com.unity.netcode.gameobjects@2.0.0

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).

## [2.0.0] - 2024-09-12

### Added

- Added tooltips for all of the `NetworkObject` component's properties. (#3052)
- Added message size validation to named and unnamed message sending functions for better error messages. (#3049)
- Added "Check for NetworkObject Component" property to the Multiplayer->Netcode for GameObjects project settings. When disabled, this will bypass the in-editor `NetworkObject` check on `NetworkBehaviour` components. (#3031)
- Added `NetworkTransform.SwitchTransformSpaceWhenParented` property that, when enabled, will handle the world to local, local to world, and local to local transform space transitions when interpolation is enabled. (#3013)
- Added `NetworkTransform.TickSyncChildren` that, when enabled, will tick synchronize nested and/or child `NetworkTransform` components to eliminate any potential visual jittering that could occur if the `NetworkTransform` instances get into a state where their state updates are landing on different network ticks. (#3013)
- Added `NetworkObject.AllowOwnerToParent` property to provide the ability to allow clients to parent owned objects when running in a client-server network topology. (#3013)
- Added `NetworkObject.SyncOwnerTransformWhenParented` property to provide a way to disable applying the server's transform information in the parenting message on the client owner instance which can be useful for owner authoritative motion models. (#3013)
- Added `NetcodeEditorBase` editor helper class to provide easier modification and extension of the SDK's components. (#3013)

### Fixed

- Fixed issue where `NetworkAnimator` would send updates to non-observer clients. (#3057)
- Fixed issue where an exception could occur when receiving a universal RPC for a `NetworkObject` that has been despawned. (#3052)
- Fixed issue where a NetworkObject hidden from a client that is then promoted to be session owner was not being synchronized with newly joining clients.(#3051)
- Fixed issue where clients could have a wrong time delta on `NetworkVariableBase` which could prevent from sending delta state updates. (#3045)
- Fixed issue where setting a prefab hash value during connection approval but not having a player prefab assigned could cause an exception when spawning a player. (#3042)
- Fixed issue where the `NetworkSpawnManager.HandleNetworkObjectShow` could throw an exception if one of the `NetworkObject` components to show was destroyed during the same frame. (#3030)
- Fixed issue where the `NetworkManagerHelper` was continuing to check for hierarchy changes when in play mode. (#3026)
- Fixed issue with newly/late joined clients and `NetworkTransform` synchronization of parented `NetworkObject` instances. (#3013)
- Fixed issue with smooth transitions between transform spaces when interpolation is enabled (requires `NetworkTransform.SwitchTransformSpaceWhenParented` to be enabled). (#3013)

### Changed

- Changed `NetworkTransformEditor` now uses `NetworkTransform` as the base type class to assure it doesn't display a foldout group when using the base `NetworkTransform` component class. (#3052)
- Changed `NetworkAnimator.Awake` is now a protected virtual method. (#3052)
- Changed  when invoking `NetworkManager.ConnectionManager.DisconnectClient` during a distributed authority session a more appropriate message is logged. (#3052)
- Changed `NetworkTransformEditor` so it now derives from `NetcodeEditorBase`. (#3013)
- Changed `NetworkRigidbodyBaseEditor` so it now derives from `NetcodeEditorBase`. (#3013)
- Changed `NetworkManagerEditor` so it now derives from `NetcodeEditorBase`. (#3013)

CHANGELOG.md

@@ -6,6 +6,87 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 
 Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).
 
+## [2.0.0] - 2024-09-12
+
+### Added
+
+- Added tooltips for all of the `NetworkObject` component's properties. (#3052)
+- Added message size validation to named and unnamed message sending functions for better error messages. (#3049)
+- Added "Check for NetworkObject Component" property to the Multiplayer->Netcode for GameObjects project settings. When disabled, this will bypass the in-editor `NetworkObject` check on `NetworkBehaviour` components. (#3031)
+- Added `NetworkTransform.SwitchTransformSpaceWhenParented` property that, when enabled, will handle the world to local, local to world, and local to local transform space transitions when interpolation is enabled. (#3013)
+- Added `NetworkTransform.TickSyncChildren` that, when enabled, will tick synchronize nested and/or child `NetworkTransform` components to eliminate any potential visual jittering that could occur if the `NetworkTransform` instances get into a state where their state updates are landing on different network ticks. (#3013)
+- Added `NetworkObject.AllowOwnerToParent` property to provide the ability to allow clients to parent owned objects when running in a client-server network topology. (#3013)
+- Added `NetworkObject.SyncOwnerTransformWhenParented` property to provide a way to disable applying the server's transform information in the parenting message on the client owner instance which can be useful for owner authoritative motion models. (#3013)
+- Added `NetcodeEditorBase` editor helper class to provide easier modification and extension of the SDK's components. (#3013)
+
+### Fixed
+
+- Fixed issue where `NetworkAnimator` would send updates to non-observer clients. (#3057)
+- Fixed issue where an exception could occur when receiving a universal RPC for a `NetworkObject` that has been despawned. (#3052)
+- Fixed issue where a NetworkObject hidden from a client that is then promoted to be session owner was not being synchronized with newly joining clients.(#3051)
+- Fixed issue where clients could have a wrong time delta on `NetworkVariableBase` which could prevent from sending delta state updates. (#3045)
+- Fixed issue where setting a prefab hash value during connection approval but not having a player prefab assigned could cause an exception when spawning a player. (#3042)
+- Fixed issue where the `NetworkSpawnManager.HandleNetworkObjectShow` could throw an exception if one of the `NetworkObject` components to show was destroyed during the same frame. (#3030)
+- Fixed issue where the `NetworkManagerHelper` was continuing to check for hierarchy changes when in play mode. (#3026)
+- Fixed issue with newly/late joined clients and `NetworkTransform` synchronization of parented `NetworkObject` instances. (#3013)
+- Fixed issue with smooth transitions between transform spaces when interpolation is enabled (requires `NetworkTransform.SwitchTransformSpaceWhenParented` to be enabled). (#3013)
+
+### Changed
+
+- Changed `NetworkTransformEditor` now uses `NetworkTransform` as the base type class to assure it doesn't display a foldout group when using the base `NetworkTransform` component class. (#3052)
+- Changed `NetworkAnimator.Awake` is now a protected virtual method. (#3052)
+- Changed  when invoking `NetworkManager.ConnectionManager.DisconnectClient` during a distributed authority session a more appropriate message is logged. (#3052)
+- Changed `NetworkTransformEditor` so it now derives from `NetcodeEditorBase`. (#3013)
+- Changed `NetworkRigidbodyBaseEditor` so it now derives from `NetcodeEditorBase`. (#3013)
+- Changed `NetworkManagerEditor` so it now derives from `NetcodeEditorBase`. (#3013)
+
+
+## [2.0.0-pre.4] - 2024-08-21
+
+### Added
+
+- Added `NetworkVariable.CheckDirtyState` that is to be used in tandem with collections in order to detect whether the collection or an item within the collection has changed. (#3004)
+
+### Fixed
+
+- Fixed issue where nested `NetworkTransform` components were not getting updated. (#3016)
+- Fixed issue by adding null checks in `NetworkVariableBase.CanClientRead` and `NetworkVariableBase.CanClientWrite` methods to ensure safe access to `NetworkBehaviour`. (#3012)
+- Fixed issue where `FixedStringSerializer<T>` was using `NetworkVariableSerialization<byte>.AreEqual` to determine if two bytes were equal causes an exception to be thrown due to no byte serializer having been defined. (#3009)
+- Fixed Issue where a state with dual triggers, inbound and outbound, could cause a false layer to layer state transition message to be sent to non-authority `NetworkAnimator` instances and cause a warning message to be logged. (#3008)
+- Fixed issue using collections within `NetworkVariable` where the collection would not detect changes to items or nested items. (#3004)
+- Fixed issue where `List`, `Dictionary`, and `HashSet` collections would not uniquely duplicate nested collections. (#3004)
+- Fixed issue where `NotAuthorityTarget` would include the service observer in the list of targets to send the RPC to as opposed to excluding the service observer as it should. (#3000)
+- Fixed issue where `ProxyRpcTargetGroup` could attempt to send a message if there were no targets to send to. (#3000)
+
+### Changed
+
+- Changed `NetworkAnimator` to automatically switch to owner authoritative mode when using a distributed authority network topology. (#3021)
+- Changed permissions exception thrown in `NetworkList` to exiting early with a logged error that is now a unified permissions message within `NetworkVariableBase`. (#3004)
+- Changed permissions exception thrown in `NetworkVariable.Value` to exiting early with a logged error that is now a unified permissions message within `NetworkVariableBase`. (#3004)
+
+
+## [2.0.0-pre.3] - 2024-07-23
+
+### Added
+- Added: `UnityTransport.GetNetworkDriver` and `UnityTransport.GetLocalEndpoint` methods to expose the driver and local endpoint being used. (#2978)
+
+### Fixed
+
+- Fixed issue where deferred despawn was causing GC allocations when converting an `IEnumerable` to a list. (#2983)
+- Fixed issue where the realtime network stats monitor was not able to display RPC traffic in release builds due to those stats being only available in development builds or the editor. (#2979)
+- Fixed issue where `NetworkManager.ScenesLoaded` was not being updated if `PostSynchronizationSceneUnloading` was set and any loaded scenes not used during synchronization were unloaded. (#2971)
+- Fixed issue where `Rigidbody2d` under Unity 6000.0.11f1 has breaking changes where `velocity` is now `linearVelocity` and `isKinematic` is replaced by `bodyType`. (#2971)
+- Fixed issue where `NetworkSpawnManager.InstantiateAndSpawn` and `NetworkObject.InstantiateAndSpawn` were not honoring the ownerClientId parameter when using a client-server network topology. (#2968)
+- Fixed issue where internal delta serialization could not have a byte serializer defined when serializing deltas for other types. Added `[GenerateSerializationForType(typeof(byte))]` to both the `NetworkVariable` and `AnticipatedNetworkVariable` classes to assure a byte serializer is defined.(#2962)
+- Fixed issue when scene management was disabled and the session owner would still try to synchronize a late joining client. (#2962)
+- Fixed issue when using a distributed authority network topology where it would allow a session owner to spawn a `NetworkObject` prior to being approved. Now, an error message is logged and the `NetworkObject` will not be spawned prior to the client being approved.  (#2962)
+- Fixed issue where attempting to spawn during `NetworkBehaviour.OnInSceneObjectsSpawned` and `NetworkBehaviour.OnNetworkSessionSynchronized` notifications would throw a collection modified exception.  (#2962)
+
+### Changed
+
+- Changed logic where clients can now set the `NetworkSceneManager` client synchronization mode when using a distributed authority network topology. (#2985)
+
+
 ## [2.0.0-pre.2] - 2024-06-17
 
 ### Added

Editor/Configuration/NetcodeForGameObjectsSettings.cs

@@ -5,6 +5,7 @@ namespace Unity.Netcode.Editor.Configuration
     internal class NetcodeForGameObjectsEditorSettings
     {
         internal const string AutoAddNetworkObjectIfNoneExists = "AutoAdd-NetworkObject-When-None-Exist";
+        internal const string CheckForNetworkObject = "NetworkBehaviour-Check-For-NetworkObject";
         internal const string InstallMultiplayerToolsTipDismissedPlayerPrefKey = "Netcode_Tip_InstallMPTools_Dismissed";
 
         internal static int GetNetcodeInstallMultiplayerToolTips()
@@ -28,7 +29,7 @@ namespace Unity.Netcode.Editor.Configuration
             {
                 return EditorPrefs.GetBool(AutoAddNetworkObjectIfNoneExists);
             }
-
+            // Default for this is false
             return false;
         }
 
@@ -36,5 +37,20 @@ namespace Unity.Netcode.Editor.Configuration
         {
             EditorPrefs.SetBool(AutoAddNetworkObjectIfNoneExists, autoAddSetting);
         }
+
+        internal static bool GetCheckForNetworkObjectSetting()
+        {
+            if (EditorPrefs.HasKey(CheckForNetworkObject))
+            {
+                return EditorPrefs.GetBool(CheckForNetworkObject);
+            }
+            // Default for this is true
+            return true;
+        }
+
+        internal static void SetCheckForNetworkObjectSetting(bool checkForNetworkObject)
+        {
+            EditorPrefs.SetBool(CheckForNetworkObject, checkForNetworkObject);
+        }
     }
 }

Editor/Configuration/NetcodeSettingsProvider.cs

@@ -81,6 +81,7 @@ namespace Unity.Netcode.Editor.Configuration
 
         internal static NetcodeSettingsLabel NetworkObjectsSectionLabel;
         internal static NetcodeSettingsToggle AutoAddNetworkObjectToggle;
+        internal static NetcodeSettingsToggle CheckForNetworkObjectToggle;
         internal static NetcodeSettingsLabel MultiplayerToolsLabel;
         internal static NetcodeSettingsToggle MultiplayerToolTipStatusToggle;
 
@@ -103,6 +104,11 @@ namespace Unity.Netcode.Editor.Configuration
                 AutoAddNetworkObjectToggle = new NetcodeSettingsToggle("Auto-Add NetworkObject Component", "When enabled, NetworkObject components are automatically added to GameObjects when NetworkBehaviour components are added first.", 20);
             }
 
+            if (CheckForNetworkObjectToggle == null)
+            {
+                CheckForNetworkObjectToggle = new NetcodeSettingsToggle("Check for NetworkObject Component", "When disabled, the automatic check on NetworkBehaviours for an associated NetworkObject component will not be performed and Auto-Add NetworkObject Component will be disabled.", 20);
+            }
+
             if (MultiplayerToolsLabel == null)
             {
                 MultiplayerToolsLabel = new NetcodeSettingsLabel("Multiplayer Tools", 20);
@@ -120,7 +126,9 @@ namespace Unity.Netcode.Editor.Configuration
             CheckForInitialize();
 
             var autoAddNetworkObjectSetting = NetcodeForGameObjectsEditorSettings.GetAutoAddNetworkObjectSetting();
+            var checkForNetworkObjectSetting = NetcodeForGameObjectsEditorSettings.GetCheckForNetworkObjectSetting();
             var multiplayerToolsTipStatus = NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() == 0;
+
             var settings = NetcodeForGameObjectsProjectSettings.instance;
             var generateDefaultPrefabs = settings.GenerateDefaultNetworkPrefabs;
             var networkPrefabsPath = settings.TempNetworkPrefabsPath;
@@ -134,7 +142,13 @@ namespace Unity.Netcode.Editor.Configuration
             {
                 GUILayout.BeginVertical("Box");
                 NetworkObjectsSectionLabel.DrawLabel();
-                autoAddNetworkObjectSetting = AutoAddNetworkObjectToggle.DrawToggle(autoAddNetworkObjectSetting);
+
+                autoAddNetworkObjectSetting = AutoAddNetworkObjectToggle.DrawToggle(autoAddNetworkObjectSetting, checkForNetworkObjectSetting);
+                checkForNetworkObjectSetting = CheckForNetworkObjectToggle.DrawToggle(checkForNetworkObjectSetting);
+                if (autoAddNetworkObjectSetting && !checkForNetworkObjectSetting)
+                {
+                    autoAddNetworkObjectSetting = false;
+                }
                 GUILayout.EndVertical();
 
                 GUILayout.BeginVertical("Box");
@@ -184,6 +198,7 @@ namespace Unity.Netcode.Editor.Configuration
             if (EditorGUI.EndChangeCheck())
             {
                 NetcodeForGameObjectsEditorSettings.SetAutoAddNetworkObjectSetting(autoAddNetworkObjectSetting);
+                NetcodeForGameObjectsEditorSettings.SetCheckForNetworkObjectSetting(checkForNetworkObjectSetting);
                 NetcodeForGameObjectsEditorSettings.SetNetcodeInstallMultiplayerToolTips(multiplayerToolsTipStatus ? 0 : 1);
                 settings.GenerateDefaultNetworkPrefabs = generateDefaultPrefabs;
                 settings.TempNetworkPrefabsPath = networkPrefabsPath;
@@ -213,10 +228,13 @@ namespace Unity.Netcode.Editor.Configuration
     {
         private GUIContent m_ToggleContent;
 
-        public bool DrawToggle(bool currentSetting)
+        public bool DrawToggle(bool currentSetting, bool enabled = true)
         {
             EditorGUIUtility.labelWidth = m_LabelSize;
-            return EditorGUILayout.Toggle(m_ToggleContent, currentSetting, m_LayoutWidth);
+            GUI.enabled = enabled;
+            var returnValue = EditorGUILayout.Toggle(m_ToggleContent, currentSetting, m_LayoutWidth);
+            GUI.enabled = true;
+            return returnValue;
         }
 
         public NetcodeSettingsToggle(string labelText, string toolTip, float layoutOffset)

Editor/NetcodeEditorBase.cs

@@ -0,0 +1,62 @@
+using System;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Netcode.Editor
+{
+    /// <summary>
+    /// The base Netcode Editor helper class to display derived <see cref="MonoBehaviour"/> based components <br />
+    /// where each child generation's properties will be displayed within a FoldoutHeaderGroup.
+    /// </summary>
+    [CanEditMultipleObjects]
+    public partial class NetcodeEditorBase<TT> : UnityEditor.Editor where TT : MonoBehaviour
+    {
+        /// <inheritdoc/>
+        public virtual void OnEnable()
+        {
+        }
+
+        /// <summary>
+        /// Helper method to draw the properties of the specified child type <typeparamref name="T"/> component within a FoldoutHeaderGroup.
+        /// </summary>
+        /// <typeparam name="T">The specific child type that should have its properties drawn.</typeparam>
+        /// <param name="type">The component type of the <see cref="UnityEditor.Editor.target"/>.</param>
+        /// <param name="displayProperties">The <see cref="Action"/> to invoke that will draw the type <typeparamref name="T"/> properties.</param>
+        /// <param name="expanded">The <typeparamref name="T"/> current expanded property value</param>
+        /// <param name="setExpandedProperty">The <see cref="Action{bool}"/> invoked to apply the updated <paramref name="expanded"/> value.</param>
+        protected void DrawFoldOutGroup<T>(Type type, Action displayProperties, bool expanded, Action<bool> setExpandedProperty)
+        {
+            var baseClass = target as TT;
+            EditorGUI.BeginChangeCheck();
+            serializedObject.Update();
+            var currentClass = typeof(T);
+            if (type.IsSubclassOf(currentClass) || (!type.IsSubclassOf(currentClass) && currentClass.IsSubclassOf(typeof(TT))))
+            {
+                var expandedValue = EditorGUILayout.BeginFoldoutHeaderGroup(expanded, $"{currentClass.Name} Properties");
+                if (expandedValue)
+                {
+                    EditorGUILayout.EndFoldoutHeaderGroup();
+                    displayProperties.Invoke();
+                }
+                else
+                {
+                    EditorGUILayout.EndFoldoutHeaderGroup();
+                }
+                EditorGUILayout.Space();
+                setExpandedProperty.Invoke(expandedValue);
+            }
+            else
+            {
+                displayProperties.Invoke();
+            }
+            serializedObject.ApplyModifiedProperties();
+            EditorGUI.EndChangeCheck();
+        }
+
+        /// <inheritdoc/>
+        public override void OnInspectorGUI()
+        {
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Editor/NetcodeEditorBase.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4ce97256a2d80f94bb340e13c71a24b8

Editor/NetworkBehaviourEditor.cs

@@ -301,9 +301,8 @@ namespace Unity.Netcode.Editor
 
                 expanded = false;
             }
-
-            serializedObject.ApplyModifiedProperties();
             EditorGUI.EndChangeCheck();
+            serializedObject.ApplyModifiedProperties();
         }
 
         /// <summary>
@@ -352,6 +351,12 @@ namespace Unity.Netcode.Editor
                 return;
             }
 
+            // If this automatic check is disabled, then do not perform this check.
+            if (!NetcodeForGameObjectsEditorSettings.GetCheckForNetworkObjectSetting())
+            {
+                return;
+            }
+
             // Now get the root parent transform to the current GameObject (or itself)
             var rootTransform = GetRootParentTransform(gameObject.transform);
             if (!rootTransform.TryGetComponent<NetworkManager>(out var networkManager))

Editor/NetworkManagerEditor.cs

@@ -13,7 +13,7 @@ namespace Unity.Netcode.Editor
     /// </summary>
     [CustomEditor(typeof(NetworkManager), true)]
     [CanEditMultipleObjects]
-    public class NetworkManagerEditor : UnityEditor.Editor
+    public class NetworkManagerEditor : NetcodeEditorBase<NetworkManager>
     {
         private static GUIStyle s_CenteredWordWrappedLabelStyle;
         private static GUIStyle s_HelpBoxStyle;
@@ -168,16 +168,8 @@ namespace Unity.Netcode.Editor
                 .FindPropertyRelative(nameof(NetworkPrefabs.NetworkPrefabsLists));
         }
 
-        /// <inheritdoc/>
-        public override void OnInspectorGUI()
+        private void DisplayNetworkManagerProperties()
         {
-            Initialize();
-            CheckNullProperties();
-
-#if !MULTIPLAYER_TOOLS
-            DrawInstallMultiplayerToolsTip();
-#endif
-
             if (!m_NetworkManager.IsServer && !m_NetworkManager.IsClient)
             {
                 serializedObject.Update();
@@ -298,9 +290,12 @@ namespace Unity.Netcode.Editor
                 }
 
                 serializedObject.ApplyModifiedProperties();
+            }
+        }
 
-
-                // Start buttons below
+        private void DisplayCallToActionButtons()
+        {
+            if (!m_NetworkManager.IsServer && !m_NetworkManager.IsClient)
             {
                 string buttonDisabledReasonSuffix = "";
 
@@ -341,7 +336,6 @@ namespace Unity.Netcode.Editor
                     GUI.enabled = true;
                 }
             }
-            }
             else
             {
                 string instanceType = string.Empty;
@@ -368,6 +362,21 @@ namespace Unity.Netcode.Editor
             }
         }
 
+        /// <inheritdoc/>
+        public override void OnInspectorGUI()
+        {
+            var networkManager = target as NetworkManager;
+            Initialize();
+            CheckNullProperties();
+#if !MULTIPLAYER_TOOLS
+            DrawInstallMultiplayerToolsTip();
+#endif
+            void SetExpanded(bool expanded) { networkManager.NetworkManagerExpanded = expanded; };
+            DrawFoldOutGroup<NetworkManager>(networkManager.GetType(), DisplayNetworkManagerProperties, networkManager.NetworkManagerExpanded, SetExpanded);
+            DisplayCallToActionButtons();
+            base.OnInspectorGUI();
+        }
+
         private static void DrawInstallMultiplayerToolsTip()
         {
             const string getToolsText = "Access additional tools for multiplayer development by installing the Multiplayer Tools package in the Package Manager.";

Editor/NetworkManagerHelper.cs

@@ -61,6 +61,12 @@ namespace Unity.Netcode.Editor
                     {
                         s_LastKnownNetworkManagerParents.Clear();
                         ScenesInBuildActiveSceneCheck();
+                        EditorApplication.hierarchyChanged -= EditorApplication_hierarchyChanged;
+                        break;
+                    }
+                case PlayModeStateChange.EnteredEditMode:
+                    {
+                        EditorApplication.hierarchyChanged += EditorApplication_hierarchyChanged;
                         break;
                     }
             }
@@ -110,6 +116,12 @@ namespace Unity.Netcode.Editor
         /// </summary>
         private static void EditorApplication_hierarchyChanged()
         {
+            if (Application.isPlaying)
+            {
+                EditorApplication.hierarchyChanged -= EditorApplication_hierarchyChanged;
+                return;
+            }
+
             var allNetworkManagers = Resources.FindObjectsOfTypeAll<NetworkManager>();
             foreach (var networkManager in allNetworkManagers)
             {

Editor/NetworkRigidbodyBaseEditor.cs

@@ -0,0 +1,42 @@
+#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
+using Unity.Netcode.Components;
+using UnityEditor;
+
+namespace Unity.Netcode.Editor
+{
+    [CustomEditor(typeof(NetworkRigidbodyBase), true)]
+    [CanEditMultipleObjects]
+    public class NetworkRigidbodyBaseEditor : NetcodeEditorBase<NetworkBehaviour>
+    {
+        private SerializedProperty m_UseRigidBodyForMotion;
+        private SerializedProperty m_AutoUpdateKinematicState;
+        private SerializedProperty m_AutoSetKinematicOnDespawn;
+
+
+        public override void OnEnable()
+        {
+            m_UseRigidBodyForMotion = serializedObject.FindProperty(nameof(NetworkRigidbodyBase.UseRigidBodyForMotion));
+            m_AutoUpdateKinematicState = serializedObject.FindProperty(nameof(NetworkRigidbodyBase.AutoUpdateKinematicState));
+            m_AutoSetKinematicOnDespawn = serializedObject.FindProperty(nameof(NetworkRigidbodyBase.AutoSetKinematicOnDespawn));
+
+            base.OnEnable();
+        }
+
+        private void DisplayNetworkRigidbodyProperties()
+        {
+            EditorGUILayout.PropertyField(m_UseRigidBodyForMotion);
+            EditorGUILayout.PropertyField(m_AutoUpdateKinematicState);
+            EditorGUILayout.PropertyField(m_AutoSetKinematicOnDespawn);
+        }
+
+        /// <inheritdoc/>
+        public override void OnInspectorGUI()
+        {
+            var networkRigidbodyBase = target as NetworkRigidbodyBase;
+            void SetExpanded(bool expanded) { networkRigidbodyBase.NetworkRigidbodyBaseExpanded = expanded; };
+            DrawFoldOutGroup<NetworkRigidbodyBase>(networkRigidbodyBase.GetType(), DisplayNetworkRigidbodyProperties, networkRigidbodyBase.NetworkRigidbodyBaseExpanded, SetExpanded);
+            base.OnInspectorGUI();
+        }
+    }
+}
+#endif

Editor/NetworkRigidbodyBaseEditor.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 06561c57f81a6354f8bb16076f1de3a9

Editor/NetworkTransformEditor.cs

@@ -8,8 +8,11 @@ namespace Unity.Netcode.Editor
     /// The <see cref="CustomEditor"/> for <see cref="NetworkTransform"/>
     /// </summary>
     [CustomEditor(typeof(NetworkTransform), true)]
-    public class NetworkTransformEditor : UnityEditor.Editor
+    [CanEditMultipleObjects]
+    public class NetworkTransformEditor : NetcodeEditorBase<NetworkTransform>
     {
+        private SerializedProperty m_SwitchTransformSpaceWhenParented;
+        private SerializedProperty m_TickSyncChildren;
         private SerializedProperty m_UseUnreliableDeltas;
         private SerializedProperty m_SyncPositionXProperty;
         private SerializedProperty m_SyncPositionYProperty;
@@ -39,8 +42,10 @@ namespace Unity.Netcode.Editor
         private static GUIContent s_ScaleLabel = EditorGUIUtility.TrTextContent("Scale");
 
         /// <inheritdoc/>
-        public virtual void OnEnable()
+        public override void OnEnable()
         {
+            m_SwitchTransformSpaceWhenParented = serializedObject.FindProperty(nameof(NetworkTransform.SwitchTransformSpaceWhenParented));
+            m_TickSyncChildren = serializedObject.FindProperty(nameof(NetworkTransform.TickSyncChildren));
             m_UseUnreliableDeltas = serializedObject.FindProperty(nameof(NetworkTransform.UseUnreliableDeltas));
             m_SyncPositionXProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionX));
             m_SyncPositionYProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionY));
@@ -61,10 +66,10 @@ namespace Unity.Netcode.Editor
             m_UseHalfFloatPrecision = serializedObject.FindProperty(nameof(NetworkTransform.UseHalfFloatPrecision));
             m_SlerpPosition = serializedObject.FindProperty(nameof(NetworkTransform.SlerpPosition));
             m_AuthorityMode = serializedObject.FindProperty(nameof(NetworkTransform.AuthorityMode));
+            base.OnEnable();
         }
 
-        /// <inheritdoc/>
-        public override void OnInspectorGUI()
+        private void DisplayNetworkTransformProperties()
         {
             var networkTransform = target as NetworkTransform;
             EditorGUILayout.LabelField("Axis to Synchronize", EditorStyles.boldLabel);
@@ -141,9 +146,15 @@ namespace Unity.Netcode.Editor
             EditorGUILayout.PropertyField(m_ScaleThresholdProperty);
             EditorGUILayout.Space();
             EditorGUILayout.LabelField("Delivery", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(m_TickSyncChildren);
             EditorGUILayout.PropertyField(m_UseUnreliableDeltas);
             EditorGUILayout.Space();
             EditorGUILayout.LabelField("Configurations", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(m_SwitchTransformSpaceWhenParented);
+            if (m_SwitchTransformSpaceWhenParented.boolValue)
+            {
+                m_TickSyncChildren.boolValue = true;
+            }
             EditorGUILayout.PropertyField(m_InLocalSpaceProperty);
             if (!networkTransform.HideInterpolateValue)
             {
@@ -163,8 +174,7 @@ namespace Unity.Netcode.Editor
 
 #if COM_UNITY_MODULES_PHYSICS
             // if rigidbody is present but network rigidbody is not present
-            var go = ((NetworkTransform)target).gameObject;
-            if (go.TryGetComponent<Rigidbody>(out _) && go.TryGetComponent<NetworkRigidbody>(out _) == false)
+            if (networkTransform.TryGetComponent<Rigidbody>(out _) && networkTransform.TryGetComponent<NetworkRigidbody>(out _) == false)
             {
                 EditorGUILayout.HelpBox("This GameObject contains a Rigidbody but no NetworkRigidbody.\n" +
                     "Add a NetworkRigidbody component to improve Rigidbody synchronization.", MessageType.Warning);
@@ -172,14 +182,23 @@ namespace Unity.Netcode.Editor
 #endif // COM_UNITY_MODULES_PHYSICS
 
 #if COM_UNITY_MODULES_PHYSICS2D
-            if (go.TryGetComponent<Rigidbody2D>(out _) && go.TryGetComponent<NetworkRigidbody2D>(out _) == false)
+            if (networkTransform.TryGetComponent<Rigidbody2D>(out _) && networkTransform.TryGetComponent<NetworkRigidbody2D>(out _) == false)
             {
                 EditorGUILayout.HelpBox("This GameObject contains a Rigidbody2D but no NetworkRigidbody2D.\n" +
                     "Add a NetworkRigidbody2D component to improve Rigidbody2D synchronization.", MessageType.Warning);
             }
 #endif // COM_UNITY_MODULES_PHYSICS2D
+        }
 
-            serializedObject.ApplyModifiedProperties();
+
+
+        /// <inheritdoc/>
+        public override void OnInspectorGUI()
+        {
+            var networkTransform = target as NetworkTransform;
+            void SetExpanded(bool expanded) { networkTransform.NetworkTransformExpanded = expanded; };
+            DrawFoldOutGroup<NetworkTransform>(networkTransform.GetType(), DisplayNetworkTransformProperties, networkTransform.NetworkTransformExpanded, SetExpanded);
+            base.OnInspectorGUI();
         }
     }
 }

Runtime/Components/AnticipatedNetworkTransform.cs

@@ -239,19 +239,13 @@ namespace Unity.Netcode.Components
             m_CurrentSmoothTime = 0;
         }
 
-        public override void OnUpdate()
+        private void ProcessSmoothing()
         {
             // If not spawned or this instance has authority, exit early
             if (!IsSpawned)
             {
                 return;
             }
-            // Do not call the base class implementation...
-            // AnticipatedNetworkTransform applies its authoritative state immediately rather than waiting for update
-            // This is because AnticipatedNetworkTransforms may need to reference each other in reanticipating
-            // and we will want all reanticipation done before anything else wants to reference the transform in
-            // OnUpdate()
-            //base.Update();
 
             if (m_CurrentSmoothTime < m_SmoothDuration)
             {
@@ -262,7 +256,7 @@ namespace Unity.Netcode.Components
                 m_AnticipatedTransform = new TransformState
                 {
                     Position = Vector3.Lerp(m_SmoothFrom.Position, m_SmoothTo.Position, pct),
-                    Rotation = Quaternion.Slerp(m_SmoothFrom.Rotation, m_SmoothTo.Rotation, pct),
+                    Rotation = Quaternion.Lerp(m_SmoothFrom.Rotation, m_SmoothTo.Rotation, pct),
                     Scale = Vector3.Lerp(m_SmoothFrom.Scale, m_SmoothTo.Scale, pct)
                 };
                 m_PreviousAnticipatedTransform = m_AnticipatedTransform;
@@ -275,6 +269,32 @@ namespace Unity.Netcode.Components
             }
         }
 
+        // TODO: This does not handle OnFixedUpdate
+        // This requires a complete overhaul in this class to switch between using
+        // NetworkRigidbody's position and rotation values.
+        public override void OnUpdate()
+        {
+            ProcessSmoothing();
+            // Do not call the base class implementation...
+            // AnticipatedNetworkTransform applies its authoritative state immediately rather than waiting for update
+            // This is because AnticipatedNetworkTransforms may need to reference each other in reanticipating
+            // and we will want all reanticipation done before anything else wants to reference the transform in
+            // OnUpdate()
+            //base.OnUpdate();
+        }
+
+        /// <summary>
+        /// Since authority does not subscribe to updates (OnUpdate or OnFixedUpdate),
+        /// we have to update every frame to assure authority processes soothing.
+        /// </summary>
+        private void Update()
+        {
+            if (CanCommitToTransform && IsSpawned)
+            {
+                ProcessSmoothing();
+            }
+        }
+
         internal class AnticipatedObject : IAnticipationEventReceiver, IAnticipatedObject
         {
             public AnticipatedNetworkTransform Transform;
@@ -347,20 +367,61 @@ namespace Unity.Netcode.Components
             m_CurrentSmoothTime = 0;
         }
 
-        protected override void OnSynchronize<T>(ref BufferSerializer<T> serializer)
+        /// <summary>
+        /// (This replaces the first OnSynchronize for NetworkTransforms)
+        /// This is needed to initialize when fully synchronized since non-authority instances
+        /// don't apply the initial synchronization (new client synchronization) until after
+        /// everything has been spawned and synchronized.
+        /// </summary>
+        protected internal override void InternalOnNetworkSessionSynchronized()
         {
-            base.OnSynchronize(ref serializer);
-            if (!CanCommitToTransform)
+            var wasSynchronizing = SynchronizeState.IsSynchronizing;
+            base.InternalOnNetworkSessionSynchronized();
+            if (!CanCommitToTransform && wasSynchronizing && !SynchronizeState.IsSynchronizing)
             {
                 m_OutstandingAuthorityChange = true;
                 ApplyAuthoritativeState();
                 ResetAnticipatedState();
+
+                m_AnticipatedObject = new AnticipatedObject { Transform = this };
+                NetworkManager.AnticipationSystem.RegisterForAnticipationEvents(m_AnticipatedObject);
+                NetworkManager.AnticipationSystem.AllAnticipatedObjects.Add(m_AnticipatedObject);
+            }
+        }
+
+        /// <summary>
+        /// (This replaces the any subsequent OnSynchronize for NetworkTransforms post client synchronization)
+        /// This occurs on already connected clients when dynamically spawning a NetworkObject for
+        /// non-authoritative instances.
+        /// </summary>
+        protected internal override void InternalOnNetworkPostSpawn()
+        {
+            base.InternalOnNetworkPostSpawn();
+            if (!CanCommitToTransform && NetworkManager.IsConnectedClient && !SynchronizeState.IsSynchronizing)
+            {
+                m_OutstandingAuthorityChange = true;
+                ApplyAuthoritativeState();
+                ResetAnticipatedState();
+                m_AnticipatedObject = new AnticipatedObject { Transform = this };
+                NetworkManager.AnticipationSystem.RegisterForAnticipationEvents(m_AnticipatedObject);
+                NetworkManager.AnticipationSystem.AllAnticipatedObjects.Add(m_AnticipatedObject);
             }
         }
 
         public override void OnNetworkSpawn()
         {
+            if (NetworkManager.DistributedAuthorityMode)
+            {
+                Debug.LogWarning($"This component is not currently supported in distributed authority.");
+            }
             base.OnNetworkSpawn();
+
+            // Non-authoritative instances exit early if the synchronization has yet to
+            // be applied at this point
+            if (SynchronizeState.IsSynchronizing && !CanCommitToTransform)
+            {
+                return;
+            }
             m_OutstandingAuthorityChange = true;
             ApplyAuthoritativeState();
             ResetAnticipatedState();

Runtime/Components/HalfVector3.cs

@@ -8,7 +8,7 @@ namespace Unity.Netcode.Components
     /// Half float precision <see cref="Vector3"/>.
     /// </summary>
     /// <remarks>
-    /// The Vector3T<ushort> values are half float values returned by <see cref="Mathf.FloatToHalf(float)"/> for each
+    /// The Vector3T&lt;ushort&gt; values are half float values returned by <see cref="Mathf.FloatToHalf(float)"/> for each
     /// individual axis and the 16 bits of the half float are stored as <see cref="ushort"/> values since C# does not have
     /// a half float type.
     /// </remarks>

Runtime/Components/HalfVector4.cs

@@ -8,7 +8,7 @@ namespace Unity.Netcode.Components
     /// Half Precision <see cref="Vector4"/> that can also be used to convert a <see cref="Quaternion"/> to half precision.
     /// </summary>
     /// <remarks>
-    /// The Vector4T<ushort> values are half float values returned by <see cref="Mathf.FloatToHalf(float)"/> for each
+    /// The Vector4T&lt;ushort&gt; values are half float values returned by <see cref="Mathf.FloatToHalf(float)"/> for each
     /// individual axis and the 16 bits of the half float are stored as <see cref="ushort"/> values since C# does not have
     /// a half float type.
     /// </remarks>

Runtime/Components/Interpolator/BufferedLinearInterpolator.cs

@@ -5,14 +5,14 @@ using UnityEngine;
 namespace Unity.Netcode
 {
     /// <summary>
-    /// Solves for incoming values that are jittered
+    /// Solves for incoming values that are jittered.
     /// Partially solves for message loss. Unclamped lerping helps hide this, but not completely
     /// </summary>
     /// <typeparam name="T">The type of interpolated value</typeparam>
     public abstract class BufferedLinearInterpolator<T> where T : struct
     {
         internal float MaxInterpolationBound = 3.0f;
-        private struct BufferedItem
+        protected internal struct BufferedItem
         {
             public T Item;
             public double TimeSent;
@@ -31,14 +31,16 @@ namespace Unity.Netcode
 
         private const double k_SmallValue = 9.999999439624929E-11; // copied from Vector3's equal operator
 
-        private T m_InterpStartValue;
-        private T m_CurrentInterpValue;
-        private T m_InterpEndValue;
+        protected internal T m_InterpStartValue;
+        protected internal T m_CurrentInterpValue;
+        protected internal T m_InterpEndValue;
 
         private double m_EndTimeConsumed;
         private double m_StartTimeConsumed;
 
-        private readonly List<BufferedItem> m_Buffer = new List<BufferedItem>(k_BufferCountLimit);
+        protected internal readonly List<BufferedItem> m_Buffer = new List<BufferedItem>(k_BufferCountLimit);
+
+
 
         // Buffer consumption scenarios
         // Perfect case consumption
@@ -73,6 +75,21 @@ namespace Unity.Netcode
 
         private bool InvalidState => m_Buffer.Count == 0 && m_LifetimeConsumedCount == 0;
 
+        internal bool EndOfBuffer => m_Buffer.Count == 0;
+
+        internal bool InLocalSpace;
+
+        protected internal virtual void OnConvertTransformSpace(Transform transform, bool inLocalSpace)
+        {
+
+        }
+
+        internal void ConvertTransformSpace(Transform transform, bool inLocalSpace)
+        {
+            OnConvertTransformSpace(transform, inLocalSpace);
+            InLocalSpace = inLocalSpace;
+        }
+
         /// <summary>
         /// Resets interpolator to initial state
         /// </summary>
@@ -351,6 +368,35 @@ namespace Unity.Netcode
                 return Quaternion.Lerp(start, end, time);
             }
         }
+
+        private Quaternion ConvertToNewTransformSpace(Transform transform, Quaternion rotation, bool inLocalSpace)
+        {
+            if (inLocalSpace)
+            {
+                return Quaternion.Inverse(transform.rotation) * rotation;
+
+            }
+            else
+            {
+                return transform.rotation * rotation;
+            }
+        }
+
+        protected internal override void OnConvertTransformSpace(Transform transform, bool inLocalSpace)
+        {
+            for (int i = 0; i < m_Buffer.Count; i++)
+            {
+                var entry = m_Buffer[i];
+                entry.Item = ConvertToNewTransformSpace(transform, entry.Item, inLocalSpace);
+                m_Buffer[i] = entry;
+            }
+
+            m_InterpStartValue = ConvertToNewTransformSpace(transform, m_InterpStartValue, inLocalSpace);
+            m_CurrentInterpValue = ConvertToNewTransformSpace(transform, m_CurrentInterpValue, inLocalSpace);
+            m_InterpEndValue = ConvertToNewTransformSpace(transform, m_InterpEndValue, inLocalSpace);
+
+            base.OnConvertTransformSpace(transform, inLocalSpace);
+        }
     }
 
     /// <summary>
@@ -388,5 +434,34 @@ namespace Unity.Netcode
                 return Vector3.Lerp(start, end, time);
             }
         }
+
+        private Vector3 ConvertToNewTransformSpace(Transform transform, Vector3 position, bool inLocalSpace)
+        {
+            if (inLocalSpace)
+            {
+                return transform.InverseTransformPoint(position);
+
+            }
+            else
+            {
+                return transform.TransformPoint(position);
+            }
+        }
+
+        protected internal override void OnConvertTransformSpace(Transform transform, bool inLocalSpace)
+        {
+            for (int i = 0; i < m_Buffer.Count; i++)
+            {
+                var entry = m_Buffer[i];
+                entry.Item = ConvertToNewTransformSpace(transform, entry.Item, inLocalSpace);
+                m_Buffer[i] = entry;
+            }
+
+            m_InterpStartValue = ConvertToNewTransformSpace(transform, m_InterpStartValue, inLocalSpace);
+            m_CurrentInterpValue = ConvertToNewTransformSpace(transform, m_CurrentInterpValue, inLocalSpace);
+            m_InterpEndValue = ConvertToNewTransformSpace(transform, m_InterpEndValue, inLocalSpace);
+
+            base.OnConvertTransformSpace(transform, inLocalSpace);
+        }
     }
 }

Runtime/Components/NetworkAnimator.cs

@@ -498,9 +498,13 @@ namespace Unity.Netcode.Components
         /// <summary>
         /// Override this method and return false to switch to owner authoritative mode
         /// </summary>
+        /// <remarks>
+        /// When using a distributed authority network topology, this will default to
+        /// owner authoritative.
+        /// </remarks>
         protected virtual bool OnIsServerAuthoritative()
         {
-            return true;
+            return NetworkManager ? !NetworkManager.DistributedAuthorityMode : true;
         }
 
         // Animators only support up to 32 parameters
@@ -580,7 +584,7 @@ namespace Unity.Netcode.Components
             base.OnDestroy();
         }
 
-        private void Awake()
+        protected virtual void Awake()
         {
             int layers = m_Animator.layerCount;
             // Initializing the below arrays for everyone handles an issue
@@ -851,7 +855,12 @@ namespace Unity.Netcode.Components
                     stateChangeDetected = true;
                     //Debug.Log($"[Cross-Fade] To-Hash: {nt.fullPathHash} | TI-Duration: ({tt.duration}) | TI-Norm: ({tt.normalizedTime}) | From-Hash: ({m_AnimationHash[layer]}) | SI-FPHash: ({st.fullPathHash}) | SI-Norm: ({st.normalizedTime})");
                 }
-                else if (!tt.anyState && tt.fullPathHash != m_TransitionHash[layer])
+                // If we are not transitioned into the "any state" and the animator transition isn't a full path hash (layer to layer) and our pre-built destination state to transition does not contain the
+                // current layer (i.e. transitioning into a state from another layer) =or= we do contain the layer and the layer contains state to transition to is contained within our pre-built destination
+                // state then we can handle this transition as a non-cross fade state transition between layers.
+                // Otherwise, if we don't enter into this then this is a "trigger transition to some state that is now being transitioned back to the Idle state via trigger" or "Dual Triggers" IDLE<-->State.
+                else if (!tt.anyState && tt.fullPathHash != m_TransitionHash[layer] && (!m_DestinationStateToTransitioninfo.ContainsKey(layer) ||
+                    (m_DestinationStateToTransitioninfo.ContainsKey(layer) && m_DestinationStateToTransitioninfo[layer].ContainsKey(nt.fullPathHash))))
                 {
                     // first time in this transition for this layer
                     m_TransitionHash[layer] = tt.fullPathHash;
@@ -860,6 +869,10 @@ namespace Unity.Netcode.Components
                     animState.CrossFade = false;
                     animState.Transition = true;
                     animState.NormalizedTime = tt.normalizedTime;
+                    if (m_DestinationStateToTransitioninfo.ContainsKey(layer) && m_DestinationStateToTransitioninfo[layer].ContainsKey(nt.fullPathHash))
+                    {
+                        animState.DestinationStateHash = nt.fullPathHash;
+                    }
                     stateChangeDetected = true;
                     //Debug.Log($"[Transition] TI-Duration: ({tt.duration}) | TI-Norm: ({tt.normalizedTime}) | From-Hash: ({m_AnimationHash[layer]}) |SI-FPHash: ({st.fullPathHash}) | SI-Norm: ({st.normalizedTime})");
                 }
@@ -939,8 +952,14 @@ namespace Unity.Netcode.Components
                 {
                     // Just notify all remote clients and not the local server
                     m_ClientSendList.Clear();
-                    m_ClientSendList.AddRange(NetworkManager.ConnectedClientsIds);
-                    m_ClientSendList.Remove(NetworkManager.LocalClientId);
+                    foreach (var clientId in NetworkManager.ConnectedClientsIds)
+                    {
+                        if (clientId == NetworkManager.LocalClientId || !NetworkObject.Observers.Contains(clientId))
+                        {
+                            continue;
+                        }
+                        m_ClientSendList.Add(clientId);
+                    }
                     m_ClientRpcParams.Send.TargetClientIds = m_ClientSendList;
                     SendAnimStateClientRpc(m_AnimationMessage, m_ClientRpcParams);
                 }
@@ -1251,9 +1270,15 @@ namespace Unity.Netcode.Components
                 if (NetworkManager.ConnectedClientsIds.Count > (IsHost ? 2 : 1))
                 {
                     m_ClientSendList.Clear();
-                    m_ClientSendList.AddRange(NetworkManager.ConnectedClientsIds);
-                    m_ClientSendList.Remove(serverRpcParams.Receive.SenderClientId);
-                    m_ClientSendList.Remove(NetworkManager.ServerClientId);
+                    foreach (var clientId in NetworkManager.ConnectedClientsIds)
+                    {
+                        if (clientId == serverRpcParams.Receive.SenderClientId || clientId == NetworkManager.ServerClientId || !NetworkObject.Observers.Contains(clientId))
+                        {
+                            continue;
+                        }
+                        m_ClientSendList.Add(clientId);
+                    }
+
                     m_ClientRpcParams.Send.TargetClientIds = m_ClientSendList;
                     m_NetworkAnimatorStateChangeHandler.SendParameterUpdate(parametersUpdate, m_ClientRpcParams);
                 }
@@ -1308,9 +1333,14 @@ namespace Unity.Netcode.Components
                 if (NetworkManager.ConnectedClientsIds.Count > (IsHost ? 2 : 1))
                 {
                     m_ClientSendList.Clear();
-                    m_ClientSendList.AddRange(NetworkManager.ConnectedClientsIds);
-                    m_ClientSendList.Remove(serverRpcParams.Receive.SenderClientId);
-                    m_ClientSendList.Remove(NetworkManager.ServerClientId);
+                    foreach (var clientId in NetworkManager.ConnectedClientsIds)
+                    {
+                        if (clientId == serverRpcParams.Receive.SenderClientId || clientId == NetworkManager.ServerClientId || !NetworkObject.Observers.Contains(clientId))
+                        {
+                            continue;
+                        }
+                        m_ClientSendList.Add(clientId);
+                    }
                     m_ClientRpcParams.Send.TargetClientIds = m_ClientSendList;
                     m_NetworkAnimatorStateChangeHandler.SendAnimationUpdate(animationMessage, m_ClientRpcParams);
                 }
@@ -1377,9 +1407,14 @@ namespace Unity.Netcode.Components
             InternalSetTrigger(animationTriggerMessage.Hash, animationTriggerMessage.IsTriggerSet);
 
             m_ClientSendList.Clear();
-            m_ClientSendList.AddRange(NetworkManager.ConnectedClientsIds);
-            m_ClientSendList.Remove(NetworkManager.ServerClientId);
-
+            foreach (var clientId in NetworkManager.ConnectedClientsIds)
+            {
+                if (clientId == NetworkManager.ServerClientId || !NetworkObject.Observers.Contains(clientId))
+                {
+                    continue;
+                }
+                m_ClientSendList.Add(clientId);
+            }
             if (IsServerAuthoritative())
             {
                 m_NetworkAnimatorStateChangeHandler.QueueTriggerUpdateToClient(animationTriggerMessage, m_ClientRpcParams);

Runtime/Components/NetworkRigidBodyBase.cs

@@ -1,4 +1,4 @@
-#if COM_UNITY_MODULES_PHYSICS
+#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
 using System.Runtime.CompilerServices;
 using UnityEngine;
 
@@ -14,6 +14,12 @@ namespace Unity.Netcode.Components
     /// </remarks>
     public abstract class NetworkRigidbodyBase : NetworkBehaviour
     {
+#if UNITY_EDITOR
+        [HideInInspector]
+        [SerializeField]
+        internal bool NetworkRigidbodyBaseExpanded;
+#endif
+
         /// <summary>
         /// When enabled, the associated <see cref="NetworkTransform"/> will use the Rigidbody/Rigidbody2D to apply and synchronize changes in position, rotation, and
         /// allows for the use of Rigidbody interpolation/extrapolation.
@@ -42,8 +48,10 @@ namespace Unity.Netcode.Components
         private bool m_IsRigidbody2D => RigidbodyType == RigidbodyTypes.Rigidbody2D;
         // Used to cache the authority state of this Rigidbody during the last frame
         private bool m_IsAuthority;
-        private Rigidbody m_Rigidbody;
-        private Rigidbody2D m_Rigidbody2D;
+
+        protected internal Rigidbody m_InternalRigidbody { get; private set; }
+        protected internal Rigidbody2D m_InternalRigidbody2D { get; private set; }
+
         internal NetworkTransform NetworkTransform;
         private float m_TickFrequency;
         private float m_TickRate;
@@ -87,18 +95,18 @@ namespace Unity.Netcode.Components
                 return;
             }
             RigidbodyType = rigidbodyType;
-            m_Rigidbody2D = rigidbody2D;
-            m_Rigidbody = rigidbody;
+            m_InternalRigidbody2D = rigidbody2D;
+            m_InternalRigidbody = rigidbody;
             NetworkTransform = networkTransform;
 
-            if (m_IsRigidbody2D && m_Rigidbody2D == null)
+            if (m_IsRigidbody2D && m_InternalRigidbody2D == null)
             {
-                m_Rigidbody2D = GetComponent<Rigidbody2D>();
+                m_InternalRigidbody2D = GetComponent<Rigidbody2D>();
 
             }
-            else if (m_Rigidbody == null)
+            else if (m_InternalRigidbody == null)
             {
-                m_Rigidbody = GetComponent<Rigidbody>();
+                m_InternalRigidbody = GetComponent<Rigidbody>();
             }
 
             SetOriginalInterpolation();
@@ -177,11 +185,15 @@ namespace Unity.Netcode.Components
         {
             if (m_IsRigidbody2D)
             {
-                m_Rigidbody2D.velocity = linearVelocity;
+#if COM_UNITY_MODULES_PHYSICS2D_LINEAR
+                m_InternalRigidbody2D.linearVelocity = linearVelocity;
+#else
+                m_InternalRigidbody2D.velocity = linearVelocity;
+#endif
             }
             else
             {
-                m_Rigidbody.linearVelocity = linearVelocity;
+                m_InternalRigidbody.linearVelocity = linearVelocity;
             }
         }
 
@@ -197,11 +209,15 @@ namespace Unity.Netcode.Components
         {
             if (m_IsRigidbody2D)
             {
-                return m_Rigidbody2D.velocity;
+#if COM_UNITY_MODULES_PHYSICS2D_LINEAR
+                return m_InternalRigidbody2D.linearVelocity;
+#else
+                return m_InternalRigidbody2D.velocity;
+#endif
             }
             else
             {
-                return m_Rigidbody.linearVelocity;
+                return m_InternalRigidbody.linearVelocity;
             }
         }
 
@@ -218,11 +234,11 @@ namespace Unity.Netcode.Components
         {
             if (m_IsRigidbody2D)
             {
-                m_Rigidbody2D.angularVelocity = angularVelocity.z;
+                m_InternalRigidbody2D.angularVelocity = angularVelocity.z;
             }
             else
             {
-                m_Rigidbody.angularVelocity = angularVelocity;
+                m_InternalRigidbody.angularVelocity = angularVelocity;
             }
         }
 
@@ -238,11 +254,11 @@ namespace Unity.Netcode.Components
         {
             if (m_IsRigidbody2D)
             {
-                return Vector3.forward * m_Rigidbody2D.velocity;
+                return Vector3.forward * m_InternalRigidbody2D.angularVelocity;
             }
             else
             {
-                return m_Rigidbody.angularVelocity;
+                return m_InternalRigidbody.angularVelocity;
             }
         }
 
@@ -255,11 +271,11 @@ namespace Unity.Netcode.Components
         {
             if (m_IsRigidbody2D)
             {
-                return m_Rigidbody2D.position;
+                return m_InternalRigidbody2D.position;
             }
             else
             {
-                return m_Rigidbody.position;
+                return m_InternalRigidbody.position;
             }
         }
 
@@ -274,13 +290,13 @@ namespace Unity.Netcode.Components
             {
                 var quaternion = Quaternion.identity;
                 var angles = quaternion.eulerAngles;
-                angles.z = m_Rigidbody2D.rotation;
+                angles.z = m_InternalRigidbody2D.rotation;
                 quaternion.eulerAngles = angles;
                 return quaternion;
             }
             else
             {
-                return m_Rigidbody.rotation;
+                return m_InternalRigidbody.rotation;
             }
         }
 
@@ -293,11 +309,11 @@ namespace Unity.Netcode.Components
         {
             if (m_IsRigidbody2D)
             {
-                m_Rigidbody2D.MovePosition(position);
+                m_InternalRigidbody2D.MovePosition(position);
             }
             else
             {
-                m_Rigidbody.MovePosition(position);
+                m_InternalRigidbody.MovePosition(position);
             }
         }
 
@@ -310,11 +326,11 @@ namespace Unity.Netcode.Components
         {
             if (m_IsRigidbody2D)
             {
-                m_Rigidbody2D.position = position;
+                m_InternalRigidbody2D.position = position;
             }
             else
             {
-                m_Rigidbody.position = position;
+                m_InternalRigidbody.position = position;
             }
         }
 
@@ -326,13 +342,13 @@ namespace Unity.Netcode.Components
         {
             if (m_IsRigidbody2D)
             {
-                m_Rigidbody2D.position = transform.position;
-                m_Rigidbody2D.rotation = transform.eulerAngles.z;
+                m_InternalRigidbody2D.position = transform.position;
+                m_InternalRigidbody2D.rotation = transform.eulerAngles.z;
             }
             else
             {
-                m_Rigidbody.position = transform.position;
-                m_Rigidbody.rotation = transform.rotation;
+                m_InternalRigidbody.position = transform.position;
+                m_InternalRigidbody.rotation = transform.rotation;
             }
         }
 
@@ -350,9 +366,9 @@ namespace Unity.Netcode.Components
             {
                 var quaternion = Quaternion.identity;
                 var angles = quaternion.eulerAngles;
-                angles.z = m_Rigidbody2D.rotation;
+                angles.z = m_InternalRigidbody2D.rotation;
                 quaternion.eulerAngles = angles;
-                m_Rigidbody2D.MoveRotation(quaternion);
+                m_InternalRigidbody2D.MoveRotation(quaternion);
             }
             else
             {
@@ -367,7 +383,7 @@ namespace Unity.Netcode.Components
                 {
                     rotation.Normalize();
                 }
-                m_Rigidbody.MoveRotation(rotation);
+                m_InternalRigidbody.MoveRotation(rotation);
             }
         }
 
@@ -380,11 +396,11 @@ namespace Unity.Netcode.Components
         {
             if (m_IsRigidbody2D)
             {
-                m_Rigidbody2D.rotation = rotation.eulerAngles.z;
+                m_InternalRigidbody2D.rotation = rotation.eulerAngles.z;
             }
             else
             {
-                m_Rigidbody.rotation = rotation;
+                m_InternalRigidbody.rotation = rotation;
             }
         }
 
@@ -396,7 +412,7 @@ namespace Unity.Netcode.Components
         {
             if (m_IsRigidbody2D)
             {
-                switch (m_Rigidbody2D.interpolation)
+                switch (m_InternalRigidbody2D.interpolation)
                 {
                     case RigidbodyInterpolation2D.None:
                         {
@@ -417,7 +433,7 @@ namespace Unity.Netcode.Components
             }
             else
             {
-                switch (m_Rigidbody.interpolation)
+                switch (m_InternalRigidbody.interpolation)
                 {
                     case RigidbodyInterpolation.None:
                         {
@@ -446,16 +462,16 @@ namespace Unity.Netcode.Components
         {
             if (m_IsRigidbody2D)
             {
-                if (m_Rigidbody2D.IsSleeping())
+                if (m_InternalRigidbody2D.IsSleeping())
                 {
-                    m_Rigidbody2D.WakeUp();
+                    m_InternalRigidbody2D.WakeUp();
                 }
             }
             else
             {
-                if (m_Rigidbody.IsSleeping())
+                if (m_InternalRigidbody.IsSleeping())
                 {
-                    m_Rigidbody.WakeUp();
+                    m_InternalRigidbody.WakeUp();
                 }
             }
         }
@@ -468,11 +484,11 @@ namespace Unity.Netcode.Components
         {
             if (m_IsRigidbody2D)
             {
-                m_Rigidbody2D.Sleep();
+                m_InternalRigidbody2D.Sleep();
             }
             else
             {
-                m_Rigidbody.Sleep();
+                m_InternalRigidbody.Sleep();
             }
         }
 
@@ -481,11 +497,11 @@ namespace Unity.Netcode.Components
         {
             if (m_IsRigidbody2D)
             {
-                return m_Rigidbody2D.isKinematic;
+                return m_InternalRigidbody2D.bodyType == RigidbodyType2D.Kinematic;
             }
             else
             {
-                return m_Rigidbody.isKinematic;
+                return m_InternalRigidbody.isKinematic;
             }
         }
 
@@ -510,11 +526,11 @@ namespace Unity.Netcode.Components
         {
             if (m_IsRigidbody2D)
             {
-                m_Rigidbody2D.isKinematic = isKinematic;
+                m_InternalRigidbody2D.bodyType = isKinematic ? RigidbodyType2D.Kinematic : RigidbodyType2D.Dynamic;
             }
             else
             {
-                m_Rigidbody.isKinematic = isKinematic;
+                m_InternalRigidbody.isKinematic = isKinematic;
             }
 
             // If we are not spawned, then exit early
@@ -531,7 +547,7 @@ namespace Unity.Netcode.Components
                     if (IsKinematic())
                     {
                         // If not already set to interpolate then set the Rigidbody to interpolate 
-                        if (m_Rigidbody.interpolation == RigidbodyInterpolation.Extrapolate)
+                        if (m_InternalRigidbody.interpolation == RigidbodyInterpolation.Extrapolate)
                         {
                             // Sleep until the next fixed update when switching from extrapolation to interpolation
                             SleepRigidbody();
@@ -560,11 +576,11 @@ namespace Unity.Netcode.Components
                     {
                         if (m_IsRigidbody2D)
                         {
-                            m_Rigidbody2D.interpolation = RigidbodyInterpolation2D.None;
+                            m_InternalRigidbody2D.interpolation = RigidbodyInterpolation2D.None;
                         }
                         else
                         {
-                            m_Rigidbody.interpolation = RigidbodyInterpolation.None;
+                            m_InternalRigidbody.interpolation = RigidbodyInterpolation.None;
                         }
                         break;
                     }
@@ -572,11 +588,11 @@ namespace Unity.Netcode.Components
                     {
                         if (m_IsRigidbody2D)
                         {
-                            m_Rigidbody2D.interpolation = RigidbodyInterpolation2D.Interpolate;
+                            m_InternalRigidbody2D.interpolation = RigidbodyInterpolation2D.Interpolate;
                         }
                         else
                         {
-                            m_Rigidbody.interpolation = RigidbodyInterpolation.Interpolate;
+                            m_InternalRigidbody.interpolation = RigidbodyInterpolation.Interpolate;
                         }
                         break;
                     }
@@ -584,11 +600,11 @@ namespace Unity.Netcode.Components
                     {
                         if (m_IsRigidbody2D)
                         {
-                            m_Rigidbody2D.interpolation = RigidbodyInterpolation2D.Extrapolate;
+                            m_InternalRigidbody2D.interpolation = RigidbodyInterpolation2D.Extrapolate;
                         }
                         else
                         {
-                            m_Rigidbody.interpolation = RigidbodyInterpolation.Extrapolate;
+                            m_InternalRigidbody.interpolation = RigidbodyInterpolation.Extrapolate;
                         }
                         break;
                     }
@@ -703,24 +719,28 @@ namespace Unity.Netcode.Components
         private void ApplyFixedJoint2D(NetworkRigidbodyBase bodyToConnect, Vector3 position, float connectedMassScale = 0.0f, float massScale = 1.0f, bool useGravity = false, bool zeroVelocity = true)
         {
             transform.position = position;
-            m_Rigidbody2D.position = position;
-            m_OriginalGravitySetting = bodyToConnect.m_Rigidbody.useGravity;
+            m_InternalRigidbody2D.position = position;
+            m_OriginalGravitySetting = bodyToConnect.m_InternalRigidbody.useGravity;
             m_FixedJoint2DUsingGravity = useGravity;
 
             if (!useGravity)
             {
-                m_OriginalGravityScale = m_Rigidbody2D.gravityScale;
-                m_Rigidbody2D.gravityScale = 0.0f;
+                m_OriginalGravityScale = m_InternalRigidbody2D.gravityScale;
+                m_InternalRigidbody2D.gravityScale = 0.0f;
             }
 
             if (zeroVelocity)
             {
-                m_Rigidbody2D.velocity = Vector2.zero;
-                m_Rigidbody2D.angularVelocity = 0.0f;
+#if COM_UNITY_MODULES_PHYSICS2D_LINEAR
+                m_InternalRigidbody2D.linearVelocity = Vector2.zero;
+#else
+                m_InternalRigidbody2D.velocity = Vector2.zero;
+#endif
+                m_InternalRigidbody2D.angularVelocity = 0.0f;
             }
 
             FixedJoint2D = gameObject.AddComponent<FixedJoint2D>();
-            FixedJoint2D.connectedBody = bodyToConnect.m_Rigidbody2D;
+            FixedJoint2D.connectedBody = bodyToConnect.m_InternalRigidbody2D;
             OnFixedJoint2DCreated();
         }
 
@@ -728,16 +748,16 @@ namespace Unity.Netcode.Components
         private void ApplyFixedJoint(NetworkRigidbodyBase bodyToConnectTo, Vector3 position, float connectedMassScale = 0.0f, float massScale = 1.0f, bool useGravity = false, bool zeroVelocity = true)
         {
             transform.position = position;
-            m_Rigidbody.position = position;
+            m_InternalRigidbody.position = position;
             if (zeroVelocity)
             {
-                m_Rigidbody.linearVelocity = Vector3.zero;
-                m_Rigidbody.angularVelocity = Vector3.zero;
+                m_InternalRigidbody.linearVelocity = Vector3.zero;
+                m_InternalRigidbody.angularVelocity = Vector3.zero;
             }
-            m_OriginalGravitySetting = m_Rigidbody.useGravity;
-            m_Rigidbody.useGravity = useGravity;
+            m_OriginalGravitySetting = m_InternalRigidbody.useGravity;
+            m_InternalRigidbody.useGravity = useGravity;
             FixedJoint = gameObject.AddComponent<FixedJoint>();
-            FixedJoint.connectedBody = bodyToConnectTo.m_Rigidbody;
+            FixedJoint.connectedBody = bodyToConnectTo.m_InternalRigidbody;
             FixedJoint.connectedMassScale = connectedMassScale;
             FixedJoint.massScale = massScale;
             OnFixedJointCreated();
@@ -849,7 +869,7 @@ namespace Unity.Netcode.Components
                     if (FixedJoint != null)
                     {
                         FixedJoint.connectedBody = null;
-                        m_Rigidbody.useGravity = m_OriginalGravitySetting;
+                        m_InternalRigidbody.useGravity = m_OriginalGravitySetting;
                         Destroy(FixedJoint);
                         FixedJoint = null;
                         ResetInterpolation();

Runtime/Components/NetworkRigidbody.cs

@@ -12,6 +12,9 @@ namespace Unity.Netcode.Components
     [AddComponentMenu("Netcode/Network Rigidbody")]
     public class NetworkRigidbody : NetworkRigidbodyBase
     {
+
+        public Rigidbody Rigidbody => m_InternalRigidbody;
+
         protected virtual void Awake()
         {
             Initialize(RigidbodyTypes.Rigidbody);

Runtime/Components/NetworkRigidbody2D.cs

@@ -12,6 +12,7 @@ namespace Unity.Netcode.Components
     [AddComponentMenu("Netcode/Network Rigidbody 2D")]
     public class NetworkRigidbody2D : NetworkRigidbodyBase
     {
+        public Rigidbody2D Rigidbody2D => m_InternalRigidbody2D;
         protected virtual void Awake()
         {
             Initialize(RigidbodyTypes.Rigidbody2D);

Runtime/Configuration/NetworkConfig.cs

@@ -159,9 +159,21 @@ namespace Unity.Netcode
         public bool AutoSpawnPlayerPrefabClientSide = true;
 
 #if MULTIPLAYER_TOOLS
+        /// <summary>
+        /// Controls whether network messaging metrics will be gathered. (defaults to true)
+        /// There is a slight performance cost to having this enabled, and can increase in processing time based on network message traffic.
+        /// </summary>
+        /// <remarks>
+        /// The Realtime Network Stats Monitoring tool requires this to be enabled.
+        /// </remarks>
+        [Tooltip("Enable (default) if you want to gather messaging metrics. Realtime Network Stats Monitor requires this to be enabled. Disabling this can improve performance in release builds.")]
         public bool NetworkMessageMetrics = true;
 #endif
-
+        /// <summary>
+        /// When enabled (default, this enables network profiling information. This does come with a per message processing cost.
+        /// Network profiling information is automatically disabled in release builds.
+        /// </summary>
+        [Tooltip("Enable (default) if you want to profile network messages with development builds and defaults to being disabled in release builds. When disabled, network messaging profiling will be disabled in development builds.")]
         public bool NetworkProfilingMetrics = true;
 
         /// <summary>

Runtime/Connection/NetworkConnectionManager.cs

@@ -735,42 +735,23 @@ namespace Unity.Netcode
                 RemovePendingClient(ownerClientId);
 
                 var client = AddClient(ownerClientId);
-                if (!NetworkManager.DistributedAuthorityMode && response.CreatePlayerObject && NetworkManager.NetworkConfig.PlayerPrefab != null)
-                {
-                    var prefabNetworkObject = NetworkManager.NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>();
-                    var playerPrefabHash = response.PlayerPrefabHash ?? prefabNetworkObject.GlobalObjectIdHash;
 
-                    // Generate a SceneObject for the player object to spawn
-                    // Note: This is only to create the local NetworkObject, many of the serialized properties of the player prefab will be set when instantiated.
-                    var sceneObject = new NetworkObject.SceneObject
+                // Server-side spawning (only if there is a prefab hash or player prefab provided)
+                if (!NetworkManager.DistributedAuthorityMode && response.CreatePlayerObject && (response.PlayerPrefabHash.HasValue || NetworkManager.NetworkConfig.PlayerPrefab != null))
                 {
-                        OwnerClientId = ownerClientId,
-                        IsPlayerObject = true,
-                        IsSceneObject = false,
-                        HasTransform = prefabNetworkObject.SynchronizeTransform,
-                        Hash = playerPrefabHash,
-                        TargetClientId = ownerClientId,
-                        DontDestroyWithOwner = prefabNetworkObject.DontDestroyWithOwner,
-                        Transform = new NetworkObject.SceneObject.TransformData
-                        {
-                            Position = response.Position.GetValueOrDefault(),
-                            Rotation = response.Rotation.GetValueOrDefault()
-                        }
-                    };
-
-                    // Create the player NetworkObject locally
-                    var networkObject = NetworkManager.SpawnManager.CreateLocalNetworkObject(sceneObject);
+                    var playerObject = response.PlayerPrefabHash.HasValue ? NetworkManager.SpawnManager.GetNetworkObjectToSpawn(response.PlayerPrefabHash.Value, ownerClientId, response.Position.GetValueOrDefault(), response.Rotation.GetValueOrDefault())
+                        : NetworkManager.SpawnManager.GetNetworkObjectToSpawn(NetworkManager.NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash, ownerClientId, response.Position.GetValueOrDefault(), response.Rotation.GetValueOrDefault());
 
                     // Spawn the player NetworkObject locally
                     NetworkManager.SpawnManager.SpawnNetworkObjectLocally(
-                        networkObject,
+                        playerObject,
                         NetworkManager.SpawnManager.GetNetworkObjectId(),
                         sceneObject: false,
                         playerObject: true,
                         ownerClientId,
                         destroyWithScene: false);
 
-                    client.AssignPlayerObject(ref networkObject);
+                    client.AssignPlayerObject(ref playerObject);
                 }
 
                 // Server doesn't send itself the connection approved message
@@ -871,6 +852,7 @@ namespace Unity.Netcode
                     }
                 }
 
+                // Exit early if no player object was spawned
                 if (!response.CreatePlayerObject || (response.PlayerPrefabHash == null && NetworkManager.NetworkConfig.PlayerPrefab == null))
                 {
                     return;
@@ -1003,10 +985,18 @@ namespace Unity.Netcode
                 ConnectedClientIds.Add(clientId);
             }
 
+            var distributedAuthority = NetworkManager.DistributedAuthorityMode;
+            var sessionOwnerId = NetworkManager.CurrentSessionOwner;
+            var isSessionOwner = NetworkManager.LocalClient.IsSessionOwner;
             foreach (var networkObject in NetworkManager.SpawnManager.SpawnedObjectsList)
             {
                 if (networkObject.SpawnWithObservers)
                 {
+                    // Don't add the client to the observers if hidden from the session owner
+                    if (networkObject.IsOwner && distributedAuthority && !isSessionOwner && !networkObject.Observers.Contains(sessionOwnerId))
+                    {
+                        continue;
+                    }
                     networkObject.Observers.Add(clientId);
                 }
             }
@@ -1308,9 +1298,17 @@ namespace Unity.Netcode
         internal void DisconnectClient(ulong clientId, string reason = null)
         {
             if (!LocalClient.IsServer)
+            {
+                if (NetworkManager.NetworkConfig.NetworkTopology == NetworkTopologyTypes.ClientServer)
                 {
                     throw new NotServerException($"Only server can disconnect remote clients. Please use `{nameof(Shutdown)}()` instead.");
                 }
+                else
+                {
+                    Debug.LogWarning($"Currently, clients cannot disconnect other clients from a distributed authority session. Please use `{nameof(Shutdown)}()` instead.");
+                    return;
+                }
+            }
 
             if (clientId == NetworkManager.ServerClientId)
             {

Runtime/Core/NetworkBehaviour.cs

@@ -15,10 +15,16 @@ namespace Unity.Netcode
     }
 
     /// <summary>
-    /// The base class to override to write network code. Inherits MonoBehaviour
+    /// The base class to override to write network code. Inherits MonoBehaviour.
     /// </summary>
     public abstract class NetworkBehaviour : MonoBehaviour
     {
+#if UNITY_EDITOR
+        [HideInInspector]
+        [SerializeField]
+        internal bool ShowTopMostFoldoutHeaderGroup = true;
+#endif
+
 #pragma warning disable IDE1006 // disable naming rule violation check
 
         // RuntimeAccessModifiersILPP will make this `public`
@@ -27,7 +33,7 @@ namespace Unity.Netcode
         // RuntimeAccessModifiersILPP will make this `public`
         internal static readonly Dictionary<Type, Dictionary<uint, RpcReceiveHandler>> __rpc_func_table = new Dictionary<Type, Dictionary<uint, RpcReceiveHandler>>();
 
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
         // RuntimeAccessModifiersILPP will make this `public`
         internal static readonly Dictionary<Type, Dictionary<uint, string>> __rpc_name_table = new Dictionary<Type, Dictionary<uint, string>>();
 #endif
@@ -124,7 +130,7 @@ namespace Unity.Netcode
             }
 
             bufferWriter.Dispose();
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
             if (__rpc_name_table[GetType()].TryGetValue(rpcMethodId, out var rpcMethodName))
             {
                 NetworkManager.NetworkMetrics.TrackRpcSent(
@@ -252,7 +258,7 @@ namespace Unity.Netcode
             }
 
             bufferWriter.Dispose();
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
             if (__rpc_name_table[GetType()].TryGetValue(rpcMethodId, out var rpcMethodName))
             {
                 if (clientRpcParams.Send.TargetClientIds != null)
@@ -410,8 +416,8 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Gets the NetworkManager that owns this NetworkBehaviour instance
-        ///   See note around `NetworkObject` for how there is a chicken / egg problem when we are not initialized
+        /// Gets the NetworkManager that owns this NetworkBehaviour instance.
+        /// See `NetworkObject` note for how there is a chicken/egg problem when not initialized.
         /// </summary>
         public NetworkManager NetworkManager
         {
@@ -439,38 +445,40 @@ namespace Unity.Netcode
         /// <see cref="Unity.Netcode.RpcTarget.Not(NativeArray{ulong})"/>,
         /// <see cref="Unity.Netcode.RpcTarget.Not(NativeList{ulong})"/>,
         /// <see cref="Unity.Netcode.RpcTarget.Not(ulong[])"/>, and
-        /// <see cref="Unity.Netcode.RpcTarget.Not{T}(T)"/>
+        /// <see cref="Unity.Netcode.RpcTarget.Not{T}(T)"/>.
         /// </summary>
 #pragma warning restore IDE0001
         public RpcTarget RpcTarget => NetworkManager.RpcTarget;
 
         /// <summary>
-        /// If a NetworkObject is assigned, it will return whether or not this NetworkObject
-        /// is the local player object.  If no NetworkObject is assigned it will always return false.
+        /// If a NetworkObject is assigned, returns whether the NetworkObject
+        /// is the local player object. If no NetworkObject is assigned, returns false.
         /// </summary>
         public bool IsLocalPlayer { get; private set; }
 
         /// <summary>
-        /// Gets if the object is owned by the local player or if the object is the local player object
+        /// Gets whether the object is owned by the local player or if the object is the local player object.
         /// </summary>
         public bool IsOwner { get; internal set; }
 
         /// <summary>
-        /// Gets if we are executing as server
+        /// Gets whether executing as a server.
         /// </summary>
         public bool IsServer { get; private set; }
 
         /// <summary>
-        /// Determines if the local client has authority over the associated NetworkObject
-        /// Client-Server: This will return true if IsServer or IsHost
-        /// Distributed Authority: This will return true if IsOwner
+        /// Determines if the local client has authority over the associated NetworkObject.
+        /// <list type="bullet">
+        /// <item>In client-server contexts: returns true if `IsServer` or `IsHost`.</item>
+        /// <item>In distributed authority contexts: returns true if `IsOwner`.</item>
+        /// </list>
         /// </summary>
         public bool HasAuthority { get; internal set; }
 
         internal NetworkClient LocalClient { get; private set; }
 
         /// <summary>
-        /// Gets if the client is the distributed authority mode session owner
+        /// Gets whether the client is the distributed authority mode session owner.
         /// </summary>
         public bool IsSessionOwner
         {
@@ -486,29 +494,29 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Gets if the server (local or remote) is a host - i.e., also a client
+        /// Gets whether the server (local or remote) is a host.
         /// </summary>
         public bool ServerIsHost { get; private set; }
 
         /// <summary>
-        /// Gets if we are executing as client
+        /// Gets whether executing as a client.
         /// </summary>
         public bool IsClient { get; private set; }
 
 
         /// <summary>
-        /// Gets if we are executing as Host, I.E Server and Client
+        /// Gets whether executing as a host (both server and client).
         /// </summary>
         public bool IsHost { get; private set; }
 
         /// <summary>
-        /// Gets Whether or not the object has a owner
+        /// Gets whether the object has an owner.
         /// </summary>
         public bool IsOwnedByServer { get; internal set; }
 
         /// <summary>
-        /// Used to determine if it is safe to access NetworkObject and NetworkManager from within a NetworkBehaviour component
-        /// Primarily useful when checking NetworkObject/NetworkManager properties within FixedUpate
+        /// Determines whether it's safe to access a NetworkObject and NetworkManager from within a NetworkBehaviour component.
+        /// Primarily useful when checking NetworkObject or NetworkManager properties within FixedUpate.
         /// </summary>
         public bool IsSpawned { get; internal set; }
 
@@ -528,7 +536,7 @@ namespace Unity.Netcode
         ///   the warning below.  This is why IsBehaviourEditable had to be created.  Matt was going to re-do
         ///   how NetworkObject works but it was close to the release and too risky to change
         /// <summary>
-        /// Gets the NetworkObject that owns this NetworkBehaviour instance
+        /// Gets the NetworkObject that owns this NetworkBehaviour instance.
         /// </summary>
         public NetworkObject NetworkObject
         {
@@ -567,19 +575,19 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Gets whether or not this NetworkBehaviour instance has a NetworkObject owner.
+        /// Gets whether this NetworkBehaviour instance has a NetworkObject owner.
         /// </summary>
         public bool HasNetworkObject => NetworkObject != null;
 
         private NetworkObject m_NetworkObject = null;
 
         /// <summary>
-        /// Gets the NetworkId of the NetworkObject that owns this NetworkBehaviour
+        /// Gets the NetworkId of the NetworkObject that owns this NetworkBehaviour instance.
         /// </summary>
         public ulong NetworkObjectId { get; internal set; }
 
         /// <summary>
-        /// Gets NetworkId for this NetworkBehaviour from the owner NetworkObject
+        /// Gets NetworkId for this NetworkBehaviour from the owner NetworkObject.
         /// </summary>
         public ushort NetworkBehaviourId { get; internal set; }
 
@@ -589,7 +597,7 @@ namespace Unity.Netcode
         internal ushort NetworkBehaviourIdCache = 0;
 
         /// <summary>
-        /// Returns a the NetworkBehaviour with a given BehaviourId for the current NetworkObject
+        /// Returns the NetworkBehaviour with a given BehaviourId for the current NetworkObject.
         /// </summary>
         /// <param name="behaviourId">The behaviourId to return</param>
         /// <returns>Returns NetworkBehaviour with given behaviourId</returns>
@@ -599,7 +607,7 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Gets the ClientId that owns the NetworkObject
+        /// Gets the ClientId that owns this NetworkObject.
         /// </summary>
         public ulong OwnerClientId { get; internal set; }
 
@@ -651,28 +659,29 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Distributed Authority Mode Only
+        /// Only for use in distributed authority mode.
         /// Invoked only on the authority instance when a <see cref="NetworkObject"/> is deferring its despawn on non-authoritative instances.
         /// </summary>
         /// <remarks>
         /// See also: <see cref="NetworkObject.DeferDespawn(int, bool)"/>
         /// </remarks>
-        /// <param name="despawnTick">the future network tick that the <see cref="NetworkObject"/> will be despawned on non-authoritative instances</param>
+        /// <param name="despawnTick">The future network tick that the <see cref="NetworkObject"/> will be despawned on non-authoritative instances</param>
         public virtual void OnDeferringDespawn(int despawnTick) { }
 
+        /// <summary>
         /// Gets called after the <see cref="NetworkObject"/> is spawned. No NetworkBehaviours associated with the NetworkObject will have had <see cref="OnNetworkSpawn"/> invoked yet.
-        /// A reference to <see cref="NetworkManager"/> is passed in as a parameter to determine the context of execution (IsServer/IsClient)
+        /// A reference to <see cref="NetworkManager"/> is passed in as a parameter to determine the context of execution (`IsServer` or `IsClient`).
         /// </summary>
-        /// <remarks>
         /// <param name="networkManager">a ref to the <see cref="NetworkManager"/> since this is not yet set on the <see cref="NetworkBehaviour"/></param>
+        /// <remarks>
         /// The <see cref="NetworkBehaviour"/> will not have anything assigned to it at this point in time.
-        /// Settings like ownership, NetworkBehaviourId, NetworkManager, and most other spawn related properties will not be set.
-        /// This can be used to handle things like initializing/instantiating a NetworkVariable or the like.
+        /// Settings like ownership, NetworkBehaviourId, NetworkManager, and most other spawn-related properties will not be set.
+        /// This can be used to handle things like initializing a NetworkVariable.
         /// </remarks>
         protected virtual void OnNetworkPreSpawn(ref NetworkManager networkManager) { }
 
         /// <summary>
-        /// Gets called when the <see cref="NetworkObject"/> gets spawned, message handlers are ready to be registered and the network is setup.
+        /// Gets called when the <see cref="NetworkObject"/> gets spawned, message handlers are ready to be registered, and the network is set up.
         /// </summary>
         public virtual void OnNetworkSpawn() { }
 
@@ -685,29 +694,33 @@ namespace Unity.Netcode
         /// </remarks>
         protected virtual void OnNetworkPostSpawn() { }
 
+        protected internal virtual void InternalOnNetworkPostSpawn() { }
+
         /// <summary>
-        /// [Client-Side Only]
-        /// When a new client joins it is synchronized with all spawned NetworkObjects and scenes loaded for the session joined. At the end of the synchronization process, when all
+        /// This method is only available client-side.
+        /// When a new client joins it's synchronized with all spawned NetworkObjects and scenes loaded for the session joined. At the end of the synchronization process, when all
         /// <see cref="NetworkObject"/>s and scenes (if scene management is enabled) have finished synchronizing, all NetworkBehaviour components associated with spawned <see cref="NetworkObject"/>s
         /// will have this method invoked.
         /// </summary>
         /// <remarks>
-        /// This can be used to handle post synchronization actions where you might need to access a different NetworkObject and/or NetworkBehaviour not local to the current NetworkObject context.
+        /// This can be used to handle post-synchronization actions where you might need to access a different NetworkObject and/or NetworkBehaviour not local to the current NetworkObject context.
         /// This is only invoked on clients during a client-server network topology session.
         /// </remarks>
         protected virtual void OnNetworkSessionSynchronized() { }
 
+        protected internal virtual void InternalOnNetworkSessionSynchronized() { }
+
         /// <summary>
-        /// [Client & Server Side]
-        /// When a scene is loaded an in-scene placed NetworkObjects are all spawned, this method is invoked on all of the newly spawned in-scene placed NetworkObjects.
+        /// When a scene is loaded and in-scene placed NetworkObjects are finished spawning, this method is invoked on all of the newly spawned in-scene placed NetworkObjects.
+        /// This method runs both client and server side.
         /// </summary>
         /// <remarks>
-        /// This can be used to handle post scene loaded actions for in-scene placed NetworkObjcts where you might need to access a different NetworkObject and/or NetworkBehaviour not local to the current NetworkObject context.
+        /// This method can be used to handle post-scene loaded actions for in-scene placed NetworkObjcts where you might need to access a different NetworkObject and/or NetworkBehaviour not local to the current NetworkObject context.
         /// </remarks>
         protected virtual void OnInSceneObjectsSpawned() { }
 
         /// <summary>
-        /// Gets called when the <see cref="NetworkObject"/> gets despawned. Is called both on the server and clients.
+        /// Gets called when the <see cref="NetworkObject"/> gets despawned. This method runs both client and server side.
         /// </summary>
         public virtual void OnNetworkDespawn() { }
 
@@ -756,6 +769,7 @@ namespace Unity.Netcode
         {
             try
             {
+                InternalOnNetworkPostSpawn();
                 OnNetworkPostSpawn();
             }
             catch (Exception e)
@@ -768,6 +782,7 @@ namespace Unity.Netcode
         {
             try
             {
+                InternalOnNetworkSessionSynchronized();
                 OnNetworkSessionSynchronized();
             }
             catch (Exception e)
@@ -803,7 +818,8 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Gets called when the local client gains ownership of this object
+        /// In client-server contexts, this method is invoked on both the server and the local client of the owner when <see cref="Netcode.NetworkObject"/> ownership is assigned.
+        /// <para>In distributed authority contexts, this method is only invoked on the local client that has been assigned ownership of the associated <see cref="Netcode.NetworkObject"/>.</para>
         /// </summary>
         public virtual void OnGainedOwnership() { }
 
@@ -814,8 +830,8 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Invoked on all clients, override this method to be notified of any
-        /// ownership changes (even if the instance was niether the previous or
+        /// Invoked on all clients. Override this method to be notified of any
+        /// ownership changes (even if the instance was neither the previous or
         /// newly assigned current owner).
         /// </summary>
         /// <param name="previous">the previous owner</param>
@@ -831,7 +847,9 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Gets called when we loose ownership of this object
+        /// In client-server contexts, this method is invoked on the local client when it loses ownership of the associated <see cref="Netcode.NetworkObject"/>
+        /// and on the server when any client loses ownership.
+        /// <para>In distributed authority contexts, this method is only invoked on the local client that has lost ownership of the associated <see cref="Netcode.NetworkObject"/>.</para>
         /// </summary>
         public virtual void OnLostOwnership() { }
 
@@ -842,11 +860,13 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Gets called when the parent NetworkObject of this NetworkBehaviour's NetworkObject has changed
+        /// Gets called when the parent NetworkObject of this NetworkBehaviour's NetworkObject has changed.
         /// </summary>
         /// <param name="parentNetworkObject">the new <see cref="NetworkObject"/> parent</param>
         public virtual void OnNetworkObjectParentChanged(NetworkObject parentNetworkObject) { }
 
+        internal virtual void InternalOnNetworkObjectParentChanged(NetworkObject parentNetworkObject) { }
+
         private bool m_VarInit = false;
 
         private readonly List<HashSet<int>> m_DeliveryMappedNetworkVariableIndices = new List<HashSet<int>>();
@@ -877,7 +897,7 @@ namespace Unity.Netcode
 #pragma warning restore IDE1006 // restore naming rule violation check
         {
             __rpc_func_table[GetType()][hash] = handler;
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
             __rpc_name_table[GetType()][hash] = rpcMethodName;
 #endif
         }
@@ -903,7 +923,7 @@ namespace Unity.Netcode
             if (!__rpc_func_table.ContainsKey(GetType()))
             {
                 __rpc_func_table[GetType()] = new Dictionary<uint, RpcReceiveHandler>();
-#if UNITY_EDITOR || DEVELOPMENT_BUILD
+#if UNITY_EDITOR || DEVELOPMENT_BUILD || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
                 __rpc_name_table[GetType()] = new Dictionary<uint, string>();
 #endif
                 __initializeRpcs();
@@ -1112,31 +1132,38 @@ namespace Unity.Netcode
         /// </remarks>
         internal void WriteNetworkVariableData(FastBufferWriter writer, ulong targetClientId)
         {
+            // Create any values that require accessing the NetworkManager locally (it is expensive to access it in NetworkBehaviour)
             var networkManager = NetworkManager;
-            if (networkManager.DistributedAuthorityMode)
+            var distributedAuthority = networkManager.DistributedAuthorityMode;
+            var ensureLengthSafety = networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety;
+
+            // Always write the NetworkVariable count even if zero for distributed authority (used by comb server)
+            if (distributedAuthority)
             {
                 writer.WriteValueSafe((ushort)NetworkVariableFields.Count);
             }
 
+            // Exit early if there are no NetworkVariables
             if (NetworkVariableFields.Count == 0)
             {
                 return;
             }
 
-            // DANGO-TODO: Made some modifications here that overlap/won't play nice with EnsureNetworkVariableLenghtSafety.
-            // Worth either merging or more cleanly separating these codepaths.
             for (int j = 0; j < NetworkVariableFields.Count; j++)
             {
-                // Note: In distributed authority mode, all clients can read
+                // Client-Server: Try to write values only for clients that have read permissions.
+                // Distributed Authority: All clients have read permissions, always try to write the value.
                 if (NetworkVariableFields[j].CanClientRead(targetClientId))
                 {
-                    if (networkManager.DistributedAuthorityMode)
+                    // Write additional NetworkVariable information when length safety is enabled or when in distributed authority mode
+                    if (ensureLengthSafety || distributedAuthority)
+                    {
+                        // Write the type being serialized for distributed authority (only for comb-server)
+                        if (distributedAuthority)
                         {
                             writer.WriteValueSafe(NetworkVariableFields[j].Type);
                         }
 
-                    if (networkManager.DistributedAuthorityMode || networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
-                    {
                         var writePos = writer.Position;
                         // Note: This value can't be packed because we don't know how large it will be in advance
                         // we reserve space for it, then write the data, then come back and fill in the space
@@ -1148,18 +1175,19 @@ namespace Unity.Netcode
                         NetworkVariableFields[j].WriteField(writer);
                         var size = writer.Position - startPos;
                         writer.Seek(writePos);
+                        // Write the NetworkVariable value
                         writer.WriteValueSafe((ushort)size);
                         writer.Seek(startPos + size);
                     }
-                    else
+                    else // Client-Server Only: Should only ever be invoked when using a client-server NetworkTopology
                     {
+                        // Write the NetworkVariable value
                         NetworkVariableFields[j].WriteField(writer);
                     }
                 }
-                else
+                else if (ensureLengthSafety)
                 {
-                    // Only if EnsureNetworkVariableLengthSafety, otherwise just skip
-                    if (networkManager.DistributedAuthorityMode || networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                    // Client-Server Only: If the client cannot read this field, then skip it but write a 0 for this NetworkVariable's position
                     {
                         writer.WriteValueSafe((ushort)0);
                     }
@@ -1177,75 +1205,78 @@ namespace Unity.Netcode
         /// </remarks>
         internal void SetNetworkVariableData(FastBufferReader reader, ulong clientId)
         {
+            // Stack cache any values that requires accessing the NetworkManager (it is expensive to access it in NetworkBehaviour)
             var networkManager = NetworkManager;
-            if (networkManager.DistributedAuthorityMode)
+            var distributedAuthority = networkManager.DistributedAuthorityMode;
+            var ensureLengthSafety = networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety;
+
+            // Always read the NetworkVariable count when in distributed authority (sanity check if comb-server matches what client has locally)
+            if (distributedAuthority)
             {
                 reader.ReadValueSafe(out ushort variableCount);
                 if (variableCount != NetworkVariableFields.Count)
                 {
-                    Debug.LogError("NetworkVariable count mismatch.");
+                    Debug.LogError($"[{name}][NetworkObjectId: {NetworkObjectId}][NetworkBehaviourId: {NetworkBehaviourId}] NetworkVariable count mismatch! (Read: {variableCount} vs. Expected: {NetworkVariableFields.Count})");
                     return;
                 }
             }
 
+            // Exit early if nothing else to read
             if (NetworkVariableFields.Count == 0)
             {
                 return;
             }
 
-            // DANGO-TODO: Made some modifications here that overlap/won't play nice with EnsureNetworkVariableLenghtSafety.
-            // Worth either merging or more cleanly separating these codepaths.
             for (int j = 0; j < NetworkVariableFields.Count; j++)
             {
                 var varSize = (ushort)0;
                 var readStartPos = 0;
-                if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                // Client-Server: Clients that only have read permissions will try to read the value
+                // Distributed Authority: All clients have read permissions, always try to read the value
+                if (NetworkVariableFields[j].CanClientRead(clientId))
                 {
+                    if (ensureLengthSafety || distributedAuthority)
+                    {
+                        // Read the type being serialized and discard it (for now) when in a distributed authority network topology (only used by comb-server)
+                        if (distributedAuthority)
+                        {
+                            reader.ReadValueSafe(out NetworkVariableType _);
+                        }
+
                         reader.ReadValueSafe(out varSize);
                         if (varSize == 0)
                         {
+                            Debug.LogError($"[{name}][NetworkObjectId: {NetworkObjectId}][NetworkBehaviourId: {NetworkBehaviourId}][{NetworkVariableFields[j].Name}] Expected non-zero size readable NetworkVariable! (Skipping)");
                             continue;
                         }
                         readStartPos = reader.Position;
                     }
-                else // If the client cannot read this field, then skip it
-                if (!NetworkVariableFields[j].CanClientRead(clientId))
+                }
+                else // Client-Server Only: If the client cannot read this field, then skip it
                 {
-                    if (networkManager.DistributedAuthorityMode)
+                    // If skipping and length safety, then fill in a 0 size for this one spot
+                    if (ensureLengthSafety)
                     {
                         reader.ReadValueSafe(out ushort size);
                         if (size != 0)
                         {
-                            Debug.LogError("Expected zero size");
+                            Debug.LogError($"[{name}][NetworkObjectId: {NetworkObjectId}][NetworkBehaviourId: {NetworkBehaviourId}][{NetworkVariableFields[j].Name}] Expected zero size for non-readable NetworkVariable when EnsureNetworkVariableLengthSafety is enabled! (Skipping)");
                         }
                     }
                     continue;
                 }
 
-                if (networkManager.DistributedAuthorityMode)
-                {
-                    // Explicit setting of the NetworkVariableType is only needed for CMB Runtime
-                    reader.ReadValueSafe(out NetworkVariableType _);
-                    reader.ReadValueSafe(out ushort size);
-                    var start_marker = reader.Position;
+                // Read the NetworkVarible value
                 NetworkVariableFields[j].ReadField(reader);
-                    if (reader.Position - start_marker != size)
-                    {
-                        Debug.LogError("Mismatched network variable size");
-                    }
-                }
-                else
-                {
-                    NetworkVariableFields[j].ReadField(reader);
-                }
 
-                if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                // When EnsureNetworkVariableLengthSafety or DistributedAuthorityMode always do a bounds check
+                if (ensureLengthSafety || distributedAuthority)
                 {
                     if (reader.Position > (readStartPos + varSize))
                     {
                         if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                         {
-                            NetworkLog.LogWarning($"Var data read too far. {reader.Position - (readStartPos + varSize)} bytes.");
+                            NetworkLog.LogWarning($"[{name}][NetworkObjectId: {NetworkObjectId}][NetworkBehaviourId: {NetworkBehaviourId}][{NetworkVariableFields[j].Name}] NetworkVariable data read too big. {reader.Position - (readStartPos + varSize)} bytes.");
                         }
 
                         reader.Seek(readStartPos + varSize);
@@ -1254,7 +1285,7 @@ namespace Unity.Netcode
                     {
                         if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                         {
-                            NetworkLog.LogWarning($"Var data read too little. {(readStartPos + varSize) - reader.Position} bytes.");
+                            NetworkLog.LogWarning($"[{name}][NetworkObjectId: {NetworkObjectId}][NetworkBehaviourId: {NetworkBehaviourId}][{NetworkVariableFields[j].Name}] NetworkVariable data read too small. {(readStartPos + varSize) - reader.Position} bytes.");
                         }
 
                         reader.Seek(readStartPos + varSize);
@@ -1264,7 +1295,7 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Gets the local instance of a object with a given NetworkId
+        /// Gets the local instance of a NetworkObject with a given NetworkId.
         /// </summary>
         /// <param name="networkId"></param>
         /// <returns></returns>
@@ -1275,14 +1306,14 @@ namespace Unity.Netcode
 
         /// <summary>
         /// Override this method if your derived NetworkBehaviour requires custom synchronization data.
-        /// Note: Use of this method is only for the initial client synchronization of NetworkBehaviours
+        /// Use of this method is only for the initial client synchronization of NetworkBehaviours
         /// and will increase the payload size for client synchronization and dynamically spawned
         /// <see cref="NetworkObject"/>s.
         /// </summary>
         /// <remarks>
-        /// When serializing (writing) this will be invoked during the client synchronization period and
+        /// When serializing (writing), this method is invoked during the client synchronization period and
         /// when spawning new NetworkObjects.
-        /// When deserializing (reading), this will be invoked prior to the NetworkBehaviour's associated
+        /// When deserializing (reading), this method is invoked prior to the NetworkBehaviour's associated
         /// NetworkObject being spawned.
         /// </remarks>
         /// <param name="serializer">The serializer to use to read and write the data.</param>
@@ -1305,10 +1336,10 @@ namespace Unity.Netcode
         /// The relative client identifier targeted for the serialization of this <see cref="NetworkBehaviour"/> instance.
         /// </summary>
         /// <remarks>
-        /// This value will be set prior to <see cref="OnSynchronize{T}(ref BufferSerializer{T})"/> being invoked.
+        /// This value is set prior to <see cref="OnSynchronize{T}(ref BufferSerializer{T})"/> being invoked.
         /// For writing (server-side), this is useful to know which client will receive the serialized data.
         /// For reading (client-side), this will be the <see cref="NetworkManager.LocalClientId"/>.
-        /// When synchronization of this instance is complete, this value will be reset to 0
+        /// When synchronization of this instance is complete, this value is reset to 0.
         /// </remarks>
         protected ulong m_TargetIdBeingSynchronized { get; private set; }
 
@@ -1431,9 +1462,8 @@ namespace Unity.Netcode
 
 
         /// <summary>
-        /// Invoked when the <see cref="GameObject"/> the <see cref="NetworkBehaviour"/> is attached to.
-        /// NOTE:  If you override this, you will want to always invoke this base class version of this
-        /// <see cref="OnDestroy"/> method!!
+        /// Invoked when the <see cref="GameObject"/> the <see cref="NetworkBehaviour"/> is attached to is destroyed.
+        /// If you override this, you must always invoke the base class version of this <see cref="OnDestroy"/> method.
         /// </summary>
         public virtual void OnDestroy()
         {

Runtime/Core/NetworkManager.cs

@@ -8,7 +8,6 @@ using UnityEditor;
 #endif
 using UnityEngine.SceneManagement;
 using Debug = UnityEngine.Debug;
-using Unity.Netcode.Components;
 
 namespace Unity.Netcode
 {
@@ -18,6 +17,12 @@ namespace Unity.Netcode
     [AddComponentMenu("Netcode/Network Manager", -100)]
     public class NetworkManager : MonoBehaviour, INetworkUpdateSystem
     {
+#if UNITY_EDITOR
+        // Inspector view expand/collapse settings for this derived child class
+        [HideInInspector]
+        public bool NetworkManagerExpanded;
+#endif
+
         // TODO: Deprecate...
         // The following internal values are not used, but because ILPP makes them public in the assembly, they cannot
         // be removed thanks to our semver validation.
@@ -29,13 +34,40 @@ namespace Unity.Netcode
         // RuntimeAccessModifiersILPP will make this `public`
         internal static readonly Dictionary<uint, RpcReceiveHandler> __rpc_func_table = new Dictionary<uint, RpcReceiveHandler>();
 
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
         // RuntimeAccessModifiersILPP will make this `public`
         internal static readonly Dictionary<uint, string> __rpc_name_table = new Dictionary<uint, string>();
 #endif
 
 #pragma warning restore IDE1006 // restore naming rule violation check
 
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
+        private static List<Type> s_SerializedType = new List<Type>();
+        // This is used to control the serialized type not optimized messaging for integration test purposes
+        internal static bool DisableNotOptimizedSerializedType;
+        /// <summary>
+        /// Until all serialized types are optimized for the distributed authority network topology,
+        /// this will handle the notification to the user that the type being serialized is not yet
+        /// optimized but will only log the message once to prevent log spamming.
+        /// </summary>
+        internal static void LogSerializedTypeNotOptimized<T>()
+        {
+            if (DisableNotOptimizedSerializedType)
+            {
+                return;
+            }
+            var type = typeof(T);
+            if (!s_SerializedType.Contains(type))
+            {
+                s_SerializedType.Add(type);
+                if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
+                {
+                    Debug.LogWarning($"[{type.Name}] Serialized type has not been optimized for use with Distributed Authority!");
+                }
+            }
+        }
+#endif
+
         internal static bool IsDistributedAuthority;
 
         /// <summary>
@@ -163,7 +195,6 @@ namespace Unity.Netcode
             OnSessionOwnerPromoted?.Invoke(sessionOwner);
         }
 
-        // TODO: Make this internal after testing
         internal void PromoteSessionOwner(ulong clientId)
         {
             if (!DistributedAuthorityMode)
@@ -188,25 +219,25 @@ namespace Unity.Netcode
             }
         }
 
-        internal Dictionary<ulong, NetworkTransform> NetworkTransformUpdate = new Dictionary<ulong, NetworkTransform>();
+        internal Dictionary<ulong, NetworkObject> NetworkTransformUpdate = new Dictionary<ulong, NetworkObject>();
 #if COM_UNITY_MODULES_PHYSICS
-        internal Dictionary<ulong, NetworkTransform> NetworkTransformFixedUpdate = new Dictionary<ulong, NetworkTransform>();
+        internal Dictionary<ulong, NetworkObject> NetworkTransformFixedUpdate = new Dictionary<ulong, NetworkObject>();
 #endif
 
-        internal void NetworkTransformRegistration(NetworkTransform networkTransform, bool forUpdate = true, bool register = true)
+        internal void NetworkTransformRegistration(NetworkObject networkObject, bool onUpdate = true, bool register = true)
         {
-            if (forUpdate)
+            if (onUpdate)
             {
                 if (register)
                 {
-                    if (!NetworkTransformUpdate.ContainsKey(networkTransform.NetworkObjectId))
+                    if (!NetworkTransformUpdate.ContainsKey(networkObject.NetworkObjectId))
                     {
-                        NetworkTransformUpdate.Add(networkTransform.NetworkObjectId, networkTransform);
+                        NetworkTransformUpdate.Add(networkObject.NetworkObjectId, networkObject);
                     }
                 }
                 else
                 {
-                    NetworkTransformUpdate.Remove(networkTransform.NetworkObjectId);
+                    NetworkTransformUpdate.Remove(networkObject.NetworkObjectId);
                 }
             }
 #if COM_UNITY_MODULES_PHYSICS
@@ -214,14 +245,14 @@ namespace Unity.Netcode
             {
                 if (register)
                 {
-                    if (!NetworkTransformFixedUpdate.ContainsKey(networkTransform.NetworkObjectId))
+                    if (!NetworkTransformFixedUpdate.ContainsKey(networkObject.NetworkObjectId))
                     {
-                        NetworkTransformFixedUpdate.Add(networkTransform.NetworkObjectId, networkTransform);
+                        NetworkTransformFixedUpdate.Add(networkObject.NetworkObjectId, networkObject);
                     }
                 }
                 else
                 {
-                    NetworkTransformFixedUpdate.Remove(networkTransform.NetworkObjectId);
+                    NetworkTransformFixedUpdate.Remove(networkObject.NetworkObjectId);
                 }
             }
 #endif
@@ -262,11 +293,21 @@ namespace Unity.Netcode
 #if COM_UNITY_MODULES_PHYSICS
                 case NetworkUpdateStage.FixedUpdate:
                     {
-                        foreach (var networkTransformEntry in NetworkTransformFixedUpdate)
+                        foreach (var networkObjectEntry in NetworkTransformFixedUpdate)
                         {
-                            if (networkTransformEntry.Value.gameObject.activeInHierarchy && networkTransformEntry.Value.IsSpawned)
+                            // if not active or not spawned then skip
+                            if (!networkObjectEntry.Value.gameObject.activeInHierarchy || !networkObjectEntry.Value.IsSpawned)
                             {
-                                networkTransformEntry.Value.OnFixedUpdate();
+                                continue;
+                            }
+
+                            foreach (var networkTransformEntry in networkObjectEntry.Value.NetworkTransforms)
+                            {
+                                // only update if enabled
+                                if (networkTransformEntry.enabled)
+                                {
+                                    networkTransformEntry.OnFixedUpdate();
+                                }
                             }
                         }
                     }
@@ -281,11 +322,21 @@ namespace Unity.Netcode
                 case NetworkUpdateStage.PreLateUpdate:
                     {
                         // Non-physics based non-authority NetworkTransforms update their states after all other components
-                        foreach (var networkTransformEntry in NetworkTransformUpdate)
+                        foreach (var networkObjectEntry in NetworkTransformUpdate)
                         {
-                            if (networkTransformEntry.Value.gameObject.activeInHierarchy && networkTransformEntry.Value.IsSpawned)
+                            // if not active or not spawned then skip
+                            if (!networkObjectEntry.Value.gameObject.activeInHierarchy || !networkObjectEntry.Value.IsSpawned)
                             {
-                                networkTransformEntry.Value.OnUpdate();
+                                continue;
+                            }
+
+                            foreach (var networkTransformEntry in networkObjectEntry.Value.NetworkTransforms)
+                            {
+                                // only update if enabled
+                                if (networkTransformEntry.enabled)
+                                {
+                                    networkTransformEntry.OnUpdate();
+                                }
                             }
                         }
                     }
@@ -844,6 +895,11 @@ namespace Unity.Netcode
             OnNetworkManagerReset?.Invoke(this);
         }
 
+        protected virtual void OnValidateComponent()
+        {
+
+        }
+
         internal void OnValidate()
         {
             if (NetworkConfig == null)
@@ -904,6 +960,15 @@ namespace Unity.Netcode
                     }
                 }
             }
+
+            try
+            {
+                OnValidateComponent();
+            }
+            catch (Exception ex)
+            {
+                Debug.LogException(ex);
+            }
         }
 
         private void ModeChanged(PlayModeStateChange change)
@@ -1062,6 +1127,13 @@ namespace Unity.Netcode
 
         internal void Initialize(bool server)
         {
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
+            if (!DisableNotOptimizedSerializedType)
+            {
+                s_SerializedType.Clear();
+            }
+#endif
+
 #if COM_UNITY_MODULES_PHYSICS
             NetworkTransformFixedUpdate.Clear();
 #endif
@@ -1250,17 +1322,8 @@ namespace Unity.Netcode
                 {
                     SpawnManager.ServerSpawnSceneObjectsOnStartSweep();
 
-                    // Notify the server that all in-scnee placed NetworkObjects are spawned at this time.
-                    foreach (var networkObject in SpawnManager.SpawnedObjectsList)
-                    {
-                        networkObject.InternalInSceneNetworkObjectsSpawned();
-                    }
-
                     // Notify the server that everything should be synchronized/spawned at this time.
-                    foreach (var networkObject in SpawnManager.SpawnedObjectsList)
-                    {
-                        networkObject.InternalNetworkSessionSynchronized();
-                    }
+                    SpawnManager.NotifyNetworkObjectsSynchronized();
                     OnServerStarted?.Invoke();
                     ConnectionManager.LocalClient.IsApproved = true;
                     return true;
@@ -1407,17 +1470,9 @@ namespace Unity.Netcode
             }
 
             SpawnManager.ServerSpawnSceneObjectsOnStartSweep();
-            // Notify the host that all in-scnee placed NetworkObjects are spawned at this time.
-            foreach (var networkObject in SpawnManager.SpawnedObjectsList)
-            {
-                networkObject.InternalInSceneNetworkObjectsSpawned();
-            }
 
             // Notify the host that everything should be synchronized/spawned at this time.
-            foreach (var networkObject in SpawnManager.SpawnedObjectsList)
-            {
-                networkObject.InternalNetworkSessionSynchronized();
-            }
+            SpawnManager.NotifyNetworkObjectsSynchronized();
 
             OnServerStarted?.Invoke();
             OnClientStarted?.Invoke();

Runtime/Core/NetworkObject.cs

@@ -67,6 +67,7 @@ namespace Unity.Netcode
         /// </remarks>
         public List<NetworkTransform> NetworkTransforms { get; private set; }
 
+
 #if COM_UNITY_MODULES_PHYSICS
         /// <summary>
         /// All <see cref="NetworkRigidbodyBase"></see> component instances associated with a <see cref="NetworkObject"/> component instance.
@@ -540,8 +541,8 @@ namespace Unity.Netcode
         /// permission failure status codes will be returned via <see cref="OnOwnershipPermissionsFailure"/>.
         /// <see cref="Locked"/>: The <see cref="NetworkObject"/> is locked and ownership cannot be acquired.
         /// <see cref="RequestRequired"/>: The <see cref="NetworkObject"/> requires an ownership request via <see cref="RequestOwnership"/>.
-        /// <see cref="RequestInProgress"/>: The <see cref="NetworkObject"/> already is processing an ownership request and ownership cannot be acquired at this time.
-        /// <see cref="NotTransferrable": The <see cref="NetworkObject"/> does not have the <see cref="OwnershipStatus.Transferable"/> flag set and ownership cannot be acquired.
+        /// <see cref="RequestInProgress"/>: The <see cref="NetworkObject"/> is already processing an ownership request and ownership cannot be acquired at this time.
+        /// <see cref="NotTransferrable"/>: The <see cref="NetworkObject"/> does not have the <see cref="OwnershipStatus.Transferable"/> flag set and ownership cannot be acquired.
         /// </summary>
         public enum OwnershipPermissionsFailureStatus
         {
@@ -937,6 +938,7 @@ namespace Unity.Netcode
         /// <summary>
         /// If true, the object will always be replicated as root on clients and the parent will be ignored.
         /// </summary>
+        [Tooltip("If enabled (default disabled), instances of this NetworkObject will ignore any parent(s) it might have and replicate on clients as the root being its parent.")]
         public bool AlwaysReplicateAsRoot;
 
         /// <summary>
@@ -954,6 +956,8 @@ namespace Unity.Netcode
         /// bandwidth cost. This can also be useful for UI elements that have
         /// a predetermined fixed position.
         /// </remarks>
+        [Tooltip("If enabled (default enabled), newly joining clients will be synchronized with the transform of the associated GameObject this component is attached to. Typical use case" +
+            " scenario would be for managment objects or in-scene placed objects that don't move and already have their transform settings applied within the scene information.")]
         public bool SynchronizeTransform = true;
 
         /// <summary>
@@ -1011,6 +1015,7 @@ namespace Unity.Netcode
         /// To synchronize clients of a <see cref="NetworkObject"/>'s scene being changed via <see cref="SceneManager.MoveGameObjectToScene(GameObject, Scene)"/>,
         /// make sure <see cref="SceneMigrationSynchronization"/> is enabled (it is by default).
         /// </remarks>
+        [Tooltip("When enabled (default disabled), spawned instances of this NetworkObject will automatically migrate to any newly assigned active scene.")]
         public bool ActiveSceneSynchronization;
 
         /// <summary>
@@ -1029,6 +1034,7 @@ namespace Unity.Netcode
         /// is <see cref="true"/> and <see cref="ActiveSceneSynchronization"/> is <see cref="false"/> and the scene is not the currently
         /// active scene, then the <see cref="NetworkObject"/> will be destroyed.
         /// </remarks>
+        [Tooltip("When enabled (default enabled), dynamically spawned instances of this NetworkObject's migration to a different scene will automatically be synchonize amongst clients.")]
         public bool SceneMigrationSynchronization = true;
 
         /// <summary>
@@ -1044,7 +1050,7 @@ namespace Unity.Netcode
         /// <summary>
         /// When set to false, the NetworkObject will be spawned with no observers initially (other than the server)
         /// </summary>
-        [Tooltip("When false, the NetworkObject will spawn with no observers initially. (default is true)")]
+        [Tooltip("When disabled (default enabled), the NetworkObject will spawn with no observers. You control object visibility using NetworkShow. This applies to newly joining clients as well.")]
         public bool SpawnWithObservers = true;
 
         /// <summary>
@@ -1073,13 +1079,35 @@ namespace Unity.Netcode
         /// Whether or not to destroy this object if it's owner is destroyed.
         /// If true, the objects ownership will be given to the server.
         /// </summary>
+        [Tooltip("When enabled (default disabled), instances of this NetworkObject will not be destroyed if the owning client disconnects.")]
         public bool DontDestroyWithOwner;
 
         /// <summary>
         /// Whether or not to enable automatic NetworkObject parent synchronization.
         /// </summary>
+        [Tooltip("When disabled (default enabled), NetworkObject parenting will not be automatically synchronized. This is typically used when you want to implement your own custom parenting solution.")]
         public bool AutoObjectParentSync = true;
 
+        /// <summary>
+        /// Determines if the owner will apply transform values sent by the parenting message.
+        /// </summary>
+        /// <remarks>
+        /// When enabled, the resultant parenting transform changes sent by the authority will be applied on all instances. <br />
+        /// When disabled, the resultant parenting transform changes sent by the authority will not be applied on the owner's instance. <br />
+        /// When disabled, all non-owner instances will still be synchronized by the authority's transform values when parented.
+        /// When using a <see cref="NetworkTopologyTypes.ClientServer"/> network topology and an owner authoritative motion model, disabling this can help smooth parenting transitions.
+        /// When using a <see cref="NetworkTopologyTypes.DistributedAuthority"/> network topology this will have no impact on the owner's instance since only the authority/owner can parent.
+        /// </remarks>
+        [Tooltip("When disabled (default enabled), the owner will not apply a server or host's transform properties when parenting changes. Primarily useful for client-server network topology configurations.")]
+        public bool SyncOwnerTransformWhenParented = true;
+
+        /// <summary>
+        /// Client-Server specific, when enabled an owner of a NetworkObject can parent locally as opposed to requiring the owner to notify the server it would like to be parented.
+        /// This behavior is always true when using a distributed authority network topology and does not require it to be set.
+        /// </summary>
+        [Tooltip("When enabled (default disabled), owner's can parent a NetworkObject locally without having to send an RPC to the server or host. Only pertinent when using client-server network topology configurations.")]
+        public bool AllowOwnerToParent;
+
         internal readonly HashSet<ulong> Observers = new HashSet<ulong>();
 
 #if MULTIPLAYER_TOOLS
@@ -1547,6 +1575,11 @@ namespace Unity.Netcode
 
             if (NetworkManager.DistributedAuthorityMode)
             {
+                if (NetworkManager.LocalClient == null || !NetworkManager.IsConnectedClient || !NetworkManager.ConnectionManager.LocalClient.IsApproved)
+                {
+                    Debug.LogError($"Cannot spawn {name} until the client is fully connected to the session!");
+                    return;
+                }
                 if (NetworkManager.NetworkConfig.EnableSceneManagement)
                 {
                     NetworkSceneHandle = NetworkManager.SceneManager.ClientSceneHandleToServerSceneHandle[gameObject.scene.handle];
@@ -1638,7 +1671,7 @@ namespace Unity.Netcode
                 return null;
             }
 
-            ownerClientId = networkManager.DistributedAuthorityMode ? networkManager.LocalClientId : NetworkManager.ServerClientId;
+            ownerClientId = networkManager.DistributedAuthorityMode ? networkManager.LocalClientId : ownerClientId;
             // We only need to check for authority when running in client-server mode
             if (!networkManager.IsServer && !networkManager.DistributedAuthorityMode)
             {
@@ -1782,6 +1815,9 @@ namespace Unity.Netcode
         {
             for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
             {
+                // Invoke internal notification
+                ChildNetworkBehaviours[i].InternalOnNetworkObjectParentChanged(parentNetworkObject);
+                // Invoke public notification
                 ChildNetworkBehaviours[i].OnNetworkObjectParentChanged(parentNetworkObject);
             }
         }
@@ -1913,7 +1949,7 @@ namespace Unity.Netcode
 
             // DANGO-TODO: Do we want to worry about ownership permissions here?
             // It wouldn't make sense to not allow parenting, but keeping this note here as a reminder.
-            var isAuthority = HasAuthority;
+            var isAuthority = HasAuthority || (AllowOwnerToParent && IsOwner);
 
             // If we don't have authority and we are not shutting down, then don't allow any parenting.
             // If we are shutting down and don't have authority then allow it.
@@ -1979,7 +2015,7 @@ namespace Unity.Netcode
             var isAuthority = false;
             // With distributed authority, we need to track "valid authoritative" parenting changes.
             // So, either the authority or AuthorityAppliedParenting is considered a "valid parenting change".
-            isAuthority = HasAuthority || AuthorityAppliedParenting;
+            isAuthority = HasAuthority || AuthorityAppliedParenting || (AllowOwnerToParent && IsOwner);
             var distributedAuthority = NetworkManager.DistributedAuthorityMode;
 
             // If we do not have authority and we are spawned
@@ -2071,7 +2107,7 @@ namespace Unity.Netcode
             }
 
             // If we are connected to a CMB service or we are running a mock CMB service then send to the "server" identifier
-            if (distributedAuthority)
+            if (distributedAuthority || (!distributedAuthority && AllowOwnerToParent && IsOwner && !NetworkManager.IsServer))
             {
                 if (!NetworkManager.DAHost)
                 {
@@ -2354,13 +2390,15 @@ namespace Unity.Netcode
                     {
                         m_ChildNetworkBehaviours.Add(networkBehaviours[i]);
                         var type = networkBehaviours[i].GetType();
-                        if (type.IsInstanceOfType(typeof(NetworkTransform)) || type.IsSubclassOf(typeof(NetworkTransform)))
+                        if (type == typeof(NetworkTransform) || type.IsInstanceOfType(typeof(NetworkTransform)) || type.IsSubclassOf(typeof(NetworkTransform)))
                         {
                             if (NetworkTransforms == null)
                             {
                                 NetworkTransforms = new List<NetworkTransform>();
                             }
-                            NetworkTransforms.Add(networkBehaviours[i] as NetworkTransform);
+                            var networkTransform = networkBehaviours[i] as NetworkTransform;
+                            networkTransform.IsNested = i != 0 && networkTransform.gameObject != gameObject;
+                            NetworkTransforms.Add(networkTransform);
                         }
 #if COM_UNITY_MODULES_PHYSICS
                         else if (type.IsSubclassOf(typeof(NetworkRigidbodyBase)))
@@ -2436,10 +2474,10 @@ namespace Unity.Netcode
             if (NetworkManager.DistributedAuthorityMode)
             {
                 var readerPosition = reader.Position;
-                reader.ReadValueSafe(out ushort behaviorCount);
-                if (behaviorCount != ChildNetworkBehaviours.Count)
+                reader.ReadValueSafe(out ushort behaviourCount);
+                if (behaviourCount != ChildNetworkBehaviours.Count)
                 {
-                    Debug.LogError($"Network Behavior Count Mismatch! [{readerPosition}][{reader.Position}]");
+                    Debug.LogError($"[{name}] Network Behavior Count Mismatch! [In: {behaviourCount} vs Local: {ChildNetworkBehaviours.Count}][StartReaderPos: {readerPosition}] CurrentReaderPos: {reader.Position}]");
                     return false;
                 }
             }

Runtime/Messaging/CustomMessageManager.cs

@@ -95,6 +95,7 @@ namespace Unity.Netcode
                 return;
             }
 
+            ValidateMessageSize(messageBuffer, networkDelivery, isNamed: false);
 
             if (m_NetworkManager.IsHost)
             {
@@ -131,6 +132,8 @@ namespace Unity.Netcode
         /// <param name="networkDelivery">The delivery type (QoS) to send data with</param>
         public void SendUnnamedMessage(ulong clientId, FastBufferWriter messageBuffer, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
         {
+            ValidateMessageSize(messageBuffer, networkDelivery, isNamed: false);
+
             if (m_NetworkManager.IsHost)
             {
                 if (clientId == m_NetworkManager.LocalClientId)
@@ -286,6 +289,8 @@ namespace Unity.Netcode
         /// <param name="networkDelivery">The delivery type (QoS) to send data with</param>
         public void SendNamedMessage(string messageName, ulong clientId, FastBufferWriter messageStream, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
         {
+            ValidateMessageSize(messageStream, networkDelivery, isNamed: true);
+
             ulong hash = 0;
             switch (m_NetworkManager.NetworkConfig.RpcHashSize)
             {
@@ -367,6 +372,8 @@ namespace Unity.Netcode
                 return;
             }
 
+            ValidateMessageSize(messageStream, networkDelivery, isNamed: true);
+
             ulong hash = 0;
             switch (m_NetworkManager.NetworkConfig.RpcHashSize)
             {
@@ -405,5 +412,32 @@ namespace Unity.Netcode
                 m_NetworkManager.NetworkMetrics.TrackNamedMessageSent(clientIds, messageName, size);
             }
         }
+
+        /// <summary>
+        /// Validate the size of the message. If it's a non-fragmented delivery type the message must fit within the
+        /// max allowed size with headers also subtracted. Named messages also include the hash
+        /// of the name string. Only validates in editor and development builds.
+        /// </summary>
+        /// <param name="messageStream">The named message payload</param>
+        /// <param name="networkDelivery">Delivery method</param>
+        /// <param name="isNamed">Is the message named (or unnamed)</param>
+        /// <exception cref="OverflowException">Exception thrown in case validation fails</exception>
+        private unsafe void ValidateMessageSize(FastBufferWriter messageStream, NetworkDelivery networkDelivery, bool isNamed)
+        {
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
+            var maxNonFragmentedSize = m_NetworkManager.MessageManager.NonFragmentedMessageMaxSize - FastBufferWriter.GetWriteSize<NetworkMessageHeader>() - sizeof(NetworkBatchHeader);
+            if (isNamed)
+            {
+                maxNonFragmentedSize -= sizeof(ulong); // MessageName hash
+            }
+            if (networkDelivery != NetworkDelivery.ReliableFragmentedSequenced
+                && messageStream.Length > maxNonFragmentedSize)
+            {
+                throw new OverflowException($"Given message size ({messageStream.Length} bytes) is greater than " +
+                    $"the maximum allowed for the selected delivery method ({maxNonFragmentedSize} bytes). Try using " +
+                    $"ReliableFragmentedSequenced delivery method instead.");
+            }
+#endif
+        }
     }
 }

Runtime/Messaging/Messages/ClientConnectedMessage.cs

@@ -31,7 +31,7 @@ namespace Unity.Netcode
         public void Handle(ref NetworkContext context)
         {
             var networkManager = (NetworkManager)context.SystemOwner;
-            if ((ShouldSynchronize || networkManager.CMBServiceConnection) && networkManager.DistributedAuthorityMode && networkManager.LocalClient.IsSessionOwner)
+            if (ShouldSynchronize && networkManager.NetworkConfig.EnableSceneManagement && networkManager.DistributedAuthorityMode && networkManager.LocalClient.IsSessionOwner)
             {
                 networkManager.SceneManager.SynchronizeNetworkObjects(ClientId);
             }
@@ -55,6 +55,15 @@ namespace Unity.Netcode
                 // Don't redistribute for the local instance
                 if (ClientId != networkManager.LocalClientId)
                 {
+                    // Show any NetworkObjects that are:
+                    // - Hidden from the session owner
+                    // - Owned by this client
+                    // - Has NetworkObject.SpawnWithObservers set to true (the default)
+                    if (!networkManager.LocalClient.IsSessionOwner)
+                    {
+                        networkManager.SpawnManager.ShowHiddenObjectsToNewlyJoinedClient(ClientId);
+                    }
+
                     // We defer redistribution to the end of the NetworkUpdateStage.PostLateUpdate
                     networkManager.RedistributeToClient = true;
                     networkManager.ClientToRedistribute = ClientId;

Runtime/Messaging/Messages/ConnectionApprovedMessage.cs

@@ -224,10 +224,7 @@ namespace Unity.Netcode
                 networkManager.ConnectionManager.InvokeOnClientConnectedCallback(context.SenderId);
 
                 // For convenience, notify all NetworkBehaviours that synchronization is complete.
-                foreach (var networkObject in networkManager.SpawnManager.SpawnedObjectsList)
-                {
-                    networkObject.InternalNetworkSessionSynchronized();
-                }
+                networkManager.SpawnManager.NotifyNetworkObjectsSynchronized();
             }
             else
             {
@@ -240,16 +237,12 @@ namespace Unity.Netcode
 
                     if (!IsRestoredSession)
                     {
+                        // Synchronize the service with the initial session owner's loaded scenes and spawned objects
+                        networkManager.SceneManager.SynchronizeNetworkObjects(NetworkManager.ServerClientId);
+
                         // Spawn any in-scene placed NetworkObjects
                         networkManager.SpawnManager.ServerSpawnSceneObjectsOnStartSweep();
 
-                        // With scene management enabled and since the session owner doesn't send a Synchronize scene event synchronize itself,
-                        // we need to notify the session owner that all in-scnee placed NetworkObjects are spawned at this time.
-                        foreach (var networkObject in networkManager.SpawnManager.SpawnedObjectsList)
-                        {
-                            networkObject.InternalInSceneNetworkObjectsSpawned();
-                        }
-
                         // Spawn the local player of the session owner
                         if (networkManager.AutoSpawnPlayerPrefabClientSide)
                         {
@@ -261,10 +254,7 @@ namespace Unity.Netcode
 
                         // With scene management enabled and since the session owner doesn't send a Synchronize scene event synchronize itself,
                         // we need to notify the session owner that everything should be synchronized/spawned at this time.
-                        foreach (var networkObject in networkManager.SpawnManager.SpawnedObjectsList)
-                        {
-                            networkObject.InternalNetworkSessionSynchronized();
-                        }
+                        networkManager.SpawnManager.NotifyNetworkObjectsSynchronized();
 
                         // When scene management is enabled and since the session owner is synchronizing the service (i.e. acting like  host),
                         // we need to locallyh invoke the OnClientConnected callback at this point in time.

Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs

@@ -25,8 +25,6 @@ namespace Unity.Netcode
 
         private const string k_Name = "NetworkVariableDeltaMessage";
 
-        // DANGO-TODO: Made some modifications here that overlap/won't play nice with EnsureNetworkVariableLenghtSafety.
-        // Worth either merging or more cleanly separating these codepaths.
         public void Serialize(FastBufferWriter writer, int targetVersion)
         {
             if (!writer.TryBeginWrite(FastBufferWriter.GetWriteSize(NetworkObjectId) + FastBufferWriter.GetWriteSize(NetworkBehaviourIndex)))
@@ -126,10 +124,6 @@ namespace Unity.Netcode
                     }
                     else
                     {
-                        // DANGO-TODO:
-                        // Complex types with custom type serialization (either registered custom types or INetworkSerializable implementations) will be problematic
-                        // Non-complex types always provide a full state update per delta
-                        // DANGO-TODO: Add NetworkListEvent<T>.EventType awareness to the cloud-state server
                         if (networkManager.DistributedAuthorityMode)
                         {
                             var size_marker = writer.Position;
@@ -167,8 +161,6 @@ namespace Unity.Netcode
             return true;
         }
 
-        // DANGO-TODO: Made some modifications here that overlap/won't play nice with EnsureNetworkVariableLenghtSafety.
-        // Worth either merging or more cleanly separating these codepaths.
         public void Handle(ref NetworkContext context)
         {
             var networkManager = (NetworkManager)context.SystemOwner;

Runtime/Messaging/Messages/ParentSyncMessage.cs

@@ -117,6 +117,11 @@ namespace Unity.Netcode
             networkObject.SetNetworkParenting(LatestParent, WorldPositionStays);
             networkObject.ApplyNetworkParenting(RemoveParent);
 
+            // This check is primarily for client-server network topologies when the motion model is owner authoritative:
+            // When SyncOwnerTransformWhenParented is enabled, then always apply the transform values.
+            // When SyncOwnerTransformWhenParented is disabled, then only synchronize the transform on non-owner instances.
+            if (networkObject.SyncOwnerTransformWhenParented || (!networkObject.SyncOwnerTransformWhenParented && !networkObject.IsOwner))
+            {
                 // We set all of the transform values after parenting as they are
                 // the values of the server-side post-parenting transform values
                 if (!WorldPositionStays)
@@ -130,9 +135,10 @@ namespace Unity.Netcode
                     networkObject.transform.rotation = Rotation;
                 }
                 networkObject.transform.localScale = Scale;
+            }
 
             // If in distributed authority mode and we are running a DAHost and this is the DAHost, then forward the parent changed message to any remaining clients
-            if (networkManager.DistributedAuthorityMode && !networkManager.CMBServiceConnection && networkManager.DAHost)
+            if ((networkManager.DistributedAuthorityMode && !networkManager.CMBServiceConnection && networkManager.DAHost) || (networkObject.AllowOwnerToParent && context.SenderId == networkObject.OwnerClientId && networkManager.IsServer))
             {
                 var size = 0;
                 var message = this;

Runtime/Messaging/Messages/ProxyMessage.cs

@@ -1,4 +1,3 @@
-using System;
 using Unity.Collections;
 
 namespace Unity.Netcode
@@ -34,22 +33,14 @@ namespace Unity.Netcode
             var networkManager = (NetworkManager)context.SystemOwner;
             if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(WrappedMessage.Metadata.NetworkObjectId, out var networkObject))
             {
-                // With distributed authority mode, we can send Rpcs before we have been notified the NetworkObject is despawned.
-                // DANGO-TODO: Should the CMB Service cull out any Rpcs targeting recently despawned NetworkObjects?
-                // DANGO-TODO: This would require the service to keep track of despawned NetworkObjects since we re-use NetworkObject identifiers.
-                if (networkManager.DistributedAuthorityMode)
-                {
+                // If the NetworkObject no longer exists then just log a warning when developer mode logging is enabled and exit.
+                // This can happen if NetworkObject is despawned and a client sends an RPC before receiving the despawn message.
                 if (networkManager.LogLevel == LogLevel.Developer)
                 {
-                        NetworkLog.LogWarning($"[{WrappedMessage.Metadata.NetworkObjectId}, {WrappedMessage.Metadata.NetworkBehaviourId}, {WrappedMessage.Metadata.NetworkRpcMethodId}]An RPC called on a {nameof(NetworkObject)} that is not in the spawned objects list. Please make sure the {nameof(NetworkObject)} is spawned before calling RPCs.");
+                    NetworkLog.LogWarning($"[{WrappedMessage.Metadata.NetworkObjectId}, {WrappedMessage.Metadata.NetworkBehaviourId}, {WrappedMessage.Metadata.NetworkRpcMethodId}] An RPC called on a {nameof(NetworkObject)} that is not in the spawned objects list. Please make sure the {nameof(NetworkObject)} is spawned before calling RPCs.");
                 }
                 return;
             }
-                else
-                {
-                    throw new InvalidOperationException($"[{WrappedMessage.Metadata.NetworkObjectId}, {WrappedMessage.Metadata.NetworkBehaviourId}, {WrappedMessage.Metadata.NetworkRpcMethodId}]An RPC called on a {nameof(NetworkObject)} that is not in the spawned objects list. Please make sure the {nameof(NetworkObject)} is spawned before calling RPCs.");
-                }
-            }
 
             var observers = networkObject.Observers;
 

Runtime/Messaging/Messages/RpcMessages.cs

@@ -41,7 +41,7 @@ namespace Unity.Netcode
 
             payload = new FastBufferReader(reader.GetUnsafePtrAtCurrentPosition(), Allocator.None, reader.Length - reader.Position);
 
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
             if (NetworkBehaviour.__rpc_name_table[networkBehaviour.GetType()].TryGetValue(metadata.NetworkRpcMethodId, out var rpcMethodName))
             {
                 networkManager.NetworkMetrics.TrackRpcReceived(
@@ -60,7 +60,13 @@ namespace Unity.Netcode
             var networkManager = (NetworkManager)context.SystemOwner;
             if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(metadata.NetworkObjectId, out var networkObject))
             {
-                throw new InvalidOperationException($"An RPC called on a {nameof(NetworkObject)} that is not in the spawned objects list. Please make sure the {nameof(NetworkObject)} is spawned before calling RPCs.");
+                // If the NetworkObject no longer exists then just log a warning when developer mode logging is enabled and exit.
+                // This can happen if NetworkObject is despawned and a client sends an RPC before receiving the despawn message.
+                if (networkManager.LogLevel == LogLevel.Developer)
+                {
+                    NetworkLog.LogWarning($"[{metadata.NetworkObjectId}, {metadata.NetworkBehaviourId}, {metadata.NetworkRpcMethodId}] An RPC called on a {nameof(NetworkObject)} that is not in the spawned objects list. Please make sure the {nameof(NetworkObject)} is spawned before calling RPCs.");
+                }
+                return;
             }
             var networkBehaviour = networkObject.GetNetworkBehaviourAtOrderIndex(metadata.NetworkBehaviourId);
 

Runtime/Messaging/Messages/UnnamedMessage.cs

@@ -20,7 +20,7 @@ namespace Unity.Netcode
 
         public void Handle(ref NetworkContext context)
         {
-            ((NetworkManager)context.SystemOwner).CustomMessagingManager.InvokeUnnamedMessage(context.SenderId, m_ReceivedData, context.SerializedHeaderSize);
+            ((NetworkManager)context.SystemOwner).CustomMessagingManager?.InvokeUnnamedMessage(context.SenderId, m_ReceivedData, context.SerializedHeaderSize);
         }
     }
 }

Runtime/Messaging/NetworkMessageManager.cs

@@ -733,7 +733,11 @@ namespace Unity.Netcode
                 }
 
                 ref var writeQueueItem = ref sendQueueItem.ElementAt(sendQueueItem.Length - 1);
-                writeQueueItem.Writer.TryBeginWrite(tmpSerializer.Length + headerSerializer.Length);
+                if (!writeQueueItem.Writer.TryBeginWrite(tmpSerializer.Length + headerSerializer.Length))
+                {
+                    Debug.LogError($"Not enough space to write message, size={tmpSerializer.Length + headerSerializer.Length} space used={writeQueueItem.Writer.Position} total size={writeQueueItem.Writer.Capacity}");
+                    continue;
+                }
 
                 writeQueueItem.Writer.WriteBytes(headerSerializer.GetUnsafePtr(), headerSerializer.Length);
                 writeQueueItem.Writer.WriteBytes(tmpSerializer.GetUnsafePtr(), tmpSerializer.Length);

Runtime/Messaging/RpcTargets/BaseRpcTarget.cs

@@ -36,12 +36,12 @@ namespace Unity.Netcode
 
         private protected void SendMessageToClient(NetworkBehaviour behaviour, ulong clientId, ref RpcMessage message, NetworkDelivery delivery)
         {
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
             var size =
 #endif
                 behaviour.NetworkManager.MessageManager.SendMessage(ref message, delivery, clientId);
 
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
             if (NetworkBehaviour.__rpc_name_table[behaviour.GetType()].TryGetValue(message.Metadata.NetworkRpcMethodId, out var rpcMethodName))
             {
                 behaviour.NetworkManager.NetworkMetrics.TrackRpcSent(

Runtime/Messaging/RpcTargets/LocalSendRpcTarget.cs

@@ -46,7 +46,7 @@ namespace Unity.Netcode
                 message.Handle(ref context);
                 length = tempBuffer.Length;
             }
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
             if (NetworkBehaviour.__rpc_name_table[behaviour.GetType()].TryGetValue(message.Metadata.NetworkRpcMethodId, out var rpcMethodName))
             {
                 networkManager.NetworkMetrics.TrackRpcSent(

Runtime/Messaging/RpcTargets/NotAuthorityRpcTarget.cs

@@ -29,6 +29,12 @@ namespace Unity.Netcode
                         {
                             continue;
                         }
+
+                        // The CMB-Service holds ID 0 and should not be added to the targets
+                        if (clientId == NetworkManager.ServerClientId && m_NetworkManager.CMBServiceConnection)
+                        {
+                            continue;
+                        }
                         m_GroupSendTarget.Add(clientId);
                     }
                 }
@@ -41,6 +47,12 @@ namespace Unity.Netcode
                             continue;
                         }
 
+                        // The CMB-Service holds ID 0 and should not be added to the targets
+                        if (clientId == NetworkManager.ServerClientId && m_NetworkManager.CMBServiceConnection)
+                        {
+                            continue;
+                        }
+
                         if (clientId == m_NetworkManager.LocalClientId)
                         {
                             m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);

Runtime/Messaging/RpcTargets/ProxyRpcTargetGroup.cs

@@ -17,13 +17,18 @@ namespace Unity.Netcode
 
         internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
         {
+            // If there are no targets then don't attempt to send anything.
+            if (TargetClientIds.Length == 0 && Ids.Count == 0)
+            {
+                return;
+            }
             var proxyMessage = new ProxyMessage { Delivery = delivery, TargetClientIds = TargetClientIds.AsArray(), WrappedMessage = message };
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
             var size =
 #endif
                 behaviour.NetworkManager.MessageManager.SendMessage(ref proxyMessage, delivery, NetworkManager.ServerClientId);
 
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
             if (NetworkBehaviour.__rpc_name_table[behaviour.GetType()].TryGetValue(message.Metadata.NetworkRpcMethodId, out var rpcMethodName))
             {
                 foreach (var clientId in TargetClientIds)

Runtime/NetworkVariable/Collections/NetworkList.cs

@@ -94,18 +94,18 @@ namespace Unity.Netcode
                 {
                     case NetworkListEvent<T>.EventType.Add:
                         {
-                            NetworkVariableSerialization<T>.Write(writer, ref element.Value);
+                            NetworkVariableSerialization<T>.Serializer.Write(writer, ref element.Value);
                         }
                         break;
                     case NetworkListEvent<T>.EventType.Insert:
                         {
                             BytePacker.WriteValueBitPacked(writer, element.Index);
-                            NetworkVariableSerialization<T>.Write(writer, ref element.Value);
+                            NetworkVariableSerialization<T>.Serializer.Write(writer, ref element.Value);
                         }
                         break;
                     case NetworkListEvent<T>.EventType.Remove:
                         {
-                            NetworkVariableSerialization<T>.Write(writer, ref element.Value);
+                            NetworkVariableSerialization<T>.Serializer.Write(writer, ref element.Value);
                         }
                         break;
                     case NetworkListEvent<T>.EventType.RemoveAt:
@@ -116,7 +116,7 @@ namespace Unity.Netcode
                     case NetworkListEvent<T>.EventType.Value:
                         {
                             BytePacker.WriteValueBitPacked(writer, element.Index);
-                            NetworkVariableSerialization<T>.Write(writer, ref element.Value);
+                            NetworkVariableSerialization<T>.Serializer.Write(writer, ref element.Value);
                         }
                         break;
                     case NetworkListEvent<T>.EventType.Clear:
@@ -133,13 +133,13 @@ namespace Unity.Netcode
         {
             if (m_NetworkManager.DistributedAuthorityMode)
             {
-                writer.WriteValueSafe(NetworkVariableSerialization<T>.Type);
-                if (NetworkVariableSerialization<T>.Type == CollectionItemType.Unmanaged)
+                writer.WriteValueSafe(NetworkVariableSerialization<T>.Serializer.Type);
+                if (NetworkVariableSerialization<T>.Serializer.Type == NetworkVariableType.Unmanaged)
                 {
                     // Write the size of the unmanaged serialized type as it has a fixed size. This allows the CMB runtime to correctly read the unmanged type.
                     var placeholder = new T();
                     var startPos = writer.Position;
-                    NetworkVariableSerialization<T>.Write(writer, ref placeholder);
+                    NetworkVariableSerialization<T>.Serializer.Write(writer, ref placeholder);
                     var size = writer.Position - startPos;
                     writer.Seek(startPos);
                     BytePacker.WriteValueBitPacked(writer, size);
@@ -148,7 +148,7 @@ namespace Unity.Netcode
             writer.WriteValueSafe((ushort)m_List.Length);
             for (int i = 0; i < m_List.Length; i++)
             {
-                NetworkVariableSerialization<T>.Write(writer, ref m_List.ElementAt(i));
+                NetworkVariableSerialization<T>.Serializer.Write(writer, ref m_List.ElementAt(i));
             }
         }
 
@@ -158,9 +158,9 @@ namespace Unity.Netcode
             m_List.Clear();
             if (m_NetworkManager.DistributedAuthorityMode)
             {
-                // Collection item type is used by the CMB rust service, drop value here.
-                reader.ReadValueSafe(out CollectionItemType type);
-                if (type == CollectionItemType.Unmanaged)
+                SerializationTools.ReadType(reader, NetworkVariableSerialization<T>.Serializer);
+                // Collection item type is used by the DA server, drop value here.
+                if (NetworkVariableSerialization<T>.Serializer.Type == NetworkVariableType.Unmanaged)
                 {
                     ByteUnpacker.ReadValueBitPacked(reader, out int _);
                 }
@@ -169,7 +169,7 @@ namespace Unity.Netcode
             for (int i = 0; i < count; i++)
             {
                 var value = new T();
-                NetworkVariableSerialization<T>.Read(reader, ref value);
+                NetworkVariableSerialization<T>.Serializer.Read(reader, ref value);
                 m_List.Add(value);
             }
         }
@@ -186,7 +186,7 @@ namespace Unity.Netcode
                     case NetworkListEvent<T>.EventType.Add:
                         {
                             var value = new T();
-                            NetworkVariableSerialization<T>.Read(reader, ref value);
+                            NetworkVariableSerialization<T>.Serializer.Read(reader, ref value);
                             m_List.Add(value);
 
                             if (OnListChanged != null)
@@ -215,7 +215,7 @@ namespace Unity.Netcode
                         {
                             ByteUnpacker.ReadValueBitPacked(reader, out int index);
                             var value = new T();
-                            NetworkVariableSerialization<T>.Read(reader, ref value);
+                            NetworkVariableSerialization<T>.Serializer.Read(reader, ref value);
 
                             if (index < m_List.Length)
                             {
@@ -252,7 +252,7 @@ namespace Unity.Netcode
                     case NetworkListEvent<T>.EventType.Remove:
                         {
                             var value = new T();
-                            NetworkVariableSerialization<T>.Read(reader, ref value);
+                            NetworkVariableSerialization<T>.Serializer.Read(reader, ref value);
                             int index = m_List.IndexOf(value);
                             if (index == -1)
                             {
@@ -315,7 +315,7 @@ namespace Unity.Netcode
                         {
                             ByteUnpacker.ReadValueBitPacked(reader, out int index);
                             var value = new T();
-                            NetworkVariableSerialization<T>.Read(reader, ref value);
+                            NetworkVariableSerialization<T>.Serializer.Read(reader, ref value);
                             if (index >= m_List.Length)
                             {
                                 throw new Exception("Shouldn't be here, index is higher than list length");
@@ -393,7 +393,8 @@ namespace Unity.Netcode
             // check write permissions
             if (!CanClientWrite(m_NetworkManager.LocalClientId))
             {
-                throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
+                LogWritePermissionError();
+                return;
             }
 
             m_List.Add(item);
@@ -414,7 +415,8 @@ namespace Unity.Netcode
             // check write permissions
             if (!CanClientWrite(m_NetworkManager.LocalClientId))
             {
-                throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
+                LogWritePermissionError();
+                return;
             }
 
             m_List.Clear();
@@ -440,7 +442,8 @@ namespace Unity.Netcode
             // check write permissions
             if (!CanClientWrite(m_NetworkManager.LocalClientId))
             {
-                throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
+                LogWritePermissionError();
+                return false;
             }
 
             int index = m_List.IndexOf(item);
@@ -475,7 +478,8 @@ namespace Unity.Netcode
             // check write permissions
             if (!CanClientWrite(m_NetworkManager.LocalClientId))
             {
-                throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
+                LogWritePermissionError();
+                return;
             }
 
             if (index < m_List.Length)
@@ -520,6 +524,8 @@ namespace Unity.Netcode
             HandleAddListEvent(listEvent);
         }
 
+
+
         /// <inheritdoc />
         public T this[int index]
         {
@@ -529,7 +535,8 @@ namespace Unity.Netcode
                 // check write permissions
                 if (!CanClientWrite(m_NetworkManager.LocalClientId))
                 {
-                    throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
+                    LogWritePermissionError();
+                    return;
                 }
 
                 var previousValue = m_List[index];

Runtime/NetworkVariable/NetworkVariable.cs

@@ -94,25 +94,57 @@ namespace Unity.Netcode
         /// <summary>
         /// The value of the NetworkVariable container
         /// </summary>
+        /// <remarks>
+        /// When assigning collections to <see cref="Value"/>, unless it is a completely new collection this will not
+        /// detect any deltas with most managed collection classes since assignment of one collection value to another
+        /// is actually just a reference to the collection itself. <br />
+        /// To detect deltas in a collection, you should invoke <see cref="CheckDirtyState"/> after making modifications to the collection.
+        /// </remarks>
         public virtual T Value
         {
             get => m_InternalValue;
             set
             {
-                // Compare bitwise
-                if (NetworkVariableSerialization<T>.AreEqual(ref m_InternalValue, ref value))
+                if (m_NetworkManager && !CanClientWrite(m_NetworkManager.LocalClientId))
                 {
+                    LogWritePermissionError();
                     return;
                 }
 
-                if (m_NetworkManager && !CanClientWrite(m_NetworkManager.LocalClientId))
+                // Compare the Value being applied to the current value
+                if (!NetworkVariableSerialization<T>.AreEqual(ref m_InternalValue, ref value))
                 {
-                    throw new InvalidOperationException($"[Client-{m_NetworkManager.LocalClientId}][{m_NetworkBehaviour.name}][{Name}] Write permissions ({WritePerm}) for this client instance is not allowed!");
+                    T previousValue = m_InternalValue;
+                    m_InternalValue = value;
+                    SetDirty(true);
+                    m_IsDisposed = false;
+                    OnValueChanged?.Invoke(previousValue, m_InternalValue);
+                }
+            }
         }
 
-                Set(value);
+        /// <summary>
+        /// Invoke this method to check if a collection's items are dirty.
+        /// The default behavior is to exit early if the <see cref="NetworkVariable{T}"/> is already dirty.
+        /// </summary>
+        /// <param name="forceCheck"> when true, this check will force a full item collection check even if the NetworkVariable is already dirty</param>
+        /// <remarks>
+        /// This is to be used as a way to check if a <see cref="NetworkVariable{T}"/> containing a managed collection has any changees to the collection items.<br />
+        /// If you invoked this when a collection is dirty, it will not trigger the <see cref="OnValueChanged"/> unless you set <param name="forceCheck"/> to true. <br />
+        /// </remarks>
+        public bool CheckDirtyState(bool forceCheck = false)
+        {
+            var isDirty = base.IsDirty();
+
+            // Compare the previous with the current if not dirty or forcing a check.
+            if ((!isDirty || forceCheck) && !NetworkVariableSerialization<T>.AreEqual(ref m_PreviousValue, ref m_InternalValue))
+            {
+                SetDirty(true);
+                OnValueChanged?.Invoke(m_PreviousValue, m_InternalValue);
                 m_IsDisposed = false;
+                isDirty = true;
             }
+            return isDirty;
         }
 
         internal ref T RefValue()
@@ -193,19 +225,6 @@ namespace Unity.Netcode
             base.ResetDirty();
         }
 
-        /// <summary>
-        /// Sets the <see cref="Value"/>, marks the <see cref="NetworkVariable{T}"/> dirty, and invokes the <see cref="OnValueChanged"/> callback
-        /// if there are subscribers to that event.
-        /// </summary>
-        /// <param name="value">the new value of type `T` to be set/></param>
-        private protected void Set(T value)
-        {
-            SetDirty(true);
-            T previousValue = m_InternalValue;
-            m_InternalValue = value;
-            OnValueChanged?.Invoke(previousValue, m_InternalValue);
-        }
-
         /// <summary>
         /// Writes the variable to the writer
         /// </summary>
@@ -222,20 +241,22 @@ namespace Unity.Netcode
         /// <param name="keepDirtyDelta">Whether or not the container should keep the dirty delta, or mark the delta as consumed</param>
         public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
         {
+            // In order to get managed collections to properly have a previous and current value, we have to
+            // duplicate the collection at this point before making any modifications to the current.
+            m_HasPreviousValue = true;
+            NetworkVariableSerialization<T>.Duplicate(m_InternalValue, ref m_PreviousValue);
+            NetworkVariableSerialization<T>.ReadDelta(reader, ref m_InternalValue);
+
             // todo:
             // keepDirtyDelta marks a variable received as dirty and causes the server to send the value to clients
             // In a prefect world, whether a variable was A) modified locally or B) received and needs retransmit
             // would be stored in different fields
-
-            T previousValue = m_InternalValue;
-            NetworkVariableSerialization<T>.ReadDelta(reader, ref m_InternalValue);
-
             if (keepDirtyDelta)
             {
                 SetDirty(true);
             }
 
-            OnValueChanged?.Invoke(previousValue, m_InternalValue);
+            OnValueChanged?.Invoke(m_PreviousValue, m_InternalValue);
         }
 
         /// <inheritdoc />

Runtime/NetworkVariable/NetworkVariableBase.cs

@@ -35,7 +35,17 @@ namespace Unity.Netcode
 
         private NetworkManager m_InternalNetworkManager;
 
-        internal virtual NetworkVariableType Type => NetworkVariableType.Custom;
+        internal virtual NetworkVariableType Type => NetworkVariableType.Unknown;
+
+        internal string GetWritePermissionError()
+        {
+            return $"|Client-{m_NetworkManager.LocalClientId}|{m_NetworkBehaviour.name}|{Name}| Write permissions ({WritePerm}) for this client instance is not allowed!";
+        }
+
+        internal void LogWritePermissionError()
+        {
+            Debug.LogError(GetWritePermissionError());
+        }
 
         private protected NetworkManager m_NetworkManager
         {
@@ -177,7 +187,9 @@ namespace Unity.Netcode
 
         internal bool CanSend()
         {
-            var timeSinceLastUpdate = m_NetworkBehaviour.NetworkManager.NetworkTimeSystem.LocalTime - LastUpdateSent;
+            // When connected to a service or not the server, always use the synchronized server time as opposed to the local time
+            var time = m_InternalNetworkManager.CMBServiceConnection || !m_InternalNetworkManager.IsServer ? m_NetworkBehaviour.NetworkManager.ServerTime.Time : m_NetworkBehaviour.NetworkManager.NetworkTimeSystem.LocalTime;
+            var timeSinceLastUpdate = time - LastUpdateSent;
             return
                 (
                     UpdateTraits.MaxSecondsBetweenUpdates > 0 &&
@@ -191,7 +203,8 @@ namespace Unity.Netcode
 
         internal void UpdateLastSentTime()
         {
-            LastUpdateSent = m_NetworkBehaviour.NetworkManager.NetworkTimeSystem.LocalTime;
+            // When connected to a service or not the server, always use the synchronized server time as opposed to the local time
+            LastUpdateSent = m_InternalNetworkManager.CMBServiceConnection || !m_InternalNetworkManager.IsServer ? m_NetworkBehaviour.NetworkManager.ServerTime.Time : m_NetworkBehaviour.NetworkManager.NetworkTimeSystem.LocalTime;
         }
 
         internal static bool IgnoreInitializeWarning;
@@ -254,6 +267,11 @@ namespace Unity.Netcode
         /// <returns>Whether or not the client has permission to read</returns>
         public bool CanClientRead(ulong clientId)
         {
+            if (!m_NetworkBehaviour)
+            {
+                return false;
+            }
+
             // When in distributed authority mode, everyone can read (but only the owner can write)
             if (m_NetworkManager != null && m_NetworkManager.DistributedAuthorityMode)
             {
@@ -276,6 +294,11 @@ namespace Unity.Netcode
         /// <returns>Whether or not the client has permission to write</returns>
         public bool CanClientWrite(ulong clientId)
         {
+            if (!m_NetworkBehaviour)
+            {
+                return false;
+            }
+
             switch (WritePerm)
             {
                 default:
@@ -311,7 +334,6 @@ namespace Unity.Netcode
         /// </summary>
         /// <param name="reader">The stream to read the state from</param>
         public abstract void ReadField(FastBufferReader reader);
-
         /// <summary>
         /// Reads delta from the reader and applies them to the internal value
         /// </summary>
@@ -327,47 +349,4 @@ namespace Unity.Netcode
             m_InternalNetworkManager = null;
         }
     }
-
-    /// <summary>
-    /// Enum representing the different types of Network Variables.
-    /// </summary>
-    public enum NetworkVariableType : byte
-    {
-        /// <summary>
-        /// Value
-        /// Used for all of the basic NetworkVariables that contain a single value
-        /// </summary>
-        Value = 0,
-
-        /// <summary>
-        /// Custom
-        /// For any custom implemented extension of the NetworkVariableBase
-        /// </summary>
-        Custom = 1,
-
-        /// <summary>
-        /// NetworkList
-        /// </summary>
-        NetworkList = 2
-    }
-
-    public enum CollectionItemType : byte
-    {
-        /// <summary>
-        /// For any type that is not valid inside a NetworkVariable collection
-        /// </summary>
-        Unknown = 0,
-
-        /// <summary>
-        /// The following types are valid types inside of NetworkVariable collections
-        /// </summary>
-        Short = 1,
-        UShort = 2,
-        Int = 3,
-        UInt = 4,
-        Long = 5,
-        ULong = 6,
-        Unmanaged = 7,
-    }
-
 }

Runtime/NetworkVariable/NetworkVariableTypes.cs

@@ -0,0 +1,40 @@
+#if UNITY_EDITOR
+#endif
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    ///     Enum representing the different types of Network Variables that can be sent over the network.
+    ///     The values cannot be changed, as they are used to serialize and deserialize variables on the DA server.
+    ///     Adding new variables should be done by adding new values to the end of the enum
+    ///     using the next free value.
+    /// </summary>
+    /// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+    /// Add any new Variable types to this table at the END with incremented index value
+    /// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+    internal enum NetworkVariableType : byte
+    {
+        /// <summary>
+        ///     Value
+        ///     Used for all of the basic NetworkVariables that contain a single value
+        /// </summary>
+        Value = 0,
+        /// <summary>
+        ///     For any type that is not known at runtime
+        /// </summary>
+        Unknown = 1,
+        /// <summary>
+        ///     NetworkList
+        /// </summary>
+        NetworkList = 2,
+
+        // The following types are valid types inside of NetworkVariable collections
+        Short = 11,
+        UShort = 12,
+        Int = 13,
+        UInt = 14,
+        Long = 15,
+        ULong = 16,
+        Unmanaged = 17,
+    }
+}

Runtime/NetworkVariable/NetworkVariableTypes.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: df4a4005f1c842669f94a404019400ed
+timeCreated: 1718292058

Runtime/NetworkVariable/Serialization/FallbackSerializer.cs

@@ -14,6 +14,9 @@ namespace Unity.Netcode
     /// <typeparam name="T"></typeparam>
     internal class FallbackSerializer<T> : INetworkVariableSerializer<T>
     {
+        public NetworkVariableType Type => NetworkVariableType.Unknown;
+        public bool IsDistributedAuthorityOptimized => true;
+
         private void ThrowArgumentError()
         {
             throw new ArgumentException($"Serialization has not been generated for type {typeof(T).FullName}. This can be addressed by adding a [{nameof(GenerateSerializationForGenericParameterAttribute)}] to your generic class that serializes this value (if you are using one), adding [{nameof(GenerateSerializationForTypeAttribute)}(typeof({typeof(T).FullName})] to the class or method that is attempting to serialize it, or creating a field on a {nameof(NetworkBehaviour)} of type {nameof(NetworkVariable<T>)}. If this error continues to appear after doing one of those things and this is a type you can change, then either implement {nameof(INetworkSerializable)} or mark it as serializable by memcpy by adding {nameof(INetworkSerializeByMemcpy)} to its interface list to enable automatic serialization generation. If not, assign serialization code to {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.WriteValue)}, {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.ReadValue)}, and {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.DuplicateValue)}, or if it's serializable by memcpy (contains no pointers), wrap it in {typeof(ForceNetworkSerializeByMemcpy<>).Name}.");
@@ -79,6 +82,11 @@ namespace Unity.Netcode
             }
             UserNetworkVariableSerialization<T>.DuplicateValue(value, ref duplicatedValue);
         }
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref T value) => ThrowArgumentError();
+        public void ReadDistributedAuthority(FastBufferReader reader, ref T value) => ThrowArgumentError();
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref T value, ref T previousValue) => ThrowArgumentError();
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref T value) => ThrowArgumentError();
     }
 
     // RuntimeAccessModifiersILPP will make this `public`

Runtime/NetworkVariable/Serialization/INetworkVariableSerializer.cs

@@ -3,11 +3,27 @@ using Unity.Collections;
 namespace Unity.Netcode
 {
     /// <summary>
-    /// Interface used by NetworkVariables to serialize them
+    /// Interface used by NetworkVariables to serialize them with additional information for the DA runtime
     /// </summary>
     ///
     /// <typeparam name="T"></typeparam>
-    internal interface INetworkVariableSerializer<T>
+    internal interface IDistributedAuthoritySerializer<T>
+    {
+        /// <summary>
+        /// The Type tells the DA server how to parse this type.
+        /// The user should never be able to override this value, as it is meaningful for the DA server
+        /// </summary>
+        public NetworkVariableType Type { get; }
+        public bool IsDistributedAuthorityOptimized { get; }
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref T value);
+        public void ReadDistributedAuthority(FastBufferReader reader, ref T value);
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref T value, ref T previousValue);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref T value);
+    }
+
+
+    /// <typeparam name="T"></typeparam>
+    internal interface INetworkVariableSerializer<T> : IDistributedAuthoritySerializer<T>
     {
         // Write has to be taken by ref here because of INetworkSerializable
         // Open Instance Delegates (pointers to methods without an instance attached to them)

Runtime/NetworkVariable/Serialization/NetworkVariableSerialization.cs

@@ -16,12 +16,6 @@ namespace Unity.Netcode
 
         internal static bool IsDistributedAuthority => NetworkManager.IsDistributedAuthority;
 
-        /// <summary>
-        /// The collection item type tells the CMB server how to read the bytes of each item in the collection
-        /// </summary>
-        /// DANGO-EXP TODO: Determine if this is distributed authority only and impacts of this in client-server
-        internal static CollectionItemType Type = CollectionItemType.Unknown;
-
         /// <summary>
         /// A callback to check if two values are equal.
         /// </summary>
@@ -58,9 +52,22 @@ namespace Unity.Netcode
         /// <param name="writer"></param>
         /// <param name="value"></param>
         public static void Write(FastBufferWriter writer, ref T value)
+        {
+            if (IsDistributedAuthority)
+            {
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
+                if (!NetworkManager.DisableNotOptimizedSerializedType && !Serializer.IsDistributedAuthorityOptimized)
+                {
+                    NetworkManager.LogSerializedTypeNotOptimized<T>();
+                }
+#endif
+                Serializer.WriteDistributedAuthority(writer, ref value);
+            }
+            else
             {
                 Serializer.Write(writer, ref value);
             }
+        }
 
         /// <summary>
         ///     Deserialize a value using the best-known serialization method for a generic value.
@@ -83,9 +90,16 @@ namespace Unity.Netcode
         /// <param name="reader"></param>
         /// <param name="value"></param>
         public static void Read(FastBufferReader reader, ref T value)
+        {
+            if (IsDistributedAuthority)
+            {
+                Serializer.ReadDistributedAuthority(reader, ref value);
+            }
+            else
             {
                 Serializer.Read(reader, ref value);
             }
+        }
 
         /// <summary>
         ///     Serialize a value using the best-known serialization method for a generic value.
@@ -105,9 +119,22 @@ namespace Unity.Netcode
         /// <param name="writer"></param>
         /// <param name="value"></param>
         public static void WriteDelta(FastBufferWriter writer, ref T value, ref T previousValue)
+        {
+            if (IsDistributedAuthority)
+            {
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
+                if (!NetworkManager.DisableNotOptimizedSerializedType && !Serializer.IsDistributedAuthorityOptimized)
+                {
+                    NetworkManager.LogSerializedTypeNotOptimized<T>();
+                }
+#endif
+                Serializer.WriteDeltaDistributedAuthority(writer, ref value, ref previousValue);
+            }
+            else
             {
                 Serializer.WriteDelta(writer, ref value, ref previousValue);
             }
+        }
 
         /// <summary>
         ///     Deserialize a value using the best-known serialization method for a generic value.
@@ -130,9 +157,16 @@ namespace Unity.Netcode
         /// <param name="reader"></param>
         /// <param name="value"></param>
         public static void ReadDelta(FastBufferReader reader, ref T value)
+        {
+            if (IsDistributedAuthority)
+            {
+                Serializer.ReadDeltaDistributedAuthority(reader, ref value);
+            }
+            else
             {
                 Serializer.ReadDelta(reader, ref value);
             }
+        }
 
         /// <summary>
         ///     Duplicates a value using the most efficient means of creating a complete copy.

Runtime/NetworkVariable/Serialization/TypedILPPInitializers.cs

@@ -38,14 +38,6 @@ namespace Unity.Netcode
             NetworkVariableSerialization<long>.AreEqual = NetworkVariableEquality<long>.ValueEquals;
             NetworkVariableSerialization<ulong>.Serializer = new UlongSerializer();
             NetworkVariableSerialization<ulong>.AreEqual = NetworkVariableEquality<ulong>.ValueEquals;
-
-            // DANGO-EXP TODO: Determine if this is distributed authority only and impacts of this in client-server
-            NetworkVariableSerialization<short>.Type = CollectionItemType.Short;
-            NetworkVariableSerialization<ushort>.Type = CollectionItemType.UShort;
-            NetworkVariableSerialization<int>.Type = CollectionItemType.Int;
-            NetworkVariableSerialization<uint>.Type = CollectionItemType.UInt;
-            NetworkVariableSerialization<long>.Type = CollectionItemType.Long;
-            NetworkVariableSerialization<ulong>.Type = CollectionItemType.ULong;
         }
 
         /// <summary>
@@ -55,8 +47,6 @@ namespace Unity.Netcode
         public static void InitializeSerializer_UnmanagedByMemcpy<T>() where T : unmanaged
         {
             NetworkVariableSerialization<T>.Serializer = new UnmanagedTypeSerializer<T>();
-            // DANGO-EXP TODO: Determine if this is distributed authority only and impacts of this in client-server
-            NetworkVariableSerialization<T>.Type = CollectionItemType.Unmanaged;
         }
 
         /// <summary>

Runtime/NetworkVariable/Serialization/TypedSerializerImplementations.cs

@@ -10,6 +10,21 @@ namespace Unity.Netcode
     /// </summary>
     internal class ShortSerializer : INetworkVariableSerializer<short>
     {
+        public NetworkVariableType Type => NetworkVariableType.Short;
+        public bool IsDistributedAuthorityOptimized => true;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref short value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref short value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref short value, ref short previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref short value) => Read(reader, ref value);
+
         public void Write(FastBufferWriter writer, ref short value)
         {
             BytePacker.WriteValueBitPacked(writer, value);
@@ -46,6 +61,20 @@ namespace Unity.Netcode
     /// </summary>
     internal class UshortSerializer : INetworkVariableSerializer<ushort>
     {
+        public NetworkVariableType Type => NetworkVariableType.UShort;
+        public bool IsDistributedAuthorityOptimized => true;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref ushort value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref ushort value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref ushort value, ref ushort previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref ushort value) => Read(reader, ref value);
         public void Write(FastBufferWriter writer, ref ushort value)
         {
             BytePacker.WriteValueBitPacked(writer, value);
@@ -82,6 +111,20 @@ namespace Unity.Netcode
     /// </summary>
     internal class IntSerializer : INetworkVariableSerializer<int>
     {
+        public NetworkVariableType Type => NetworkVariableType.Int;
+        public bool IsDistributedAuthorityOptimized => true;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref int value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref int value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref int value, ref int previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref int value) => Read(reader, ref value);
         public void Write(FastBufferWriter writer, ref int value)
         {
             BytePacker.WriteValueBitPacked(writer, value);
@@ -118,6 +161,20 @@ namespace Unity.Netcode
     /// </summary>
     internal class UintSerializer : INetworkVariableSerializer<uint>
     {
+        public NetworkVariableType Type => NetworkVariableType.UInt;
+        public bool IsDistributedAuthorityOptimized => true;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref uint value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref uint value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref uint value, ref uint previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref uint value) => Read(reader, ref value);
         public void Write(FastBufferWriter writer, ref uint value)
         {
             BytePacker.WriteValueBitPacked(writer, value);
@@ -154,6 +211,20 @@ namespace Unity.Netcode
     /// </summary>
     internal class LongSerializer : INetworkVariableSerializer<long>
     {
+        public NetworkVariableType Type => NetworkVariableType.Long;
+        public bool IsDistributedAuthorityOptimized => true;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref long value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref long value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref long value, ref long previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref long value) => Read(reader, ref value);
         public void Write(FastBufferWriter writer, ref long value)
         {
             BytePacker.WriteValueBitPacked(writer, value);
@@ -190,6 +261,21 @@ namespace Unity.Netcode
     /// </summary>
     internal class UlongSerializer : INetworkVariableSerializer<ulong>
     {
+        public NetworkVariableType Type => NetworkVariableType.ULong;
+        public bool IsDistributedAuthorityOptimized => true;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref ulong value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref ulong value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref ulong value, ref ulong previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref ulong value) => Read(reader, ref value);
+
         public void Write(FastBufferWriter writer, ref ulong value)
         {
             BytePacker.WriteValueBitPacked(writer, value);
@@ -231,6 +317,21 @@ namespace Unity.Netcode
     /// <typeparam name="T"></typeparam>
     internal class UnmanagedTypeSerializer<T> : INetworkVariableSerializer<T> where T : unmanaged
     {
+        public NetworkVariableType Type => NetworkVariableType.Unmanaged;
+        public bool IsDistributedAuthorityOptimized => false;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref T value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref T value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref T value, ref T previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref T value) => Read(reader, ref value);
+
         public void Write(FastBufferWriter writer, ref T value)
         {
             writer.WriteUnmanagedSafe(value);
@@ -264,6 +365,20 @@ namespace Unity.Netcode
 
     internal class ListSerializer<T> : INetworkVariableSerializer<List<T>>
     {
+        public NetworkVariableType Type => NetworkVariableType.Value;
+        public bool IsDistributedAuthorityOptimized => false;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref List<T> value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref List<T> value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref List<T> value, ref List<T> previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref List<T> value) => Read(reader, ref value);
         public void Write(FastBufferWriter writer, ref List<T> value)
         {
             var isNull = value == null;
@@ -343,13 +458,30 @@ namespace Unity.Netcode
             duplicatedValue.Clear();
             foreach (var item in value)
             {
-                duplicatedValue.Add(item);
+                // This handles the nested list scenario List<List<T>>
+                T subValue = default;
+                NetworkVariableSerialization<T>.Duplicate(item, ref subValue);
+                duplicatedValue.Add(subValue);
             }
         }
     }
 
     internal class HashSetSerializer<T> : INetworkVariableSerializer<HashSet<T>> where T : IEquatable<T>
     {
+        public NetworkVariableType Type => NetworkVariableType.Value;
+        public bool IsDistributedAuthorityOptimized => false;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref HashSet<T> value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref HashSet<T> value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref HashSet<T> value, ref HashSet<T> previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref HashSet<T> value) => Read(reader, ref value);
         public void Write(FastBufferWriter writer, ref HashSet<T> value)
         {
             var isNull = value == null;
@@ -419,6 +551,9 @@ namespace Unity.Netcode
             duplicatedValue.Clear();
             foreach (var item in value)
             {
+                // Handles nested HashSets
+                T subValue = default;
+                NetworkVariableSerialization<T>.Duplicate(item, ref subValue);
                 duplicatedValue.Add(item);
             }
         }
@@ -428,6 +563,20 @@ namespace Unity.Netcode
     internal class DictionarySerializer<TKey, TVal> : INetworkVariableSerializer<Dictionary<TKey, TVal>>
         where TKey : IEquatable<TKey>
     {
+        public NetworkVariableType Type => NetworkVariableType.Value;
+        public bool IsDistributedAuthorityOptimized => false;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref Dictionary<TKey, TVal> value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref Dictionary<TKey, TVal> value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref Dictionary<TKey, TVal> value, ref Dictionary<TKey, TVal> previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref Dictionary<TKey, TVal> value) => Read(reader, ref value);
         public void Write(FastBufferWriter writer, ref Dictionary<TKey, TVal> value)
         {
             var isNull = value == null;
@@ -498,13 +647,32 @@ namespace Unity.Netcode
             duplicatedValue.Clear();
             foreach (var item in value)
             {
-                duplicatedValue.Add(item.Key, item.Value);
+                // Handles nested dictionaries
+                TKey subKey = default;
+                TVal subValue = default;
+                NetworkVariableSerialization<TKey>.Duplicate(item.Key, ref subKey);
+                NetworkVariableSerialization<TVal>.Duplicate(item.Value, ref subValue);
+                duplicatedValue.Add(subKey, subValue);
             }
         }
     }
 
     internal class UnmanagedArraySerializer<T> : INetworkVariableSerializer<NativeArray<T>> where T : unmanaged
     {
+        public NetworkVariableType Type => NetworkVariableType.Value;
+        public bool IsDistributedAuthorityOptimized => false;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref NativeArray<T> value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref NativeArray<T> value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref NativeArray<T> value, ref NativeArray<T> previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref NativeArray<T> value) => Read(reader, ref value);
         public void Write(FastBufferWriter writer, ref NativeArray<T> value)
         {
             writer.WriteUnmanagedSafe(value);
@@ -550,6 +718,20 @@ namespace Unity.Netcode
 #if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
     internal class UnmanagedListSerializer<T> : INetworkVariableSerializer<NativeList<T>> where T : unmanaged
     {
+        public NetworkVariableType Type => NetworkVariableType.Value;
+        public bool IsDistributedAuthorityOptimized => false;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref NativeList<T> value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref NativeList<T> value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref NativeList<T> value, ref NativeList<T> previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref NativeList<T> value) => Read(reader, ref value);
         public void Write(FastBufferWriter writer, ref NativeList<T> value)
         {
             writer.WriteUnmanagedSafe(value);
@@ -593,6 +775,21 @@ namespace Unity.Netcode
 
     internal class NativeHashSetSerializer<T> : INetworkVariableSerializer<NativeHashSet<T>> where T : unmanaged, IEquatable<T>
     {
+        public NetworkVariableType Type => NetworkVariableType.Value;
+        public bool IsDistributedAuthorityOptimized => false;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref NativeHashSet<T> value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref NativeHashSet<T> value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref NativeHashSet<T> value, ref NativeHashSet<T> previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref NativeHashSet<T> value) => Read(reader, ref value);
+
         public void Write(FastBufferWriter writer, ref NativeHashSet<T> value)
         {
             writer.WriteValueSafe(value);
@@ -638,6 +835,21 @@ namespace Unity.Netcode
         where TKey : unmanaged, IEquatable<TKey>
         where TVal : unmanaged
     {
+        public NetworkVariableType Type => NetworkVariableType.Value;
+        public bool IsDistributedAuthorityOptimized => false;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref NativeHashMap<TKey, TVal> value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref NativeHashMap<TKey, TVal> value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref NativeHashMap<TKey, TVal> value, ref NativeHashMap<TKey, TVal> previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref NativeHashMap<TKey, TVal> value) => Read(reader, ref value);
+
         public void Write(FastBufferWriter writer, ref NativeHashMap<TKey, TVal> value)
         {
             writer.WriteValueSafe(value);
@@ -685,7 +897,20 @@ namespace Unity.Netcode
     /// <typeparam name="T"></typeparam>
     internal class FixedStringSerializer<T> : INetworkVariableSerializer<T> where T : unmanaged, INativeList<byte>, IUTF8Bytes
     {
-        // The item type can only be bytes for fixedStrings, so the DA runtime doesn't need details on it
+        public NetworkVariableType Type => NetworkVariableType.Value;
+        public bool IsDistributedAuthorityOptimized => false;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref T value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref T value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref T value, ref T previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref T value) => Read(reader, ref value);
 
         public void Write(FastBufferWriter writer, ref T value)
         {
@@ -710,7 +935,7 @@ namespace Unity.Netcode
             {
                 var val = value[i];
                 var prevVal = previousValue[i];
-                if (!NetworkVariableSerialization<byte>.AreEqual(ref val, ref prevVal))
+                if (val != prevVal)
                 {
                     ++numChanges;
                     changes.Set(i);
@@ -731,23 +956,15 @@ namespace Unity.Netcode
                 return;
             }
 
-            writer.WriteByte(0); // Flag that we're sending a delta
+            writer.WriteByteSafe(0); // Flag that we're sending a delta
             BytePacker.WriteValuePacked(writer, value.Length);
             writer.WriteValueSafe(changes);
             var ptr = value.GetUnsafePtr();
-            var prevPtr = previousValue.GetUnsafePtr();
             for (var i = 0; i < value.Length; ++i)
             {
                 if (changes.IsSet(i))
                 {
-                    if (i < previousValue.Length)
-                    {
-                        NetworkVariableSerialization<byte>.WriteDelta(writer, ref ptr[i], ref prevPtr[i]);
-                    }
-                    else
-                    {
-                        NetworkVariableSerialization<byte>.Write(writer, ref ptr[i]);
-                    }
+                    writer.WriteByteSafe(ptr[i]);
                 }
             }
         }
@@ -779,7 +996,7 @@ namespace Unity.Netcode
                 {
                     if (changes.IsSet(i))
                     {
-                        reader.ReadByte(out ptr[i]);
+                        reader.ReadByteSafe(out ptr[i]);
                     }
                 }
             }
@@ -802,6 +1019,20 @@ namespace Unity.Netcode
     /// <typeparam name="T"></typeparam>
     internal class FixedStringArraySerializer<T> : INetworkVariableSerializer<NativeArray<T>> where T : unmanaged, INativeList<byte>, IUTF8Bytes
     {
+        public NetworkVariableType Type => NetworkVariableType.Value;
+        public bool IsDistributedAuthorityOptimized => false;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref NativeArray<T> value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref NativeArray<T> value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref NativeArray<T> value, ref NativeArray<T> previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref NativeArray<T> value) => Read(reader, ref value);
         public void Write(FastBufferWriter writer, ref NativeArray<T> value)
         {
             writer.WriteValueSafe(value);
@@ -852,6 +1083,21 @@ namespace Unity.Netcode
     /// <typeparam name="T"></typeparam>
     internal class FixedStringListSerializer<T> : INetworkVariableSerializer<NativeList<T>> where T : unmanaged, INativeList<byte>, IUTF8Bytes
     {
+        public NetworkVariableType Type => NetworkVariableType.Value;
+        public bool IsDistributedAuthorityOptimized => false;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref NativeList<T> value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref NativeList<T> value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref NativeList<T> value, ref NativeList<T> previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref NativeList<T> value) => Read(reader, ref value);
+
         public void Write(FastBufferWriter writer, ref NativeList<T> value)
         {
             writer.WriteValueSafe(value);
@@ -899,6 +1145,21 @@ namespace Unity.Netcode
     /// <typeparam name="T"></typeparam>
     internal class UnmanagedNetworkSerializableSerializer<T> : INetworkVariableSerializer<T> where T : unmanaged, INetworkSerializable
     {
+        public NetworkVariableType Type => NetworkVariableType.Value;
+        public bool IsDistributedAuthorityOptimized => false;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref T value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref T value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref T value, ref T previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref T value) => Read(reader, ref value);
+
         public void Write(FastBufferWriter writer, ref T value)
         {
             var bufferSerializer = new BufferSerializer<BufferSerializerWriter>(new BufferSerializerWriter(writer));
@@ -951,6 +1212,20 @@ namespace Unity.Netcode
     /// <typeparam name="T"></typeparam>
     internal class UnmanagedNetworkSerializableArraySerializer<T> : INetworkVariableSerializer<NativeArray<T>> where T : unmanaged, INetworkSerializable
     {
+        public NetworkVariableType Type => NetworkVariableType.Value;
+        public bool IsDistributedAuthorityOptimized => false;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref NativeArray<T> value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref NativeArray<T> value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref NativeArray<T> value, ref NativeArray<T> previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref NativeArray<T> value) => Read(reader, ref value);
         public void Write(FastBufferWriter writer, ref NativeArray<T> value)
         {
             writer.WriteNetworkSerializable(value);
@@ -1001,6 +1276,21 @@ namespace Unity.Netcode
     /// <typeparam name="T"></typeparam>
     internal class UnmanagedNetworkSerializableListSerializer<T> : INetworkVariableSerializer<NativeList<T>> where T : unmanaged, INetworkSerializable
     {
+        public NetworkVariableType Type => NetworkVariableType.Value;
+        public bool IsDistributedAuthorityOptimized => false;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref NativeList<T> value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref NativeList<T> value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref NativeList<T> value, ref NativeList<T> previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref NativeList<T> value) => Read(reader, ref value);
+
         public void Write(FastBufferWriter writer, ref NativeList<T> value)
         {
             writer.WriteNetworkSerializable(value);
@@ -1048,6 +1338,20 @@ namespace Unity.Netcode
     ///     <typeparam name="T"></typeparam>
     internal class ManagedNetworkSerializableSerializer<T> : INetworkVariableSerializer<T> where T : class, INetworkSerializable, new()
     {
+        public NetworkVariableType Type => NetworkVariableType.Value;
+        public bool IsDistributedAuthorityOptimized => false;
+
+        public void WriteDistributedAuthority(FastBufferWriter writer, ref T value)
+        {
+            Write(writer, ref value);
+        }
+
+        public void ReadDistributedAuthority(FastBufferReader reader, ref T value)
+        {
+            Read(reader, ref value);
+        }
+        public void WriteDeltaDistributedAuthority(FastBufferWriter writer, ref T value, ref T previousValue) => Write(writer, ref value);
+        public void ReadDeltaDistributedAuthority(FastBufferReader reader, ref T value) => Read(reader, ref value);
         public void Write(FastBufferWriter writer, ref T value)
         {
             var bufferSerializer = new BufferSerializer<BufferSerializerWriter>(new BufferSerializerWriter(writer));

Runtime/NetworkVariable/Serialization/VariableSerializationTools.cs

@@ -0,0 +1,54 @@
+using System.Runtime.CompilerServices;
+using System.Runtime.Serialization;
+
+namespace Unity.Netcode
+{
+
+    internal static class SerializationTools
+    {
+        public delegate void WriteDelegate<T>(FastBufferWriter writer, ref T value);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void WriteWithSize<T>(WriteDelegate<T> writeMethod, FastBufferWriter writer, ref T value)
+        {
+            var writePos = writer.Position;
+            // Note: This value can't be packed because we don't know how large it will be in advance
+            // we reserve space for it, then write the data, then come back and fill in the space
+            // to pack here, we'd have to write data to a temporary buffer and copy it in - which
+            // isn't worth possibly saving one byte if and only if the data is less than 63 bytes long...
+            // The way we do packing, any value > 63 in a ushort will use the full 2 bytes to represent.
+            writer.WriteValueSafe((ushort)0);
+            var startPos = writer.Position;
+            writeMethod(writer, ref value);
+            var size = writer.Position - startPos;
+            writer.Seek(writePos);
+            writer.WriteValueSafe((ushort)size);
+            writer.Seek(startPos + size);
+        }
+
+        public delegate void ReadDelegate<T>(FastBufferReader writer, ref T value);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ReadWithSize<T>(ReadDelegate<T> readMethod, FastBufferReader reader, ref T value)
+        {
+            reader.ReadValueSafe(out ushort _);
+            readMethod(reader, ref value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void WriteType(FastBufferWriter writer, NetworkVariableType type) => writer.WriteValueSafe(type);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ReadType<T>(FastBufferReader reader, INetworkVariableSerializer<T> serializer)
+        {
+            reader.ReadValueSafe(out NetworkVariableType type);
+            if (type != serializer.Type)
+            {
+                throw new SerializationException();
+            }
+        }
+
+
+    }
+
+}

Runtime/NetworkVariable/Serialization/VariableSerializationTools.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 52a4ce368df54b0a8887c08f3402bcd3
+timeCreated: 1718300602

Runtime/SceneManagement/DefaultSceneManagerHandler.cs

@@ -227,6 +227,11 @@ namespace Unity.Netcode
             foreach (var sceneToUnload in m_ScenesToUnload)
             {
                 SceneManager.UnloadSceneAsync(sceneToUnload);
+                // Update the ScenesLoaded when we unload scenes
+                if (sceneManager.ScenesLoaded.ContainsKey(sceneToUnload.handle))
+                {
+                    sceneManager.ScenesLoaded.Remove(sceneToUnload.handle);
+                }
             }
         }
 
@@ -328,8 +333,9 @@ namespace Unity.Netcode
         public void SetClientSynchronizationMode(ref NetworkManager networkManager, LoadSceneMode mode)
         {
             var sceneManager = networkManager.SceneManager;
-            // Don't let non-authority set this value
-            if ((!networkManager.DistributedAuthorityMode && !networkManager.IsServer) || (networkManager.DistributedAuthorityMode && !networkManager.LocalClient.IsSessionOwner))
+            // In client-server, we don't let client's set this value.
+            // In distributed authority, since session owner can be promoted clients can set this value
+            if (!networkManager.DistributedAuthorityMode && !networkManager.IsServer)
             {
                 if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                 {
@@ -338,7 +344,7 @@ namespace Unity.Netcode
                 return;
             }
             else // Warn users if they are changing this after there are clients already connected and synchronized
-            if (networkManager.ConnectedClientsIds.Count > (networkManager.IsHost ? 1 : 0) && sceneManager.ClientSynchronizationMode != mode)
+            if (!networkManager.DistributedAuthorityMode && networkManager.ConnectedClientsIds.Count > (networkManager.IsHost ? 1 : 0) && sceneManager.ClientSynchronizationMode != mode)
             {
                 if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                 {

Runtime/SceneManagement/NetworkSceneManager.cs

@@ -774,6 +774,7 @@ namespace Unity.Netcode
         /// <summary>
         /// This setting changes how clients handle scene loading when initially synchronizing with the server.<br />
         /// The server or host should set this value as clients will automatically be synchronized with the server (or host) side.
+        /// </summary>
         /// <remarks>
         /// <b>LoadSceneMode.Single:</b> All currently loaded scenes on the client will be unloaded and the
         /// server's currently active scene will be loaded in single mode on the client unless it was already
@@ -2406,16 +2407,6 @@ namespace Unity.Netcode
                                 NetworkManager.ConnectionManager.CreateAndSpawnPlayer(NetworkManager.LocalClientId);
                             }
 
-                            // Client is now synchronized and fully "connected".  This also means the client can send "RPCs" at this time
-                            NetworkManager.ConnectionManager.InvokeOnClientConnectedCallback(NetworkManager.LocalClientId);
-
-                            // Notify the client that they have finished synchronizing
-                            OnSceneEvent?.Invoke(new SceneEvent()
-                            {
-                                SceneEventType = sceneEventData.SceneEventType,
-                                ClientId = NetworkManager.LocalClientId, // Client sent this to the server
-                            });
-
                             // Process any SceneEventType.ObjectSceneChanged messages that
                             // were deferred while synchronizing and migrate the associated
                             // NetworkObjects to their newly assigned scenes.
@@ -2429,6 +2420,16 @@ namespace Unity.Netcode
                                 SceneManagerHandler.UnloadUnassignedScenes(NetworkManager);
                             }
 
+                            // Client is now synchronized and fully "connected".  This also means the client can send "RPCs" at this time
+                            NetworkManager.ConnectionManager.InvokeOnClientConnectedCallback(NetworkManager.LocalClientId);
+
+                            // Notify the client that they have finished synchronizing
+                            OnSceneEvent?.Invoke(new SceneEvent()
+                            {
+                                SceneEventType = sceneEventData.SceneEventType,
+                                ClientId = NetworkManager.LocalClientId, // Client sent this to the server
+                            });
+
                             OnSynchronizeComplete?.Invoke(NetworkManager.LocalClientId);
 
                             if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
@@ -2436,10 +2437,7 @@ namespace Unity.Netcode
                                 NetworkLog.LogInfo($"[Client-{NetworkManager.LocalClientId}][Scene Management Enabled] Synchronization complete!");
                             }
                             // For convenience, notify all NetworkBehaviours that synchronization is complete.
-                            foreach (var networkObject in NetworkManager.SpawnManager.SpawnedObjectsList)
-                            {
-                                networkObject.InternalNetworkSessionSynchronized();
-                            }
+                            NetworkManager.SpawnManager.NotifyNetworkObjectsSynchronized();
 
                             if (NetworkManager.DistributedAuthorityMode && HasSceneAuthority() && IsRestoringSession)
                             {
@@ -2552,17 +2550,6 @@ namespace Unity.Netcode
                         // At this point the client is considered fully "connected"
                         if ((NetworkManager.DistributedAuthorityMode && NetworkManager.LocalClient.IsSessionOwner) || !NetworkManager.DistributedAuthorityMode)
                         {
-                            if (NetworkManager.DistributedAuthorityMode && !NetworkManager.DAHost)
-                            {
-                                // DANGO-EXP TODO: Remove this once service is sending the synchronization message to all clients
-                                if (NetworkManager.ConnectedClients.ContainsKey(clientId) && NetworkManager.ConnectionManager.ConnectedClientIds.Contains(clientId) && NetworkManager.ConnectedClientsList.Contains(NetworkManager.ConnectedClients[clientId]))
-                                {
-                                    EndSceneEvent(sceneEventId);
-                                    return;
-                                }
-                                NetworkManager.ConnectionManager.AddClient(clientId);
-                            }
-
                             // Notify the local server that a client has finished synchronizing
                             OnSceneEvent?.Invoke(new SceneEvent()
                             {
@@ -2577,6 +2564,20 @@ namespace Unity.Netcode
                         }
                         else
                         {
+                            // Notify the local server that a client has finished synchronizing
+                            OnSceneEvent?.Invoke(new SceneEvent()
+                            {
+                                SceneEventType = sceneEventData.SceneEventType,
+                                SceneName = string.Empty,
+                                ClientId = clientId
+                            });
+
+                            // Show any NetworkObjects that are:
+                            // - Hidden from the session owner
+                            // - Owned by this client
+                            // - Has NetworkObject.SpawnWithObservers set to true (the default)
+                            NetworkManager.SpawnManager.ShowHiddenObjectsToNewlyJoinedClient(clientId);
+
                             // DANGO-EXP TODO: Remove this once service distributes objects
                             // Non-session owners receive this notification from newly connected clients and upon receiving
                             // the event they will redistribute their NetworkObjects
@@ -2591,9 +2592,6 @@ namespace Unity.Netcode
                         // At this time the client is fully synchronized with all loaded scenes and
                         // NetworkObjects and should be considered "fully connected". Send the
                         // notification that the client is connected.
-                        // TODO 2023: We should have a better name for this or have multiple states the
-                        // client progresses through (the name and associated legacy behavior/expected state
-                        // of the client was persisted since MLAPI)
                         NetworkManager.ConnectionManager.InvokeOnClientConnectedCallback(clientId);
 
                         if (NetworkManager.IsHost)
@@ -2666,9 +2664,14 @@ namespace Unity.Netcode
                                 EventData = sceneEventData,
                             };
                             // Forward synchronization to client then exit early because DAHost is not the current session owner
-                            NetworkManager.MessageManager.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, NetworkManager.CurrentSessionOwner);
-                            EndSceneEvent(sceneEventData.SceneEventId);
-                            return;
+                            foreach (var client in NetworkManager.ConnectedClientsIds)
+                            {
+                                if (client == NetworkManager.LocalClientId)
+                                {
+                                    continue;
+                                }
+                                NetworkManager.MessageManager.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, client);
+                            }
                         }
                     }
                     else

Runtime/Serialization/FastBufferWriter.cs

@@ -700,7 +700,7 @@ namespace Unity.Netcode
             }
             if (Handle->Position + size > Handle->AllowedWriteMark)
             {
-                throw new OverflowException($"Attempted to write without first calling {nameof(TryBeginWrite)}()");
+                throw new OverflowException($"Attempted to write without first calling {nameof(TryBeginWrite)}(), Position+Size={Handle->Position + size} > AllowedWriteMark={Handle->AllowedWriteMark}");
             }
 #endif
             UnsafeUtility.MemCpy((Handle->BufferPointer + Handle->Position), value + offset, size);
@@ -729,7 +729,7 @@ namespace Unity.Netcode
 
             if (!TryBeginWriteInternal(size))
             {
-                throw new OverflowException("Writing past the end of the buffer");
+                throw new OverflowException($"Writing past the end of the buffer, size is {size} bytes but remaining capacity is {Handle->Capacity - Handle->Position} bytes");
             }
             UnsafeUtility.MemCpy((Handle->BufferPointer + Handle->Position), value + offset, size);
             Handle->Position += size;

Runtime/Spawning/NetworkSpawnManager.cs

@@ -643,7 +643,7 @@ namespace Unity.Netcode
                 return null;
             }
 
-            ownerClientId = NetworkManager.DistributedAuthorityMode ? NetworkManager.LocalClientId : NetworkManager.ServerClientId;
+            ownerClientId = NetworkManager.DistributedAuthorityMode ? NetworkManager.LocalClientId : ownerClientId;
             // We only need to check for authority when running in client-server mode
             if (!NetworkManager.IsServer && !NetworkManager.DistributedAuthorityMode)
             {
@@ -1580,22 +1580,48 @@ namespace Unity.Netcode
             if (NetworkManager.DistributedAuthorityMode && !NetworkManager.DAHost)
             {
                 foreach (var entry in ClientsToShowObject)
+                {
+                    if (entry.Key != null && entry.Key.IsSpawned)
+                    {
+                        try
                         {
                             SendSpawnCallForObserverUpdate(entry.Value.ToArray(), entry.Key);
                         }
+                        catch (Exception ex)
+                        {
+                            if (NetworkManager.LogLevel <= LogLevel.Developer)
+                            {
+                                Debug.LogException(ex);
+                            }
+                        }
+                    }
+                }
                 ClientsToShowObject.Clear();
                 ObjectsToShowToClient.Clear();
                 return;
             }
 
-            // Handle NetworkObjects to show
+            // Server or Host handling of NetworkObjects to show
             foreach (var client in ObjectsToShowToClient)
             {
                 ulong clientId = client.Key;
                 foreach (var networkObject in client.Value)
+                {
+                    if (networkObject != null && networkObject.IsSpawned)
+                    {
+                        try
                         {
                             SendSpawnCallForObject(clientId, networkObject);
                         }
+                        catch (Exception ex)
+                        {
+                            if (NetworkManager.LogLevel <= LogLevel.Developer)
+                            {
+                                Debug.LogException(ex);
+                            }
+                        }
+                    }
+                }
             }
             ObjectsToShowToClient.Clear();
         }
@@ -1820,11 +1846,14 @@ namespace Unity.Netcode
                 return;
             }
             var currentTick = serverTime.Tick;
-            var deferredCallbackObjects = DeferredDespawnObjects.Where((c) => c.HasDeferredDespawnCheck);
-            var deferredCallbackCount = deferredCallbackObjects.Count();
-            for (int i = 0; i < deferredCallbackCount - 1; i++)
+            var deferredCallbackCount = DeferredDespawnObjects.Count();
+            for (int i = 0; i < deferredCallbackCount; i++)
             {
-                var deferredObjectEntry = deferredCallbackObjects.ElementAt(i);
+                var deferredObjectEntry = DeferredDespawnObjects[i];
+                if (!deferredObjectEntry.HasDeferredDespawnCheck)
+                {
+                    continue;
+                }
                 var networkObject = SpawnedObjects[deferredObjectEntry.NetworkObjectId];
                 // Double check to make sure user did not remove the callback
                 if (networkObject.OnDeferredDespawnComplete != null)
@@ -1849,9 +1878,15 @@ namespace Unity.Netcode
                 }
             }
 
-            var despawnObjects = DeferredDespawnObjects.Where((c) => c.TickToDespawn < currentTick).ToList();
-            foreach (var deferredObjectEntry in despawnObjects)
+            // Parse backwards so we can remove objects as we parse through them
+            for (int i = DeferredDespawnObjects.Count - 1; i >= 0; i--)
             {
+                var deferredObjectEntry = DeferredDespawnObjects[i];
+                if (deferredObjectEntry.TickToDespawn >= currentTick)
+                {
+                    continue;
+                }
+
                 if (!SpawnedObjects.ContainsKey(deferredObjectEntry.NetworkObjectId))
                 {
                     DeferredDespawnObjects.Remove(deferredObjectEntry);
@@ -1863,5 +1898,66 @@ namespace Unity.Netcode
                 DeferredDespawnObjects.Remove(deferredObjectEntry);
             }
         }
+
+        internal void NotifyNetworkObjectsSynchronized()
+        {
+            // Users could spawn NetworkObjects during these notifications.
+            // Create a separate list from the hashset to avoid list modification errors.
+            var spawnedObjects = SpawnedObjectsList.ToList();
+            foreach (var networkObject in spawnedObjects)
+            {
+                networkObject.InternalNetworkSessionSynchronized();
+            }
+        }
+
+        /// <summary>
+        /// Distributed Authority Only
+        /// Should be invoked on non-session owner clients when a newly joined client is finished
+        /// synchronizing in order to "show" (spawn) anything that might be currently hidden from
+        /// the session owner.
+        /// </summary>
+        internal void ShowHiddenObjectsToNewlyJoinedClient(ulong newClientId)
+        {
+            if (!NetworkManager.DistributedAuthorityMode)
+            {
+                if (NetworkManager == null || !NetworkManager.ShutdownInProgress && NetworkManager.LogLevel <= LogLevel.Developer)
+                {
+                    Debug.LogWarning($"[Internal Error] {nameof(ShowHiddenObjectsToNewlyJoinedClient)} invoked while !");
+                }
+                return;
+            }
+
+            if (!NetworkManager.DistributedAuthorityMode)
+            {
+                Debug.LogError($"[Internal Error] {nameof(ShowHiddenObjectsToNewlyJoinedClient)} should only be invoked when using a distributed authority network topology!");
+                return;
+            }
+
+            if (NetworkManager.LocalClient.IsSessionOwner)
+            {
+                Debug.LogError($"[Internal Error] {nameof(ShowHiddenObjectsToNewlyJoinedClient)} should only be invoked on a non-session owner client!");
+                return;
+            }
+            var localClientId = NetworkManager.LocalClient.ClientId;
+            var sessionOwnerId = NetworkManager.CurrentSessionOwner;
+            foreach (var networkObject in SpawnedObjectsList)
+            {
+                if (networkObject.SpawnWithObservers && networkObject.OwnerClientId == localClientId && !networkObject.Observers.Contains(sessionOwnerId))
+                {
+                    if (networkObject.Observers.Contains(newClientId))
+                    {
+                        if (NetworkManager.LogLevel <= LogLevel.Developer)
+                        {
+                            // Track if there is some other location where the client is being added to the observers list when the object is hidden from the session owner
+                            Debug.LogWarning($"[{networkObject.name}] Has new client as an observer but it is hidden from the session owner!");
+                        }
+                        // For now, remove the client (impossible for the new client to have an instance since the session owner doesn't) to make sure newly added
+                        // code to handle this edge case works.
+                        networkObject.Observers.Remove(newClientId);
+                    }
+                    networkObject.NetworkShow(newClientId);
+                }
+            }
+        }
     }
 }

Runtime/Transports/UTP/UnityTransport.cs

@@ -428,6 +428,31 @@ namespace Unity.Netcode.Transports.UTP
 
         protected NetworkDriver m_Driver;
 
+        /// <summary>
+        /// Gets a reference to the <see cref="Networking.Transport.NetworkDriver"/>.
+        /// </summary>
+        /// <returns>ref <see cref="Networking.Transport.NetworkDriver"/></returns>
+        public ref NetworkDriver GetNetworkDriver()
+        {
+            return ref m_Driver;
+        }
+
+        /// <summary>
+        /// Gets the local sytem's <see cref="NetworkEndpoint"/> that is assigned for the current network session.
+        /// </summary>
+        /// <remarks>
+        /// If the driver is not created it will return an invalid <see cref="NetworkEndpoint"/>.
+        /// </remarks>
+        /// <returns><see cref="NetworkEndpoint"/></returns>
+        public NetworkEndpoint GetLocalEndpoint()
+        {
+            if (m_Driver.IsCreated)
+            {
+                return m_Driver.GetLocalEndpoint();
+            }
+            return new NetworkEndpoint();
+        }
+
         private PacketLossCache m_PacketLossCache = new PacketLossCache();
 
         private State m_State = State.Disconnected;
@@ -450,7 +475,10 @@ namespace Unity.Netcode.Transports.UTP
 
         private RelayServerData m_RelayServerData;
 
-        internal NetworkManager NetworkManager;
+        /// <summary>
+        /// NetworkManager associated to this transport instance
+        /// </summary>
+        protected NetworkManager m_NetworkManager;
 
         private IRealTimeProvider m_RealTimeProvider;
 
@@ -795,10 +823,10 @@ namespace Unity.Netcode.Transports.UTP
             }
 
             var mtu = 0;
-            if (NetworkManager)
+            if (m_NetworkManager)
             {
-                var ngoClientId = NetworkManager.ConnectionManager.TransportIdToClientId(sendTarget.ClientId);
-                mtu = NetworkManager.GetPeerMTU(ngoClientId);
+                var ngoClientId = m_NetworkManager.ConnectionManager.TransportIdToClientId(sendTarget.ClientId);
+                mtu = m_NetworkManager.GetPeerMTU(ngoClientId);
             }
 
             new SendBatchedMessagesJob
@@ -947,7 +975,7 @@ namespace Unity.Netcode.Transports.UTP
                 }
 
 #if MULTIPLAYER_TOOLS_1_0_0_PRE_7
-                if (NetworkManager)
+                if (m_NetworkManager)
                 {
                     ExtractNetworkMetrics();
                 }
@@ -963,16 +991,16 @@ namespace Unity.Netcode.Transports.UTP
 #if MULTIPLAYER_TOOLS_1_0_0_PRE_7
         private void ExtractNetworkMetrics()
         {
-            if (NetworkManager.IsServer)
+            if (m_NetworkManager.IsServer)
             {
-                var ngoConnectionIds = NetworkManager.ConnectedClients.Keys;
+                var ngoConnectionIds = m_NetworkManager.ConnectedClients.Keys;
                 foreach (var ngoConnectionId in ngoConnectionIds)
                 {
-                    if (ngoConnectionId == 0 && NetworkManager.IsHost)
+                    if (ngoConnectionId == 0 && m_NetworkManager.IsHost)
                     {
                         continue;
                     }
-                    var transportClientId = NetworkManager.ConnectionManager.ClientIdToTransportId(ngoConnectionId);
+                    var transportClientId = m_NetworkManager.ConnectionManager.ClientIdToTransportId(ngoConnectionId);
                     ExtractNetworkMetricsForClient(transportClientId);
                 }
             }
@@ -992,10 +1020,10 @@ namespace Unity.Netcode.Transports.UTP
             ExtractNetworkMetricsFromPipeline(m_UnreliableSequencedFragmentedPipeline, networkConnection);
             ExtractNetworkMetricsFromPipeline(m_ReliableSequencedPipeline, networkConnection);
 
-            var rttValue = NetworkManager.IsServer ? 0 : ExtractRtt(networkConnection);
+            var rttValue = m_NetworkManager.IsServer ? 0 : ExtractRtt(networkConnection);
             NetworkMetrics.UpdateRttToServer(rttValue);
 
-            var packetLoss = NetworkManager.IsServer ? 0 : ExtractPacketLoss(networkConnection);
+            var packetLoss = m_NetworkManager.IsServer ? 0 : ExtractPacketLoss(networkConnection);
             NetworkMetrics.UpdatePacketLoss(packetLoss);
         }
 
@@ -1199,9 +1227,9 @@ namespace Unity.Netcode.Transports.UTP
             // use the transport client ID) or from a user (which will be using the NGO client ID).
             // So we just try both cases (ExtractRtt returns 0 for invalid connections).
 
-            if (NetworkManager != null)
+            if (m_NetworkManager != null)
             {
-                var transportId = NetworkManager.ConnectionManager.ClientIdToTransportId(clientId);
+                var transportId = m_NetworkManager.ConnectionManager.ClientIdToTransportId(clientId);
 
                 var rtt = ExtractRtt(ParseClientId(transportId));
                 if (rtt > 0)
@@ -1221,14 +1249,14 @@ namespace Unity.Netcode.Transports.UTP
         {
             Debug.Assert(sizeof(ulong) == UnsafeUtility.SizeOf<NetworkConnection>(), "Netcode connection id size does not match UTP connection id size");
 
-            NetworkManager = networkManager;
+            m_NetworkManager = networkManager;
 
-            if (NetworkManager && NetworkManager.PortOverride.Overidden)
+            if (m_NetworkManager && m_NetworkManager.PortOverride.Overidden)
             {
-                ConnectionData.Port = NetworkManager.PortOverride.Value;
+                ConnectionData.Port = m_NetworkManager.PortOverride.Value;
             }
 
-            m_RealTimeProvider = NetworkManager ? NetworkManager.RealTimeProvider : new RealTimeProvider();
+            m_RealTimeProvider = m_NetworkManager ? m_NetworkManager.RealTimeProvider : new RealTimeProvider();
 
             m_NetworkSettings = new NetworkSettings(Allocator.Persistent);
 
@@ -1322,7 +1350,7 @@ namespace Unity.Netcode.Transports.UTP
                     // provide any reliability guarantees anymore. Disconnect the client since at
                     // this point they're bound to become desynchronized.
 
-                    var ngoClientId = NetworkManager?.ConnectionManager.TransportIdToClientId(clientId) ?? clientId;
+                    var ngoClientId = m_NetworkManager?.ConnectionManager.TransportIdToClientId(clientId) ?? clientId;
                     Debug.LogError($"Couldn't add payload of size {payload.Count} to reliable send queue. " +
                         $"Closing connection {ngoClientId} as reliability guarantees can't be maintained.");
 
@@ -1479,7 +1507,7 @@ namespace Unity.Netcode.Transports.UTP
 
         protected override NetworkTopologyTypes OnCurrentTopology()
         {
-            return NetworkManager != null ? NetworkManager.NetworkConfig.NetworkTopology : NetworkTopologyTypes.ClientServer;
+            return m_NetworkManager != null ? m_NetworkManager.NetworkConfig.NetworkTopology : NetworkTopologyTypes.ClientServer;
         }
 
         private string m_ServerPrivateKey;
@@ -1555,7 +1583,7 @@ namespace Unity.Netcode.Transports.UTP
                 heartbeatTimeoutMS: transport.m_HeartbeatTimeoutMS);
 
 #if UNITY_WEBGL && !UNITY_EDITOR
-            if (NetworkManager.IsServer && m_ProtocolType != ProtocolType.RelayUnityTransport)
+            if (m_NetworkManager.IsServer && m_ProtocolType != ProtocolType.RelayUnityTransport)
             {
                 throw new Exception("WebGL as a server is not supported by Unity Transport, outside the Editor.");
             }
@@ -1577,7 +1605,7 @@ namespace Unity.Netcode.Transports.UTP
                 }
                 else
                 {
-                    if (NetworkManager.IsServer)
+                    if (m_NetworkManager.IsServer)
                     {
                         if (string.IsNullOrEmpty(m_ServerCertificate) || string.IsNullOrEmpty(m_ServerPrivateKey))
                         {

Runtime/com.unity.netcode.runtime.asmdef

@@ -72,6 +72,11 @@
             "name": "com.unity.services.multiplayer",
             "expression": "0.2.0",
             "define": "MULTIPLAYER_SERVICES_SDK_INSTALLED"
+        },
+        {
+            "name": "Unity",
+            "expression": "6000.0.11f1",
+            "define": "COM_UNITY_MODULES_PHYSICS2D_LINEAR"
         }
     ],
     "noEngineReferences": false

TestHelpers/Runtime/IntegrationTestSceneHandler.cs

@@ -677,6 +677,11 @@ namespace Unity.Netcode.TestHelpers.Runtime
             foreach (var sceneToUnload in m_ScenesToUnload)
             {
                 SceneManager.UnloadSceneAsync(sceneToUnload.Key);
+                // Update the ScenesLoaded when we unload scenes
+                if (sceneManager.ScenesLoaded.ContainsKey(sceneToUnload.Key.handle))
+                {
+                    sceneManager.ScenesLoaded.Remove(sceneToUnload.Key.handle);
+                }
             }
         }
 
@@ -795,8 +800,9 @@ namespace Unity.Netcode.TestHelpers.Runtime
 
             var sceneManager = networkManager.SceneManager;
 
-            // Don't let client's set this value
-            if (!networkManager.IsServer)
+            // In client-server, we don't let client's set this value.
+            // In dsitributed authority, since session owner can be promoted clients can set this value
+            if (!networkManager.DistributedAuthorityMode && !networkManager.IsServer)
             {
                 if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                 {
@@ -804,7 +810,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
                 }
                 return;
             }
-            else if (networkManager.ConnectedClientsIds.Count > (networkManager.IsHost ? 1 : 0) && sceneManager.ClientSynchronizationMode != mode)
+            else if (!networkManager.DistributedAuthorityMode && networkManager.ConnectedClientsIds.Count > (networkManager.IsHost ? 1 : 0) && sceneManager.ClientSynchronizationMode != mode)
             {
                 if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                 {

TestHelpers/Runtime/NetcodeIntegrationTest.cs

@@ -303,6 +303,11 @@ namespace Unity.Netcode.TestHelpers.Runtime
             OnOneTimeSetup();
 
             VerboseDebug($"Exiting {nameof(OneTimeSetup)}");
+
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
+            // Default to not log the serialized type not optimized warning message when testing.
+            NetworkManager.DisableNotOptimizedSerializedType = true;
+#endif
         }
 
         /// <summary>
@@ -845,6 +850,12 @@ namespace Unity.Netcode.TestHelpers.Runtime
 
         protected virtual bool LogAllMessages => false;
 
+        protected virtual bool ShouldCheckForSpawnedPlayers()
+        {
+            return true;
+        }
+
+
         /// <summary>
         /// This starts the server and clients as long as <see cref="CanStartServerAndClients"/>
         /// returns true.
@@ -933,7 +944,12 @@ namespace Unity.Netcode.TestHelpers.Runtime
                             AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for all sessions to spawn Client-{m_ServerNetworkManager.LocalClientId}'s player object!\n {m_InternalErrorLog}");
                         }
                     }
+
+                    if (ShouldCheckForSpawnedPlayers())
+                    {
                         ClientNetworkManagerPostStartInit();
+                    }
+
                     // Notification that at this time the server and client(s) are instantiated,
                     // started, and connected on both sides.
                     yield return OnServerAndClientsConnected();
@@ -1025,7 +1041,10 @@ namespace Unity.Netcode.TestHelpers.Runtime
                         }
                     }
 
+                    if (ShouldCheckForSpawnedPlayers())
+                    {
                         ClientNetworkManagerPostStartInit();
+                    }
 
                     // Notification that at this time the server and client(s) are instantiated,
                     // started, and connected on both sides.

TestHelpers/Runtime/NetcodeIntegrationTestHelpers.cs

@@ -326,21 +326,31 @@ namespace Unity.Netcode.TestHelpers.Runtime
 
             s_IsStarted = false;
 
+            try
+            {
                 // Shutdown the server which forces clients to disconnect
                 foreach (var networkManager in NetworkManagerInstances)
                 {
-                networkManager.Shutdown();
+                    if (networkManager != null && networkManager.IsListening)
+                    {
+                        networkManager?.Shutdown();
                         s_Hooks.Remove(networkManager);
                     }
+                }
 
                 // Destroy the network manager instances
                 foreach (var networkManager in NetworkManagerInstances)
                 {
-                if (networkManager.gameObject != null)
+                    if (networkManager != null && networkManager.gameObject)
                     {
                         Object.DestroyImmediate(networkManager.gameObject);
                     }
                 }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogException(ex);
+            }
 
             NetworkManagerInstances.Clear();
 
@@ -620,7 +630,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// Similar to WaitForClientConnected, this waits for multiple clients to be connected.
         /// </summary>
         /// <param name="clients">The clients to be connected</param>
-        /// <param name="result">The result. If null, it will automatically assert<</param>
+        /// <param name="result">The result. If null, it will automatically assert</param>
         /// <param name="maxFrames">The max frames to wait for</param>
         /// <returns></returns>
         public static IEnumerator WaitForClientsConnected(NetworkManager[] clients, ResultWrapper<bool> result = null, float timeout = DefaultTimeout)

TestHelpers/Runtime/NetworkVariableHelper.cs

@@ -8,8 +8,10 @@ namespace Unity.Netcode.TestHelpers.Runtime
     /// delegate handler. It then will expose that single delegate invocation
     /// to anything that registers for this NetworkVariableHelper's instance's OnValueChanged event.
     /// This allows us to register any NetworkVariable type as well as there are basically two "types of types":
-    /// IEquatable<T>
-    /// ValueType
+    /// <list type="bullet">
+    /// <item>IEquatable&lt;T&gt;</item>
+    /// <item>ValueType</item>
+    /// </list>
     /// From both we can then at least determine if the value indeed changed
     /// </summary>
     /// <typeparam name="T"></typeparam>
@@ -20,7 +22,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
         public event OnMyValueChangedDelegateHandler OnValueChanged;
 
         /// <summary>
-        /// IEquatable<T> Equals Check
+        /// IEquatable&lt;T&gt; Equals Check
         /// </summary>
         private void CheckVariableChanged(IEquatable<T> previous, IEquatable<T> next)
         {

Tests/Runtime/ConnectionApproval.cs

@@ -1,65 +1,135 @@
 using System;
 using System.Collections;
+using System.Collections.Generic;
 using System.Text;
 using NUnit.Framework;
 using Unity.Netcode.TestHelpers.Runtime;
-using UnityEngine;
 using UnityEngine.TestTools;
 
 namespace Unity.Netcode.RuntimeTests
 {
-    internal class ConnectionApprovalTests
+    [TestFixture(PlayerCreation.Prefab)]
+    [TestFixture(PlayerCreation.PrefabHash)]
+    [TestFixture(PlayerCreation.NoPlayer)]
+    [TestFixture(PlayerCreation.FailValidation)]
+    internal class ConnectionApprovalTests : NetcodeIntegrationTest
     {
-        private Guid m_ValidationToken;
-        private bool m_IsValidated;
+        private const string k_InvalidToken = "Invalid validation token!";
+        public enum PlayerCreation
+        {
+            Prefab,
+            PrefabHash,
+            NoPlayer,
+            FailValidation
+        }
+        private PlayerCreation m_PlayerCreation;
+        private bool m_ClientDisconnectReasonValidated;
 
-        [SetUp]
-        public void Setup()
+        private Dictionary<ulong, bool> m_Validated = new Dictionary<ulong, bool>();
+
+        public ConnectionApprovalTests(PlayerCreation playerCreation)
         {
-            // Create, instantiate, and host
-            Assert.IsTrue(NetworkManagerHelper.StartNetworkManager(out _, NetworkManagerHelper.NetworkManagerOperatingMode.None));
+            m_PlayerCreation = playerCreation;
+        }
+
+        protected override int NumberOfClients => 1;
+
+        private Guid m_ValidationToken;
+
+        protected override bool ShouldCheckForSpawnedPlayers()
+        {
+            return m_PlayerCreation != PlayerCreation.NoPlayer;
+        }
+
+        protected override void OnServerAndClientsCreated()
+        {
+            m_ClientDisconnectReasonValidated = false;
+            m_BypassConnectionTimeout = m_PlayerCreation == PlayerCreation.FailValidation;
+            m_Validated.Clear();
             m_ValidationToken = Guid.NewGuid();
+            var validationToken = Encoding.UTF8.GetBytes(m_ValidationToken.ToString());
+            m_ServerNetworkManager.ConnectionApprovalCallback = NetworkManagerObject_ConnectionApprovalCallback;
+            m_ServerNetworkManager.NetworkConfig.PlayerPrefab = m_PlayerCreation == PlayerCreation.Prefab ? m_PlayerPrefab : null;
+            if (m_PlayerCreation == PlayerCreation.PrefabHash)
+            {
+                m_ServerNetworkManager.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Prefab = m_PlayerPrefab });
+            }
+            m_ServerNetworkManager.NetworkConfig.ConnectionApproval = true;
+            m_ServerNetworkManager.NetworkConfig.ConnectionData = validationToken;
+
+            foreach (var client in m_ClientNetworkManagers)
+            {
+                client.NetworkConfig.PlayerPrefab = m_PlayerCreation == PlayerCreation.Prefab ? m_PlayerPrefab : null;
+                if (m_PlayerCreation == PlayerCreation.PrefabHash)
+                {
+                    client.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Prefab = m_PlayerPrefab });
+                }
+                client.NetworkConfig.ConnectionApproval = true;
+                client.NetworkConfig.ConnectionData = m_PlayerCreation == PlayerCreation.FailValidation ? Encoding.UTF8.GetBytes(Guid.NewGuid().ToString()) : validationToken;
+                if (m_PlayerCreation == PlayerCreation.FailValidation)
+                {
+                    client.OnClientDisconnectCallback += Client_OnClientDisconnectCallback;
+                }
+            }
+
+            base.OnServerAndClientsCreated();
+        }
+
+        private void Client_OnClientDisconnectCallback(ulong clientId)
+        {
+            m_ClientNetworkManagers[0].OnClientDisconnectCallback -= Client_OnClientDisconnectCallback;
+            m_ClientDisconnectReasonValidated = m_ClientNetworkManagers[0].LocalClientId == clientId && m_ClientNetworkManagers[0].DisconnectReason == k_InvalidToken;
+        }
+
+        private bool ClientAndHostValidated()
+        {
+            if (!m_Validated.ContainsKey(m_ServerNetworkManager.LocalClientId) || !m_Validated[m_ServerNetworkManager.LocalClientId])
+            {
+                return false;
+            }
+            if (m_PlayerCreation == PlayerCreation.FailValidation)
+            {
+                return m_ClientDisconnectReasonValidated;
+            }
+            else
+            {
+                foreach (var client in m_ClientNetworkManagers)
+                {
+                    if (!m_Validated.ContainsKey(client.LocalClientId) || !m_Validated[client.LocalClientId])
+                    {
+                        return false;
+                    }
+                }
+            }
+            return true;
         }
 
         [UnityTest]
         public IEnumerator ConnectionApproval()
         {
-            NetworkManagerHelper.NetworkManagerObject.ConnectionApprovalCallback = NetworkManagerObject_ConnectionApprovalCallback;
-            NetworkManagerHelper.NetworkManagerObject.NetworkConfig.ConnectionApproval = true;
-            NetworkManagerHelper.NetworkManagerObject.NetworkConfig.PlayerPrefab = null;
-            NetworkManagerHelper.NetworkManagerObject.NetworkConfig.ConnectionData = Encoding.UTF8.GetBytes(m_ValidationToken.ToString());
-            m_IsValidated = false;
-            NetworkManagerHelper.NetworkManagerObject.StartHost();
-
-            var timeOut = Time.realtimeSinceStartup + 3.0f;
-            var timedOut = false;
-            while (!m_IsValidated)
-            {
-                yield return new WaitForSeconds(0.01f);
-                if (timeOut < Time.realtimeSinceStartup)
-                {
-                    timedOut = true;
-                }
-            }
-
-            //Make sure we didn't time out
-            Assert.False(timedOut);
-            Assert.True(m_IsValidated);
+            yield return WaitForConditionOrTimeOut(ClientAndHostValidated);
+            AssertOnTimeout("Timed out waiting for all clients to be approved!");
         }
 
         private void NetworkManagerObject_ConnectionApprovalCallback(NetworkManager.ConnectionApprovalRequest request, NetworkManager.ConnectionApprovalResponse response)
         {
             var stringGuid = Encoding.UTF8.GetString(request.Payload);
+
             if (m_ValidationToken.ToString() == stringGuid)
             {
-                m_IsValidated = true;
+                m_Validated.Add(request.ClientNetworkId, true);
+                response.Approved = true;
+            }
+            else
+            {
+                response.Approved = false;
+                response.Reason = "Invalid validation token!";
             }
 
-            response.Approved = m_IsValidated;
-            response.CreatePlayerObject = false;
+            response.CreatePlayerObject = ShouldCheckForSpawnedPlayers();
             response.Position = null;
             response.Rotation = null;
-            response.PlayerPrefabHash = null;
+            response.PlayerPrefabHash = m_PlayerCreation == PlayerCreation.PrefabHash ? m_PlayerPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash : null;
         }
 
 
@@ -78,13 +148,6 @@ namespace Unity.Netcode.RuntimeTests
 
             Assert.True(currentHash != newHash, $"Hashed {nameof(NetworkConfig)} values {currentHash} and {newHash} should not be the same!");
         }
-
-        [TearDown]
-        public void TearDown()
-        {
-            // Stop, shutdown, and destroy
-            NetworkManagerHelper.ShutdownNetworkManager();
-        }
-
     }
 }
+

Tests/Runtime/DistributedAuthority/DistributedAuthorityCodecTests.cs

@@ -38,11 +38,7 @@ namespace Unity.Netcode.RuntimeTests
         internal class TestNetworkComponent : NetworkBehaviour
         {
             public NetworkList<int> MyNetworkList = new NetworkList<int>(new List<int> { 1, 2, 3 });
-
-            [Rpc(SendTo.NotAuthority)]
-            public void TestNotAuthorityRpc(byte[] _)
-            {
-            }
+            public NetworkVariable<int> MyNetworkVar = new NetworkVariable<int>(3);
 
             [Rpc(SendTo.Authority)]
             public void TestAuthorityRpc(byte[] _)
@@ -87,7 +83,7 @@ namespace Unity.Netcode.RuntimeTests
             Client.LogLevel = LogLevel.Developer;
 
             // Validate we are in distributed authority mode with client side spawning and using CMB Service
-            Assert.True(Client.DistributedAuthorityMode, "Distributed authority is not set!");
+            Assert.True(Client.NetworkConfig.NetworkTopology == NetworkTopologyTypes.DistributedAuthority, "Distributed authority topology is not set!");
             Assert.True(Client.AutoSpawnPlayerPrefabClientSide, "Client side spawning is not set!");
             Assert.True(Client.CMBServiceConnection, "CMBServiceConnection is not set!");
 
@@ -101,6 +97,9 @@ namespace Unity.Netcode.RuntimeTests
 
         protected override IEnumerator OnStartedServerAndClients()
         {
+            // Validate the NetworkManager are in distributed authority mode
+            Assert.True(Client.DistributedAuthorityMode, "Distributed authority is not set!");
+
             // Register hooks after starting clients and server (in this case just the one client)
             // We do this at this point in time because the MessageManager exists (happens within the same call stack when starting NetworkManagers)
             m_ClientCodecHook = new CodecTestHooks();
@@ -219,12 +218,44 @@ namespace Unity.Netcode.RuntimeTests
         }
 
         [UnityTest]
-        public IEnumerator NotAuthorityRpc()
+        public IEnumerator NetworkVariableDelta_WithValueUpdate()
         {
-            Client.LocalClient.PlayerObject.GetComponent<TestNetworkComponent>().TestNotAuthorityRpc(new byte[] { 1, 2, 3, 4 });
+            var networkObj = CreateNetworkObjectPrefab("TestObject");
+            networkObj.AddComponent<TestNetworkComponent>();
+            var instance = SpawnObject(networkObj, Client);
+            yield return m_ClientCodecHook.WaitForMessageReceived<CreateObjectMessage>();
+            var component = instance.GetComponent<TestNetworkComponent>();
 
-            // Universal Rpcs are sent as a ProxyMessage (which contains an RpcMessage)
-            yield return m_ClientCodecHook.WaitForMessageReceived<ProxyMessage>();
+            var newValue = 5;
+            component.MyNetworkVar.Value = newValue;
+            yield return m_ClientCodecHook.WaitForMessageReceived<NetworkVariableDeltaMessage>();
+            Assert.AreEqual(newValue, component.MyNetworkVar.Value);
+        }
+
+        [UnityTest]
+        public IEnumerator NetworkListDelta_WithValueUpdate()
+        {
+            var networkObj = CreateNetworkObjectPrefab("TestObject");
+            networkObj.AddComponent<TestNetworkComponent>();
+            var instance = SpawnObject(networkObj, Client);
+            yield return m_ClientCodecHook.WaitForMessageReceived<CreateObjectMessage>();
+            var component = instance.GetComponent<TestNetworkComponent>();
+
+            component.MyNetworkList.Add(5);
+            yield return m_ClientCodecHook.WaitForMessageReceived<NetworkVariableDeltaMessage>();
+            component.MyNetworkList.Add(6);
+            component.MyNetworkList.Add(7);
+            yield return m_ClientCodecHook.WaitForMessageReceived<NetworkVariableDeltaMessage>();
+            component.MyNetworkList.Insert(1, 8);
+            yield return m_ClientCodecHook.WaitForMessageReceived<NetworkVariableDeltaMessage>();
+            component.MyNetworkList.Insert(8, 11);
+            yield return m_ClientCodecHook.WaitForMessageReceived<NetworkVariableDeltaMessage>();
+            component.MyNetworkList.Remove(6);
+            yield return m_ClientCodecHook.WaitForMessageReceived<NetworkVariableDeltaMessage>();
+            component.MyNetworkList.RemoveAt(2);
+            yield return m_ClientCodecHook.WaitForMessageReceived<NetworkVariableDeltaMessage>();
+            component.MyNetworkList.Clear();
+            yield return m_ClientCodecHook.WaitForMessageReceived<NetworkVariableDeltaMessage>();
         }
 
         [UnityTest]

Tests/Runtime/DistributedAuthority/ExtendedNetworkShowAndHideTests.cs

@@ -0,0 +1,154 @@
+using System.Collections;
+using NUnit.Framework;
+using Unity.Netcode.TestHelpers.Runtime;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    [TestFixture(HostOrServer.DAHost, true)]
+    [TestFixture(HostOrServer.DAHost, false)]
+    public class ExtendedNetworkShowAndHideTests : NetcodeIntegrationTest
+    {
+        protected override int NumberOfClients => 3;
+        private bool m_EnableSceneManagement;
+        private GameObject m_ObjectToSpawn;
+        private NetworkObject m_SpawnedObject;
+        private NetworkManager m_ClientToHideFrom;
+        private NetworkManager m_LateJoinClient;
+        private NetworkManager m_SpawnOwner;
+
+        public ExtendedNetworkShowAndHideTests(HostOrServer hostOrServer, bool enableSceneManagement) : base(hostOrServer)
+        {
+            m_EnableSceneManagement = enableSceneManagement;
+        }
+
+        protected override void OnServerAndClientsCreated()
+        {
+            if (!UseCMBService())
+            {
+                m_ServerNetworkManager.NetworkConfig.EnableSceneManagement = m_EnableSceneManagement;
+            }
+
+            foreach (var client in m_ClientNetworkManagers)
+            {
+                client.NetworkConfig.EnableSceneManagement = m_EnableSceneManagement;
+            }
+
+            m_ObjectToSpawn = CreateNetworkObjectPrefab("TestObject");
+            m_ObjectToSpawn.SetActive(false);
+
+            base.OnServerAndClientsCreated();
+        }
+
+        private bool AllClientsSpawnedObject()
+        {
+            if (!UseCMBService())
+            {
+                if (!s_GlobalNetworkObjects.ContainsKey(m_ServerNetworkManager.LocalClientId))
+                {
+                    return false;
+                }
+                if (!s_GlobalNetworkObjects[m_ServerNetworkManager.LocalClientId].ContainsKey(m_SpawnedObject.NetworkObjectId))
+                {
+                    return false;
+                }
+            }
+
+            foreach (var client in m_ClientNetworkManagers)
+            {
+                if (!s_GlobalNetworkObjects.ContainsKey(client.LocalClientId))
+                {
+                    return false;
+                }
+                if (!s_GlobalNetworkObjects[client.LocalClientId].ContainsKey(m_SpawnedObject.NetworkObjectId))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        private bool IsClientPromotedToSessionOwner()
+        {
+            if (!UseCMBService())
+            {
+                if (m_ServerNetworkManager.CurrentSessionOwner != m_ClientToHideFrom.LocalClientId)
+                {
+                    return false;
+                }
+            }
+
+            foreach (var client in m_ClientNetworkManagers)
+            {
+                if (!client.IsConnectedClient)
+                {
+                    continue;
+                }
+                if (client.CurrentSessionOwner != m_ClientToHideFrom.LocalClientId)
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        protected override void OnNewClientCreated(NetworkManager networkManager)
+        {
+            m_LateJoinClient = networkManager;
+            networkManager.NetworkConfig.EnableSceneManagement = m_EnableSceneManagement;
+            networkManager.NetworkConfig.Prefabs = m_SpawnOwner.NetworkConfig.Prefabs;
+            base.OnNewClientCreated(networkManager);
+        }
+
+        /// <summary>
+        /// This test validates the following NetworkShow - NetworkHide issue:
+        /// - During a session, a spawned object is hidden from a client.
+        /// - The current session owner disconnects and the client the object is hidden from is prommoted to the session owner.
+        /// - A new client joins and the newly promoted session owner synchronizes the newly joined client with only objects visible to it.
+        /// - Any already connected non-session owner client should "NetworkShow" the object to the newly connected client
+        /// (but only if the hidden object has SpawnWithObservers enabled)
+        /// </summary>
+        [UnityTest]
+        public IEnumerator HiddenObjectPromotedSessionOwnerNewClientSynchronizes()
+        {
+            // Get the test relative session owner
+            var sessionOwner = UseCMBService() ? m_ClientNetworkManagers[0] : m_ServerNetworkManager;
+            m_SpawnOwner = UseCMBService() ? m_ClientNetworkManagers[1] : m_ClientNetworkManagers[0];
+            m_ClientToHideFrom = UseCMBService() ? m_ClientNetworkManagers[NumberOfClients - 1] : m_ClientNetworkManagers[1];
+            m_ObjectToSpawn.SetActive(true);
+
+            // Spawn the object with a non-session owner client
+            m_SpawnedObject = SpawnObject(m_ObjectToSpawn, m_SpawnOwner).GetComponent<NetworkObject>();
+            yield return WaitForConditionOrTimeOut(AllClientsSpawnedObject);
+            AssertOnTimeout($"Not all clients spawned and instance of {m_SpawnedObject.name}");
+
+            // Hide the spawned object from the to be promoted session owner
+            m_SpawnedObject.NetworkHide(m_ClientToHideFrom.LocalClientId);
+
+            yield return WaitForConditionOrTimeOut(() => !m_ClientToHideFrom.SpawnManager.SpawnedObjects.ContainsKey(m_SpawnedObject.NetworkObjectId));
+            AssertOnTimeout($"{m_SpawnedObject.name} was not hidden from Client-{m_ClientToHideFrom.LocalClientId}!");
+
+            // Promoted a new session owner (DAHost promotes while CMB Session we disconnect the current session owner)
+            if (!UseCMBService())
+            {
+                m_ServerNetworkManager.PromoteSessionOwner(m_ClientToHideFrom.LocalClientId);
+            }
+            else
+            {
+                sessionOwner.Shutdown();
+            }
+
+            // Wait for the new session owner to be promoted and for all clients to acknowledge the promotion
+            yield return WaitForConditionOrTimeOut(IsClientPromotedToSessionOwner);
+            AssertOnTimeout($"Client-{m_ClientToHideFrom.LocalClientId} was not promoted as session owner on all client instances!");
+
+            // Connect a new client instance
+            yield return CreateAndStartNewClient();
+
+            // Assure the newly connected client is synchronized with the NetworkObject hidden from the newly promoted session owner
+            yield return WaitForConditionOrTimeOut(() => m_LateJoinClient.SpawnManager.SpawnedObjects.ContainsKey(m_SpawnedObject.NetworkObjectId));
+            AssertOnTimeout($"Client-{m_LateJoinClient.LocalClientId} never spawned {nameof(NetworkObject)} {m_SpawnedObject.name}!");
+        }
+    }
+}

Tests/Runtime/DistributedAuthority/ExtendedNetworkShowAndHideTests.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: a6389d04d9080b24b99de7e6900a064c

Tests/Runtime/DistributedAuthority/RpcProxyMessageTesting.cs

@@ -0,0 +1,97 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using NUnit.Framework;
+using Unity.Netcode.TestHelpers.Runtime;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    /// <summary>
+    /// This test validates PR-3000 where it would invoke
+    /// TODO:
+    /// We really need to get the service running during tests
+    /// so we can validate these issues. While this test does
+    /// partially validate it we still need to manually validate
+    /// with a service connection.
+    /// </summary>
+    [TestFixture(HostOrServer.Host)]
+    [TestFixture(HostOrServer.DAHost)]
+    public class RpcProxyMessageTesting : NetcodeIntegrationTest
+    {
+        protected override int NumberOfClients => 2;
+
+        private List<RpcProxyText> m_ProxyTestInstances = new List<RpcProxyText>();
+
+        private StringBuilder m_ValidationLogger = new StringBuilder();
+
+        public RpcProxyMessageTesting(HostOrServer hostOrServer) : base(hostOrServer) { }
+
+        protected override IEnumerator OnSetup()
+        {
+            m_ProxyTestInstances.Clear();
+            return base.OnSetup();
+        }
+
+        protected override void OnCreatePlayerPrefab()
+        {
+            m_PlayerPrefab.AddComponent<RpcProxyText>();
+            base.OnCreatePlayerPrefab();
+        }
+
+
+        private bool ValidateRpcProxyRpcs()
+        {
+            m_ValidationLogger.Clear();
+            foreach (var proxy in m_ProxyTestInstances)
+            {
+                if (proxy.ReceivedRpc.Count < NumberOfClients)
+                {
+                    m_ValidationLogger.AppendLine($"Not all clients received RPC from Client-{proxy.OwnerClientId}!");
+                }
+                foreach (var clientId in proxy.ReceivedRpc)
+                {
+                    if (clientId == proxy.OwnerClientId)
+                    {
+                        m_ValidationLogger.AppendLine($"Client-{proxy.OwnerClientId} sent itself an Rpc!");
+                    }
+                }
+            }
+            return m_ValidationLogger.Length == 0;
+        }
+
+
+        public IEnumerator ProxyDoesNotInvokeOnSender()
+        {
+            m_ProxyTestInstances.Add(m_ServerNetworkManager.LocalClient.PlayerObject.GetComponent<RpcProxyText>());
+            foreach (var client in m_ClientNetworkManagers)
+            {
+                m_ProxyTestInstances.Add(client.LocalClient.PlayerObject.GetComponent<RpcProxyText>());
+            }
+
+            foreach (var clientProxyTest in m_ProxyTestInstances)
+            {
+                clientProxyTest.SendToEveryOneButMe();
+            }
+
+            yield return WaitForConditionOrTimeOut(ValidateRpcProxyRpcs);
+            AssertOnTimeout(m_ValidationLogger.ToString());
+        }
+
+        public class RpcProxyText : NetworkBehaviour
+        {
+            public List<ulong> ReceivedRpc = new List<ulong>();
+
+            public void SendToEveryOneButMe()
+            {
+                var baseTarget = NetworkManager.DistributedAuthorityMode ? RpcTarget.NotAuthority : RpcTarget.NotMe;
+                TestRpc(baseTarget);
+            }
+
+            [Rpc(SendTo.SpecifiedInParams)]
+            private void TestRpc(RpcParams rpcParams = default)
+            {
+                ReceivedRpc.Add(rpcParams.Receive.SenderClientId);
+            }
+        }
+    }
+}

Tests/Runtime/DistributedAuthority/RpcProxyMessageTesting.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 22d1d751fe245f7419f8393090c27106

Tests/Runtime/Messaging/NamedMessageTests.cs

@@ -239,5 +239,45 @@ namespace Unity.Netcode.RuntimeTests
                     });
             }
         }
+
+        [Test]
+        public unsafe void ErrorMessageIsPrintedWhenAttemptingToSendNamedMessageWithTooBigBuffer()
+        {
+            // First try a valid send with the maximum allowed size (this is atm 1264)
+            var msgSize = m_ServerNetworkManager.MessageManager.NonFragmentedMessageMaxSize - FastBufferWriter.GetWriteSize<NetworkMessageHeader>() - sizeof(ulong)/*MessageName hash*/ - sizeof(NetworkBatchHeader);
+            var bufferSize = m_ServerNetworkManager.MessageManager.NonFragmentedMessageMaxSize;
+            var messageName = Guid.NewGuid().ToString();
+            var messageContent = new byte[msgSize];
+            var writer = new FastBufferWriter(bufferSize, Allocator.Temp, bufferSize * 2);
+            using (writer)
+            {
+                writer.TryBeginWrite(msgSize);
+                writer.WriteBytes(messageContent, msgSize, 0);
+                m_ServerNetworkManager.CustomMessagingManager.SendNamedMessage(messageName, new List<ulong> { FirstClient.LocalClientId }, writer);
+                m_ServerNetworkManager.CustomMessagingManager.SendNamedMessage(messageName, FirstClient.LocalClientId, writer);
+            }
+
+            msgSize++;
+            messageContent = new byte[msgSize];
+            writer = new FastBufferWriter(bufferSize, Allocator.Temp, bufferSize * 2);
+            using (writer)
+            {
+                writer.TryBeginWrite(msgSize);
+                writer.WriteBytes(messageContent, msgSize, 0);
+                var message = Assert.Throws<OverflowException>(
+                    () =>
+                    {
+                        m_ServerNetworkManager.CustomMessagingManager.SendNamedMessage(messageName, new List<ulong> { FirstClient.LocalClientId }, writer);
+                    }).Message;
+                Assert.IsTrue(message.Contains($"Given message size ({msgSize} bytes) is greater than the maximum"), $"Unexpected exception: {message}");
+
+                message = Assert.Throws<OverflowException>(
+                    () =>
+                    {
+                        m_ServerNetworkManager.CustomMessagingManager.SendNamedMessage(messageName, FirstClient.LocalClientId, writer);
+                    }).Message;
+                Assert.IsTrue(message.Contains($"Given message size ({msgSize} bytes) is greater than the maximum"), $"Unexpected exception: {message}");
+            }
+        }
     }
 }

Tests/Runtime/Messaging/UnnamedMessageTests.cs

@@ -194,5 +194,44 @@ namespace Unity.Netcode.RuntimeTests
                     });
             }
         }
+
+        [Test]
+        public unsafe void ErrorMessageIsPrintedWhenAttemptingToSendUnnamedMessageWithTooBigBuffer()
+        {
+            // First try a valid send with the maximum allowed size (this is atm 1272)
+            var msgSize = m_ServerNetworkManager.MessageManager.NonFragmentedMessageMaxSize - FastBufferWriter.GetWriteSize<NetworkMessageHeader>() - sizeof(NetworkBatchHeader);
+            var bufferSize = m_ServerNetworkManager.MessageManager.NonFragmentedMessageMaxSize;
+            var messageContent = new byte[msgSize];
+            var writer = new FastBufferWriter(bufferSize, Allocator.Temp, bufferSize * 2);
+            using (writer)
+            {
+                writer.TryBeginWrite(msgSize);
+                writer.WriteBytes(messageContent, msgSize, 0);
+                m_ServerNetworkManager.CustomMessagingManager.SendUnnamedMessage(new List<ulong> { FirstClient.LocalClientId }, writer);
+                m_ServerNetworkManager.CustomMessagingManager.SendUnnamedMessage(FirstClient.LocalClientId, writer);
+            }
+
+            msgSize++;
+            messageContent = new byte[msgSize];
+            writer = new FastBufferWriter(bufferSize, Allocator.Temp, bufferSize * 2);
+            using (writer)
+            {
+                writer.TryBeginWrite(msgSize);
+                writer.WriteBytes(messageContent, msgSize, 0);
+                var message = Assert.Throws<OverflowException>(
+                    () =>
+                    {
+                        m_ServerNetworkManager.CustomMessagingManager.SendUnnamedMessage(new List<ulong> { FirstClient.LocalClientId }, writer);
+                    }).Message;
+                Assert.IsTrue(message.Contains($"Given message size ({msgSize} bytes) is greater than the maximum"), $"Unexpected exception: {message}");
+
+                message = Assert.Throws<OverflowException>(
+                    () =>
+                    {
+                        m_ServerNetworkManager.CustomMessagingManager.SendUnnamedMessage(FirstClient.LocalClientId, writer);
+                    }).Message;
+                Assert.IsTrue(message.Contains($"Given message size ({msgSize} bytes) is greater than the maximum"), $"Unexpected exception: {message}");
+            }
+        }
     }
 }

Tests/Runtime/NetworkTransform/NetworkTransformBase.cs

@@ -200,9 +200,8 @@ namespace Unity.Netcode.RuntimeTests
         /// </summary>
         /// <param name="testWithHost">Determines if we are running as a server or host</param>
         /// <param name="authority">Determines if we are using server or owner authority</param>
-        public NetworkTransformBase(HostOrServer testWithHost, Authority authority, RotationCompression rotationCompression, Rotation rotation, Precision precision)
+        public NetworkTransformBase(HostOrServer testWithHost, Authority authority, RotationCompression rotationCompression, Rotation rotation, Precision precision) : base(testWithHost)
         {
-            m_UseHost = testWithHost == HostOrServer.Host;
             m_Authority = authority;
             m_Precision = precision;
             m_RotationCompression = rotationCompression;
@@ -376,6 +375,18 @@ namespace Unity.Netcode.RuntimeTests
             return true;
         }
 
+        protected bool AllFirstLevelChildObjectInstancesHaveChild()
+        {
+            foreach (var instance in ChildObjectComponent.ClientInstances.Values)
+            {
+                if (instance.transform.parent == null)
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
         protected bool AllChildObjectInstancesHaveChild()
         {
             foreach (var instance in ChildObjectComponent.ClientInstances.Values)
@@ -398,6 +409,33 @@ namespace Unity.Netcode.RuntimeTests
             return true;
         }
 
+        protected bool AllFirstLevelChildObjectInstancesHaveNoParent()
+        {
+            foreach (var instance in ChildObjectComponent.ClientInstances.Values)
+            {
+                if (instance.transform.parent != null)
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        protected bool AllSubChildObjectInstancesHaveNoParent()
+        {
+            if (ChildObjectComponent.HasSubChild)
+            {
+                foreach (var instance in ChildObjectComponent.ClientSubChildInstances.Values)
+                {
+                    if (instance.transform.parent != null)
+                    {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+
         /// <summary>
         /// A wait condition specific method that assures the local space coordinates
         /// are not impacted by NetworkTransform when parented.

Tests/Runtime/NetworkTransform/NetworkTransformTests.cs

@@ -101,6 +101,225 @@ namespace Unity.Netcode.RuntimeTests
         }
 
 #if !MULTIPLAYER_TOOLS
+
+        private void UpdateTransformLocal(Components.NetworkTransform networkTransformTestComponent)
+        {
+            networkTransformTestComponent.transform.localPosition += GetRandomVector3(0.5f, 2.0f);
+            var rotation = networkTransformTestComponent.transform.localRotation;
+            var eulerRotation = rotation.eulerAngles;
+            eulerRotation += GetRandomVector3(0.5f, 5.0f);
+            rotation.eulerAngles = eulerRotation;
+            networkTransformTestComponent.transform.localRotation = rotation;
+        }
+
+        private void UpdateTransformWorld(Components.NetworkTransform networkTransformTestComponent)
+        {
+            networkTransformTestComponent.transform.position += GetRandomVector3(0.5f, 2.0f);
+            var rotation = networkTransformTestComponent.transform.rotation;
+            var eulerRotation = rotation.eulerAngles;
+            eulerRotation += GetRandomVector3(0.5f, 5.0f);
+            rotation.eulerAngles = eulerRotation;
+            networkTransformTestComponent.transform.rotation = rotation;
+        }
+
+        /// <summary>
+        /// This test validates the SwitchTransformSpaceWhenParented setting under all network topologies        
+        /// </summary>
+        [Test]
+        public void SwitchTransformSpaceWhenParentedTest([Values(0.5f, 1.0f, 5.0f)] float scale)
+        {
+            m_UseParentingThreshold = true;
+            // Get the NetworkManager that will have authority in order to spawn with the correct authority
+            var isServerAuthority = m_Authority == Authority.ServerAuthority;
+            var authorityNetworkManager = m_ServerNetworkManager;
+            if (!isServerAuthority)
+            {
+                authorityNetworkManager = m_ClientNetworkManagers[0];
+            }
+
+            var childAuthorityNetworkManager = m_ClientNetworkManagers[0];
+            if (!isServerAuthority)
+            {
+                childAuthorityNetworkManager = m_ServerNetworkManager;
+            }
+
+            // Spawn a parent and children
+            ChildObjectComponent.HasSubChild = true;
+            // Modify our prefabs for this specific test
+            m_ParentObject.GetComponent<NetworkTransformTestComponent>().TickSyncChildren = true;
+            m_ChildObject.GetComponent<ChildObjectComponent>().SwitchTransformSpaceWhenParented = true;
+            m_ChildObject.GetComponent<ChildObjectComponent>().TickSyncChildren = true;
+            m_SubChildObject.GetComponent<ChildObjectComponent>().SwitchTransformSpaceWhenParented = true;
+            m_SubChildObject.GetComponent<ChildObjectComponent>().TickSyncChildren = true;
+            m_ChildObject.AllowOwnerToParent = true;
+            m_SubChildObject.AllowOwnerToParent = true;
+
+
+            var authoritySideParent = SpawnObject(m_ParentObject.gameObject, authorityNetworkManager).GetComponent<NetworkObject>();
+            var authoritySideChild = SpawnObject(m_ChildObject.gameObject, childAuthorityNetworkManager).GetComponent<NetworkObject>();
+            var authoritySideSubChild = SpawnObject(m_SubChildObject.gameObject, childAuthorityNetworkManager).GetComponent<NetworkObject>();
+
+            // Assure all of the child object instances are spawned before proceeding to parenting
+            var success = WaitForConditionOrTimeOutWithTimeTravel(AllChildObjectInstancesAreSpawned);
+            Assert.True(success, "Timed out waiting for all child instances to be spawned!");
+
+            // Get the owner instance if in client-server mode with owner authority
+            if (m_Authority == Authority.OwnerAuthority && !m_DistributedAuthority)
+            {
+                authoritySideParent = s_GlobalNetworkObjects[authoritySideParent.OwnerClientId][authoritySideParent.NetworkObjectId];
+                authoritySideChild = s_GlobalNetworkObjects[authoritySideChild.OwnerClientId][authoritySideChild.NetworkObjectId];
+                authoritySideSubChild = s_GlobalNetworkObjects[authoritySideSubChild.OwnerClientId][authoritySideSubChild.NetworkObjectId];
+            }
+
+            // Get the authority parent and child instances
+            m_AuthorityParentObject = NetworkTransformTestComponent.AuthorityInstance.NetworkObject;
+            m_AuthorityChildObject = ChildObjectComponent.AuthorityInstance.NetworkObject;
+            m_AuthoritySubChildObject = ChildObjectComponent.AuthoritySubInstance.NetworkObject;
+
+            // The child NetworkTransform will use world space when world position stays and
+            // local space when world position does not stay when parenting.
+            ChildObjectComponent.AuthorityInstance.UseHalfFloatPrecision = m_Precision == Precision.Half;
+            ChildObjectComponent.AuthorityInstance.UseQuaternionSynchronization = m_Rotation == Rotation.Quaternion;
+            ChildObjectComponent.AuthorityInstance.UseQuaternionCompression = m_RotationCompression == RotationCompression.QuaternionCompress;
+
+            ChildObjectComponent.AuthoritySubInstance.UseHalfFloatPrecision = m_Precision == Precision.Half;
+            ChildObjectComponent.AuthoritySubInstance.UseQuaternionSynchronization = m_Rotation == Rotation.Quaternion;
+            ChildObjectComponent.AuthoritySubInstance.UseQuaternionCompression = m_RotationCompression == RotationCompression.QuaternionCompress;
+
+            // Set whether we are interpolating or not
+            m_AuthorityParentNetworkTransform = m_AuthorityParentObject.GetComponent<NetworkTransformTestComponent>();
+            m_AuthorityParentNetworkTransform.Interpolate = true;
+            m_AuthorityChildNetworkTransform = m_AuthorityChildObject.GetComponent<ChildObjectComponent>();
+            m_AuthorityChildNetworkTransform.Interpolate = true;
+            m_AuthoritySubChildNetworkTransform = m_AuthoritySubChildObject.GetComponent<ChildObjectComponent>();
+            m_AuthoritySubChildNetworkTransform.Interpolate = true;
+
+            // Apply a scale to the parent object to make sure the scale on the child is properly updated on
+            // non-authority instances.
+            var halfScale = scale * 0.5f;
+            m_AuthorityParentObject.transform.localScale = GetRandomVector3(scale - halfScale, scale + halfScale);
+            m_AuthorityChildObject.transform.localScale = GetRandomVector3(scale - halfScale, scale + halfScale);
+            m_AuthoritySubChildObject.transform.localScale = GetRandomVector3(scale - halfScale, scale + halfScale);
+
+            // Allow one tick for authority to update these changes
+            TimeTravelAdvanceTick();
+            success = WaitForConditionOrTimeOutWithTimeTravel(PositionRotationScaleMatches);
+
+            Assert.True(success, "All transform values did not match prior to parenting!");
+
+            success = WaitForConditionOrTimeOutWithTimeTravel(PositionRotationScaleMatches);
+
+            Assert.True(success, "All transform values did not match prior to parenting!");
+
+            // Move things around while parenting and removing the parent
+            // Not the absolute "perfect" test, but it validates the clients all synchronize
+            // parenting and transform values.
+            for (int i = 0; i < 30; i++)
+            {
+                // Provide two network ticks for interpolation to finalize
+                TimeTravelAdvanceTick();
+                TimeTravelAdvanceTick();
+
+                // This validates each child instance has preserved their local space values
+                AllChildrenLocalTransformValuesMatch(false, ChildrenTransformCheckType.Connected_Clients);
+
+                // This validates each sub-child instance has preserved their local space values
+                AllChildrenLocalTransformValuesMatch(true, ChildrenTransformCheckType.Connected_Clients);
+                // Parent while in motion
+                if (i == 5)
+                {
+                    // Parent the child under the parent with the current world position stays setting
+                    Assert.True(authoritySideChild.TrySetParent(authoritySideParent.transform), $"[Child][Client-{authoritySideChild.NetworkManagerOwner.LocalClientId}] Failed to set child's parent!");
+
+                    // This waits for all child instances to be parented
+                    success = WaitForConditionOrTimeOutWithTimeTravel(AllFirstLevelChildObjectInstancesHaveChild, 300);
+                    Assert.True(success, "Timed out waiting for all instances to have parented a child!");
+                }
+
+                if (i == 10)
+                {
+                    // Parent the sub-child under the child with the current world position stays setting
+                    Assert.True(authoritySideSubChild.TrySetParent(authoritySideChild.transform), $"[Sub-Child][Client-{authoritySideSubChild.NetworkManagerOwner.LocalClientId}] Failed to set sub-child's parent!");
+
+                    // This waits for all child instances to be parented
+                    success = WaitForConditionOrTimeOutWithTimeTravel(AllChildObjectInstancesHaveChild, 300);
+                    Assert.True(success, "Timed out waiting for all instances to have parented a child!");
+                }
+
+                if (i == 15)
+                {
+                    // Verify that a late joining client will synchronize to the parented NetworkObjects properly
+                    CreateAndStartNewClientWithTimeTravel();
+
+                    // Assure all of the child object instances are spawned (basically for the newly connected client)
+                    success = WaitForConditionOrTimeOutWithTimeTravel(AllChildObjectInstancesAreSpawned, 300);
+                    Assert.True(success, "Timed out waiting for all child instances to be spawned!");
+
+                    // This waits for all child instances to be parented
+                    success = WaitForConditionOrTimeOutWithTimeTravel(AllChildObjectInstancesHaveChild, 300);
+                    Assert.True(success, "Timed out waiting for all instances to have parented a child!");
+
+                    // This validates each child instance has preserved their local space values
+                    AllChildrenLocalTransformValuesMatch(false, ChildrenTransformCheckType.Late_Join_Client);
+
+                    // This validates each sub-child instance has preserved their local space values
+                    AllChildrenLocalTransformValuesMatch(true, ChildrenTransformCheckType.Late_Join_Client);
+                }
+
+                if (i == 20)
+                {
+                    // Remove the parent
+                    Assert.True(authoritySideSubChild.TryRemoveParent(), $"[Sub-Child][Client-{authoritySideSubChild.NetworkManagerOwner.LocalClientId}] Failed to set sub-child's parent!");
+
+                    // This waits for all child instances to have the parent removed
+                    success = WaitForConditionOrTimeOutWithTimeTravel(AllSubChildObjectInstancesHaveNoParent, 300);
+                    Assert.True(success, "Timed out waiting for all instances remove the parent!");
+                }
+
+                if (i == 25)
+                {
+                    // Parent the child under the parent with the current world position stays setting
+                    Assert.True(authoritySideChild.TryRemoveParent(), $"[Child][Client-{authoritySideChild.NetworkManagerOwner.LocalClientId}] Failed to remove parent!");
+
+                    // This waits for all child instances to be parented
+                    success = WaitForConditionOrTimeOutWithTimeTravel(AllFirstLevelChildObjectInstancesHaveNoParent, 300);
+                    Assert.True(success, "Timed out waiting for all instances remove the parent!");
+                }
+                UpdateTransformWorld(m_AuthorityParentNetworkTransform);
+                if (m_AuthorityChildNetworkTransform.InLocalSpace)
+                {
+                    UpdateTransformLocal(m_AuthorityChildNetworkTransform);
+                }
+                else
+                {
+                    UpdateTransformWorld(m_AuthorityChildNetworkTransform);
+                }
+
+                if (m_AuthoritySubChildNetworkTransform.InLocalSpace)
+                {
+                    UpdateTransformLocal(m_AuthoritySubChildNetworkTransform);
+                }
+                else
+                {
+                    UpdateTransformWorld(m_AuthoritySubChildNetworkTransform);
+                }
+            }
+
+            success = WaitForConditionOrTimeOutWithTimeTravel(PositionRotationScaleMatches, 300);
+
+            Assert.True(success, "All transform values did not match prior to parenting!");
+
+            // Revert the modifications made for this specific test
+            m_ParentObject.GetComponent<NetworkTransformTestComponent>().TickSyncChildren = false;
+            m_ChildObject.GetComponent<ChildObjectComponent>().SwitchTransformSpaceWhenParented = false;
+            m_ChildObject.GetComponent<ChildObjectComponent>().TickSyncChildren = false;
+            m_ChildObject.AllowOwnerToParent = false;
+            m_SubChildObject.AllowOwnerToParent = false;
+            m_SubChildObject.GetComponent<ChildObjectComponent>().SwitchTransformSpaceWhenParented = false;
+            m_SubChildObject.GetComponent<ChildObjectComponent>().TickSyncChildren = false;
+        }
+
+
         /// <summary>
         /// Validates that transform values remain the same when a NetworkTransform is
         /// parented under another NetworkTransform under all of the possible axial conditions
@@ -410,6 +629,7 @@ namespace Unity.Netcode.RuntimeTests
             Assert.AreEqual(Vector3.zero, m_NonAuthoritativeTransform.transform.position, "server side pos should be zero at first"); // sanity check
 
             TimeTravelAdvanceTick();
+            TimeTravelToNextTick();
 
             m_AuthoritativeTransform.StatePushed = false;
             var nextPosition = GetRandomVector3(2f, 30f);

Tests/Runtime/NetworkTransformAnticipationTests.cs

@@ -299,16 +299,15 @@ namespace Unity.Netcode.RuntimeTests
             }, new List<NetworkManager> { m_ServerNetworkManager });
 
             WaitForMessageReceivedWithTimeTravel<NetworkTransformMessage>(m_ClientNetworkManagers.ToList());
-
             var percentChanged = 1f / 60f;
 
             AssertVectorsAreEquivalent(Vector3.Lerp(anticipePosition, serverSetPosition, percentChanged), testComponent.transform.position);
             AssertVectorsAreEquivalent(Vector3.Lerp(anticipeScale, serverSetScale, percentChanged), testComponent.transform.localScale);
-            AssertQuaternionsAreEquivalent(Quaternion.Slerp(anticipeRotation, serverSetRotation, percentChanged), testComponent.transform.rotation);
+            AssertQuaternionsAreEquivalent(Quaternion.Lerp(anticipeRotation, serverSetRotation, percentChanged), testComponent.transform.rotation);
 
             AssertVectorsAreEquivalent(Vector3.Lerp(anticipePosition, serverSetPosition, percentChanged), testComponent.AnticipatedState.Position);
             AssertVectorsAreEquivalent(Vector3.Lerp(anticipeScale, serverSetScale, percentChanged), testComponent.AnticipatedState.Scale);
-            AssertQuaternionsAreEquivalent(Quaternion.Slerp(anticipeRotation, serverSetRotation, percentChanged), testComponent.AnticipatedState.Rotation);
+            AssertQuaternionsAreEquivalent(Quaternion.Lerp(anticipeRotation, serverSetRotation, percentChanged), testComponent.AnticipatedState.Rotation);
 
             AssertVectorsAreEquivalent(serverSetPosition, testComponent.AuthoritativeState.Position);
             AssertVectorsAreEquivalent(serverSetScale, testComponent.AuthoritativeState.Scale);
@@ -316,11 +315,11 @@ namespace Unity.Netcode.RuntimeTests
 
             AssertVectorsAreEquivalent(Vector3.Lerp(startPosition, serverSetPosition, percentChanged), otherClientComponent.transform.position);
             AssertVectorsAreEquivalent(Vector3.Lerp(startScale, serverSetScale, percentChanged), otherClientComponent.transform.localScale);
-            AssertQuaternionsAreEquivalent(Quaternion.Slerp(startRotation, serverSetRotation, percentChanged), otherClientComponent.transform.rotation);
+            AssertQuaternionsAreEquivalent(Quaternion.Lerp(startRotation, serverSetRotation, percentChanged), otherClientComponent.transform.rotation);
 
             AssertVectorsAreEquivalent(Vector3.Lerp(startPosition, serverSetPosition, percentChanged), otherClientComponent.AnticipatedState.Position);
             AssertVectorsAreEquivalent(Vector3.Lerp(startScale, serverSetScale, percentChanged), otherClientComponent.AnticipatedState.Scale);
-            AssertQuaternionsAreEquivalent(Quaternion.Slerp(startRotation, serverSetRotation, percentChanged), otherClientComponent.AnticipatedState.Rotation);
+            AssertQuaternionsAreEquivalent(Quaternion.Lerp(startRotation, serverSetRotation, percentChanged), otherClientComponent.AnticipatedState.Rotation);
 
             AssertVectorsAreEquivalent(serverSetPosition, otherClientComponent.AuthoritativeState.Position);
             AssertVectorsAreEquivalent(serverSetScale, otherClientComponent.AuthoritativeState.Scale);
@@ -333,11 +332,11 @@ namespace Unity.Netcode.RuntimeTests
 
                 AssertVectorsAreEquivalent(Vector3.Lerp(anticipePosition, serverSetPosition, percentChanged), testComponent.transform.position);
                 AssertVectorsAreEquivalent(Vector3.Lerp(anticipeScale, serverSetScale, percentChanged), testComponent.transform.localScale);
-                AssertQuaternionsAreEquivalent(Quaternion.Slerp(anticipeRotation, serverSetRotation, percentChanged), testComponent.transform.rotation);
+                AssertQuaternionsAreEquivalent(Quaternion.Lerp(anticipeRotation, serverSetRotation, percentChanged), testComponent.transform.rotation);
 
                 AssertVectorsAreEquivalent(Vector3.Lerp(anticipePosition, serverSetPosition, percentChanged), testComponent.AnticipatedState.Position);
                 AssertVectorsAreEquivalent(Vector3.Lerp(anticipeScale, serverSetScale, percentChanged), testComponent.AnticipatedState.Scale);
-                AssertQuaternionsAreEquivalent(Quaternion.Slerp(anticipeRotation, serverSetRotation, percentChanged), testComponent.AnticipatedState.Rotation);
+                AssertQuaternionsAreEquivalent(Quaternion.Lerp(anticipeRotation, serverSetRotation, percentChanged), testComponent.AnticipatedState.Rotation);
 
                 AssertVectorsAreEquivalent(serverSetPosition, testComponent.AuthoritativeState.Position);
                 AssertVectorsAreEquivalent(serverSetScale, testComponent.AuthoritativeState.Scale);
@@ -345,11 +344,11 @@ namespace Unity.Netcode.RuntimeTests
 
                 AssertVectorsAreEquivalent(Vector3.Lerp(startPosition, serverSetPosition, percentChanged), otherClientComponent.transform.position);
                 AssertVectorsAreEquivalent(Vector3.Lerp(startScale, serverSetScale, percentChanged), otherClientComponent.transform.localScale);
-                AssertQuaternionsAreEquivalent(Quaternion.Slerp(startRotation, serverSetRotation, percentChanged), otherClientComponent.transform.rotation);
+                AssertQuaternionsAreEquivalent(Quaternion.Lerp(startRotation, serverSetRotation, percentChanged), otherClientComponent.transform.rotation);
 
                 AssertVectorsAreEquivalent(Vector3.Lerp(startPosition, serverSetPosition, percentChanged), otherClientComponent.AnticipatedState.Position);
                 AssertVectorsAreEquivalent(Vector3.Lerp(startScale, serverSetScale, percentChanged), otherClientComponent.AnticipatedState.Scale);
-                AssertQuaternionsAreEquivalent(Quaternion.Slerp(startRotation, serverSetRotation, percentChanged), otherClientComponent.AnticipatedState.Rotation);
+                AssertQuaternionsAreEquivalent(Quaternion.Lerp(startRotation, serverSetRotation, percentChanged), otherClientComponent.AnticipatedState.Rotation);
 
                 AssertVectorsAreEquivalent(serverSetPosition, otherClientComponent.AuthoritativeState.Position);
                 AssertVectorsAreEquivalent(serverSetScale, otherClientComponent.AuthoritativeState.Scale);

Tests/Runtime/NetworkVariable.meta

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

Tests/Runtime/NetworkVariable/NetworkVariableCollectionsTests.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7d01969a8bbbd7146a24490a5190ea7e

Tests/Runtime/NetworkVariable/NetworkVariableInheritanceTests.cs

@@ -0,0 +1,165 @@
+#if !NGO_MINIMALPROJECT
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using Unity.Netcode.TestHelpers.Runtime;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    [TestFixtureSource(nameof(TestDataSource))]
+    internal class NetworkVariableInheritanceTests : NetcodeIntegrationTest
+    {
+        public NetworkVariableInheritanceTests(HostOrServer hostOrServer)
+            : base(hostOrServer)
+        {
+        }
+
+        protected override int NumberOfClients => 2;
+
+        public static IEnumerable<TestFixtureData> TestDataSource() =>
+            Enum.GetValues(typeof(HostOrServer)).OfType<HostOrServer>().Select(x => new TestFixtureData(x));
+
+        internal class ComponentA : NetworkBehaviour
+        {
+            public NetworkVariable<int> PublicFieldA = new NetworkVariable<int>(1);
+            protected NetworkVariable<int> m_ProtectedFieldA = new NetworkVariable<int>(2);
+            private NetworkVariable<int> m_PrivateFieldA = new NetworkVariable<int>(3);
+
+            public void ChangeValuesA(int pub, int pro, int pri)
+            {
+                PublicFieldA.Value = pub;
+                m_ProtectedFieldA.Value = pro;
+                m_PrivateFieldA.Value = pri;
+            }
+
+            public bool CompareValuesA(ComponentA other)
+            {
+                return PublicFieldA.Value == other.PublicFieldA.Value &&
+                    m_ProtectedFieldA.Value == other.m_ProtectedFieldA.Value &&
+                    m_PrivateFieldA.Value == other.m_PrivateFieldA.Value;
+            }
+        }
+
+        internal class ComponentB : ComponentA
+        {
+            public NetworkVariable<int> PublicFieldB = new NetworkVariable<int>(11);
+            protected NetworkVariable<int> m_ProtectedFieldB = new NetworkVariable<int>(22);
+            private NetworkVariable<int> m_PrivateFieldB = new NetworkVariable<int>(33);
+
+            public void ChangeValuesB(int pub, int pro, int pri)
+            {
+                PublicFieldB.Value = pub;
+                m_ProtectedFieldB.Value = pro;
+                m_PrivateFieldB.Value = pri;
+            }
+
+            public bool CompareValuesB(ComponentB other)
+            {
+                return PublicFieldB.Value == other.PublicFieldB.Value &&
+                    m_ProtectedFieldB.Value == other.m_ProtectedFieldB.Value &&
+                    m_PrivateFieldB.Value == other.m_PrivateFieldB.Value;
+            }
+        }
+
+        internal class ComponentC : ComponentB
+        {
+            public NetworkVariable<int> PublicFieldC = new NetworkVariable<int>(111);
+            protected NetworkVariable<int> m_ProtectedFieldC = new NetworkVariable<int>(222);
+            private NetworkVariable<int> m_PrivateFieldC = new NetworkVariable<int>(333);
+
+            public void ChangeValuesC(int pub, int pro, int pri)
+            {
+                PublicFieldC.Value = pub;
+                m_ProtectedFieldA.Value = pro;
+                m_PrivateFieldC.Value = pri;
+            }
+
+            public bool CompareValuesC(ComponentC other)
+            {
+                return PublicFieldC.Value == other.PublicFieldC.Value &&
+                    m_ProtectedFieldC.Value == other.m_ProtectedFieldC.Value &&
+                    m_PrivateFieldC.Value == other.m_PrivateFieldC.Value;
+            }
+        }
+
+        private GameObject m_TestObjectPrefab;
+        private ulong m_TestObjectId = 0;
+
+        protected override void OnOneTimeSetup()
+        {
+            NetworkVariableBase.IgnoreInitializeWarning = true;
+            base.OnOneTimeSetup();
+        }
+
+        protected override void OnOneTimeTearDown()
+        {
+            NetworkVariableBase.IgnoreInitializeWarning = false;
+            base.OnOneTimeTearDown();
+        }
+
+        protected override void OnServerAndClientsCreated()
+        {
+            m_TestObjectPrefab = CreateNetworkObjectPrefab($"[{nameof(NetworkVariableInheritanceTests)}.{nameof(m_TestObjectPrefab)}]");
+            m_TestObjectPrefab.AddComponent<ComponentA>();
+            m_TestObjectPrefab.AddComponent<ComponentB>();
+            m_TestObjectPrefab.AddComponent<ComponentC>();
+        }
+
+        protected override IEnumerator OnServerAndClientsConnected()
+        {
+            var serverTestObject = SpawnObject(m_TestObjectPrefab, m_ServerNetworkManager).GetComponent<NetworkObject>();
+            m_TestObjectId = serverTestObject.NetworkObjectId;
+
+            var serverTestComponentA = serverTestObject.GetComponent<ComponentA>();
+            var serverTestComponentB = serverTestObject.GetComponent<ComponentB>();
+            var serverTestComponentC = serverTestObject.GetComponent<ComponentC>();
+
+            serverTestComponentA.ChangeValuesA(1000, 2000, 3000);
+            serverTestComponentB.ChangeValuesA(1000, 2000, 3000);
+            serverTestComponentB.ChangeValuesB(1100, 2200, 3300);
+            serverTestComponentC.ChangeValuesA(1000, 2000, 3000);
+            serverTestComponentC.ChangeValuesB(1100, 2200, 3300);
+            serverTestComponentC.ChangeValuesC(1110, 2220, 3330);
+
+            yield return WaitForTicks(m_ServerNetworkManager, 2);
+        }
+
+        private bool CheckTestObjectComponentValuesOnAll()
+        {
+            var serverTestObject = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjectId];
+            var serverTestComponentA = serverTestObject.GetComponent<ComponentA>();
+            var serverTestComponentB = serverTestObject.GetComponent<ComponentB>();
+            var serverTestComponentC = serverTestObject.GetComponent<ComponentC>();
+            foreach (var clientNetworkManager in m_ClientNetworkManagers)
+            {
+                var clientTestObject = clientNetworkManager.SpawnManager.SpawnedObjects[m_TestObjectId];
+                var clientTestComponentA = clientTestObject.GetComponent<ComponentA>();
+                var clientTestComponentB = clientTestObject.GetComponent<ComponentB>();
+                var clientTestComponentC = clientTestObject.GetComponent<ComponentC>();
+                if (!serverTestComponentA.CompareValuesA(clientTestComponentA) ||
+                    !serverTestComponentB.CompareValuesA(clientTestComponentB) ||
+                    !serverTestComponentB.CompareValuesB(clientTestComponentB) ||
+                    !serverTestComponentC.CompareValuesA(clientTestComponentC) ||
+                    !serverTestComponentC.CompareValuesB(clientTestComponentC) ||
+                    !serverTestComponentC.CompareValuesC(clientTestComponentC))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        [UnityTest]
+        public IEnumerator TestInheritedFields()
+        {
+            yield return WaitForConditionOrTimeOut(CheckTestObjectComponentValuesOnAll);
+            Assert.IsFalse(s_GlobalTimeoutHelper.TimedOut, nameof(CheckTestObjectComponentValuesOnAll));
+        }
+    }
+}
+#endif

Tests/Runtime/NetworkVariable/NetworkVariableInheritanceTests.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 41d4aef8f33a8eb4e87879075f868e66

Tests/Runtime/NetworkVariable/NetworkVariablePermissionTests.cs

@@ -0,0 +1,306 @@
+#if !NGO_MINIMALPROJECT
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using NUnit.Framework;
+using Unity.Netcode.TestHelpers.Runtime;
+using UnityEngine;
+using UnityEngine.TestTools;
+using Random = UnityEngine.Random;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    [TestFixtureSource(nameof(TestDataSource))]
+    internal class NetworkVariablePermissionTests : NetcodeIntegrationTest
+    {
+        public static IEnumerable<TestFixtureData> TestDataSource()
+        {
+            NetworkVariableBase.IgnoreInitializeWarning = true;
+            foreach (HostOrServer hostOrServer in Enum.GetValues(typeof(HostOrServer)))
+            {
+                // DANGO-EXP TODO: Add support for distributed authority mode
+                if (hostOrServer == HostOrServer.DAHost)
+                {
+                    continue;
+                }
+                yield return new TestFixtureData(hostOrServer);
+            }
+
+            NetworkVariableBase.IgnoreInitializeWarning = false;
+        }
+
+        protected override int NumberOfClients => 3;
+
+        public NetworkVariablePermissionTests(HostOrServer hostOrServer) : base(hostOrServer) { }
+
+        private GameObject m_TestObjPrefab;
+        private ulong m_TestObjId = 0;
+
+        protected override void OnServerAndClientsCreated()
+        {
+            m_TestObjPrefab = CreateNetworkObjectPrefab($"[{nameof(NetworkVariablePermissionTests)}.{nameof(m_TestObjPrefab)}]");
+            var testComp = m_TestObjPrefab.AddComponent<NetVarPermTestComp>();
+        }
+
+        protected override IEnumerator OnServerAndClientsConnected()
+        {
+            m_TestObjId = SpawnObject(m_TestObjPrefab, m_ServerNetworkManager).GetComponent<NetworkObject>().NetworkObjectId;
+            yield return null;
+        }
+
+        private IEnumerator WaitForPositionsAreEqual(NetworkVariable<Vector3> netvar, Vector3 expected)
+        {
+            yield return WaitForConditionOrTimeOut(() => netvar.Value == expected);
+            Assert.IsFalse(s_GlobalTimeoutHelper.TimedOut);
+        }
+
+        private IEnumerator WaitForOwnerWritableAreEqualOnAll()
+        {
+            yield return WaitForConditionOrTimeOut(CheckOwnerWritableAreEqualOnAll);
+            Assert.IsFalse(s_GlobalTimeoutHelper.TimedOut);
+        }
+
+        private bool CheckOwnerWritableAreEqualOnAll()
+        {
+            var testObjServer = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
+            var testCompServer = testObjServer.GetComponent<NetVarPermTestComp>();
+            foreach (var clientNetworkManager in m_ClientNetworkManagers)
+            {
+                var testObjClient = clientNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
+                var testCompClient = testObjClient.GetComponent<NetVarPermTestComp>();
+                if (testObjServer.OwnerClientId != testObjClient.OwnerClientId ||
+                    testCompServer.OwnerWritable_Position.Value != testCompClient.OwnerWritable_Position.Value ||
+                    testCompServer.OwnerWritable_Position.ReadPerm != testCompClient.OwnerWritable_Position.ReadPerm ||
+                    testCompServer.OwnerWritable_Position.WritePerm != testCompClient.OwnerWritable_Position.WritePerm)
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        private IEnumerator WaitForServerWritableAreEqualOnAll()
+        {
+            yield return WaitForConditionOrTimeOut(CheckServerWritableAreEqualOnAll);
+            Assert.IsFalse(s_GlobalTimeoutHelper.TimedOut);
+        }
+
+        private bool CheckServerWritableAreEqualOnAll()
+        {
+            var testObjServer = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
+            var testCompServer = testObjServer.GetComponent<NetVarPermTestComp>();
+            foreach (var clientNetworkManager in m_ClientNetworkManagers)
+            {
+                var testObjClient = clientNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
+                var testCompClient = testObjClient.GetComponent<NetVarPermTestComp>();
+                if (testCompServer.ServerWritable_Position.Value != testCompClient.ServerWritable_Position.Value ||
+                    testCompServer.ServerWritable_Position.ReadPerm != testCompClient.ServerWritable_Position.ReadPerm ||
+                    testCompServer.ServerWritable_Position.WritePerm != testCompClient.ServerWritable_Position.WritePerm)
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        private bool CheckOwnerReadWriteAreEqualOnOwnerAndServer()
+        {
+            var testObjServer = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
+            var testCompServer = testObjServer.GetComponent<NetVarPermTestComp>();
+            foreach (var clientNetworkManager in m_ClientNetworkManagers)
+            {
+                var testObjClient = clientNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
+                var testCompClient = testObjClient.GetComponent<NetVarPermTestComp>();
+                if (testObjServer.OwnerClientId == testObjClient.OwnerClientId &&
+                    testCompServer.OwnerReadWrite_Position.Value == testCompClient.ServerWritable_Position.Value &&
+                    testCompServer.OwnerReadWrite_Position.ReadPerm == testCompClient.ServerWritable_Position.ReadPerm &&
+                    testCompServer.OwnerReadWrite_Position.WritePerm == testCompClient.ServerWritable_Position.WritePerm)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        private bool CheckOwnerReadWriteAreNotEqualOnNonOwnerClients(NetVarPermTestComp ownerReadWriteObject)
+        {
+            foreach (var clientNetworkManager in m_ClientNetworkManagers)
+            {
+                var testObjClient = clientNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
+                var testCompClient = testObjClient.GetComponent<NetVarPermTestComp>();
+                if (testObjClient.OwnerClientId != ownerReadWriteObject.OwnerClientId ||
+                    ownerReadWriteObject.OwnerReadWrite_Position.Value == testCompClient.ServerWritable_Position.Value ||
+                    ownerReadWriteObject.OwnerReadWrite_Position.ReadPerm != testCompClient.ServerWritable_Position.ReadPerm ||
+                    ownerReadWriteObject.OwnerReadWrite_Position.WritePerm != testCompClient.ServerWritable_Position.WritePerm)
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        [UnityTest]
+        public IEnumerator ServerChangesOwnerWritableNetVar()
+        {
+            yield return WaitForOwnerWritableAreEqualOnAll();
+
+            var testObjServer = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
+            var testCompServer = testObjServer.GetComponent<NetVarPermTestComp>();
+
+            var oldValue = testCompServer.OwnerWritable_Position.Value;
+            var newValue = oldValue + new Vector3(Random.Range(0, 100.0f), Random.Range(0, 100.0f), Random.Range(0, 100.0f));
+
+            testCompServer.OwnerWritable_Position.Value = newValue;
+            yield return WaitForPositionsAreEqual(testCompServer.OwnerWritable_Position, newValue);
+
+            yield return WaitForOwnerWritableAreEqualOnAll();
+        }
+
+        [UnityTest]
+        public IEnumerator ServerChangesServerWritableNetVar()
+        {
+            yield return WaitForServerWritableAreEqualOnAll();
+
+            var testObjServer = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
+            var testCompServer = testObjServer.GetComponent<NetVarPermTestComp>();
+
+            var oldValue = testCompServer.ServerWritable_Position.Value;
+            var newValue = oldValue + new Vector3(Random.Range(0, 100.0f), Random.Range(0, 100.0f), Random.Range(0, 100.0f));
+
+            testCompServer.ServerWritable_Position.Value = newValue;
+            yield return WaitForPositionsAreEqual(testCompServer.ServerWritable_Position, newValue);
+
+            yield return WaitForServerWritableAreEqualOnAll();
+        }
+
+        [UnityTest]
+        public IEnumerator ClientChangesOwnerWritableNetVar()
+        {
+            yield return WaitForOwnerWritableAreEqualOnAll();
+
+            var testObjServer = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
+
+            int clientManagerIndex = m_ClientNetworkManagers.Length - 1;
+            var newOwnerClientId = m_ClientNetworkManagers[clientManagerIndex].LocalClientId;
+            testObjServer.ChangeOwnership(newOwnerClientId);
+            yield return WaitForTicks(m_ServerNetworkManager, 2);
+
+            yield return WaitForOwnerWritableAreEqualOnAll();
+
+            var testObjClient = m_ClientNetworkManagers[clientManagerIndex].SpawnManager.SpawnedObjects[m_TestObjId];
+            var testCompClient = testObjClient.GetComponent<NetVarPermTestComp>();
+
+            var oldValue = testCompClient.OwnerWritable_Position.Value;
+            var newValue = oldValue + new Vector3(Random.Range(0, 100.0f), Random.Range(0, 100.0f), Random.Range(0, 100.0f));
+
+            testCompClient.OwnerWritable_Position.Value = newValue;
+            yield return WaitForPositionsAreEqual(testCompClient.OwnerWritable_Position, newValue);
+
+            yield return WaitForOwnerWritableAreEqualOnAll();
+        }
+
+        /// <summary>
+        /// This tests the scenario where a client owner has both read and write
+        /// permissions set. The server should be the only instance that can read
+        /// the NetworkVariable.  ServerCannotChangeOwnerWritableNetVar performs
+        /// the same check to make sure the server cannot write to a client owner
+        /// NetworkVariable with owner write permissions.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator ClientOwnerWithReadWriteChangesNetVar()
+        {
+            yield return WaitForOwnerWritableAreEqualOnAll();
+
+            var testObjServer = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
+
+            int clientManagerIndex = m_ClientNetworkManagers.Length - 1;
+            var newOwnerClientId = m_ClientNetworkManagers[clientManagerIndex].LocalClientId;
+            testObjServer.ChangeOwnership(newOwnerClientId);
+            yield return WaitForTicks(m_ServerNetworkManager, 2);
+
+            yield return WaitForOwnerWritableAreEqualOnAll();
+
+            var testObjClient = m_ClientNetworkManagers[clientManagerIndex].SpawnManager.SpawnedObjects[m_TestObjId];
+            var testCompClient = testObjClient.GetComponent<NetVarPermTestComp>();
+
+            var oldValue = testCompClient.OwnerReadWrite_Position.Value;
+            var newValue = oldValue + new Vector3(Random.Range(0, 100.0f), Random.Range(0, 100.0f), Random.Range(0, 100.0f));
+
+            testCompClient.OwnerWritable_Position.Value = newValue;
+            yield return WaitForPositionsAreEqual(testCompClient.OwnerWritable_Position, newValue);
+
+            // Verify the client owner and server match
+            yield return CheckOwnerReadWriteAreEqualOnOwnerAndServer();
+
+            // Verify the non-owner clients do not have the same Value but do have the same permissions
+            yield return CheckOwnerReadWriteAreNotEqualOnNonOwnerClients(testCompClient);
+        }
+
+
+        [UnityTest]
+        public IEnumerator ClientCannotChangeServerWritableNetVar()
+        {
+            yield return WaitForServerWritableAreEqualOnAll();
+
+            var testObjServer = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
+            var testCompServer = testObjServer.GetComponent<NetVarPermTestComp>();
+
+            int clientManagerIndex = m_ClientNetworkManagers.Length - 1;
+            var newOwnerClientId = m_ClientNetworkManagers[clientManagerIndex].LocalClientId;
+            testObjServer.ChangeOwnership(newOwnerClientId);
+            yield return WaitForTicks(m_ServerNetworkManager, 2);
+
+            yield return WaitForServerWritableAreEqualOnAll();
+
+            var testObjClient = m_ClientNetworkManagers[clientManagerIndex].SpawnManager.SpawnedObjects[m_TestObjId];
+            var testCompClient = testObjClient.GetComponent<NetVarPermTestComp>();
+
+            var oldValue = testCompClient.ServerWritable_Position.Value;
+            var newValue = oldValue + new Vector3(Random.Range(0, 100.0f), Random.Range(0, 100.0f), Random.Range(0, 100.0f));
+            LogAssert.Expect(LogType.Error, testCompClient.ServerWritable_Position.GetWritePermissionError());
+            testCompClient.ServerWritable_Position.Value = newValue;
+            yield return WaitForPositionsAreEqual(testCompServer.ServerWritable_Position, oldValue);
+
+            yield return WaitForServerWritableAreEqualOnAll();
+
+            testCompServer.ServerWritable_Position.Value = newValue;
+            yield return WaitForPositionsAreEqual(testCompServer.ServerWritable_Position, newValue);
+
+            yield return WaitForServerWritableAreEqualOnAll();
+        }
+
+        [UnityTest]
+        public IEnumerator ServerCannotChangeOwnerWritableNetVar()
+        {
+            yield return WaitForOwnerWritableAreEqualOnAll();
+
+            var testObjServer = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
+            var testCompServer = testObjServer.GetComponent<NetVarPermTestComp>();
+
+            int clientManagerIndex = m_ClientNetworkManagers.Length - 1;
+            var newOwnerClientId = m_ClientNetworkManagers[clientManagerIndex].LocalClientId;
+            testObjServer.ChangeOwnership(newOwnerClientId);
+            yield return WaitForTicks(m_ServerNetworkManager, 4);
+
+            yield return WaitForOwnerWritableAreEqualOnAll();
+
+            var oldValue = testCompServer.OwnerWritable_Position.Value;
+            var newValue = oldValue + new Vector3(Random.Range(0, 100.0f), Random.Range(0, 100.0f), Random.Range(0, 100.0f));
+
+            LogAssert.Expect(LogType.Error, testCompServer.OwnerWritable_Position.GetWritePermissionError());
+            testCompServer.OwnerWritable_Position.Value = newValue;
+            yield return WaitForPositionsAreEqual(testCompServer.OwnerWritable_Position, oldValue);
+
+            yield return WaitForOwnerWritableAreEqualOnAll();
+
+            var testObjClient = m_ClientNetworkManagers[clientManagerIndex].SpawnManager.SpawnedObjects[m_TestObjId];
+            var testCompClient = testObjClient.GetComponent<NetVarPermTestComp>();
+
+            testCompClient.OwnerWritable_Position.Value = newValue;
+            yield return WaitForPositionsAreEqual(testCompClient.OwnerWritable_Position, newValue);
+
+            yield return WaitForOwnerWritableAreEqualOnAll();
+        }
+    }
+}
+#endif

Tests/Runtime/NetworkVariable/NetworkVariablePermissionTests.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 60d49d322bef8ff4ebb8c4abf57e18e3

Tests/Runtime/NetworkVariable/NetworkVariableTests.cs

@@ -12,298 +12,6 @@ using Random = UnityEngine.Random;
 
 namespace Unity.Netcode.RuntimeTests
 {
-    [TestFixtureSource(nameof(TestDataSource))]
-    internal class NetworkVariablePermissionTests : NetcodeIntegrationTest
-    {
-        public static IEnumerable<TestFixtureData> TestDataSource()
-        {
-            NetworkVariableBase.IgnoreInitializeWarning = true;
-            foreach (HostOrServer hostOrServer in Enum.GetValues(typeof(HostOrServer)))
-            {
-                // DANGO-EXP TODO: Add support for distributed authority mode
-                if (hostOrServer == HostOrServer.DAHost)
-                {
-                    continue;
-                }
-                yield return new TestFixtureData(hostOrServer);
-            }
-
-            NetworkVariableBase.IgnoreInitializeWarning = false;
-        }
-
-        protected override int NumberOfClients => 3;
-
-        public NetworkVariablePermissionTests(HostOrServer hostOrServer) : base(hostOrServer) { }
-
-        private GameObject m_TestObjPrefab;
-        private ulong m_TestObjId = 0;
-
-        protected override void OnServerAndClientsCreated()
-        {
-            m_TestObjPrefab = CreateNetworkObjectPrefab($"[{nameof(NetworkVariablePermissionTests)}.{nameof(m_TestObjPrefab)}]");
-            var testComp = m_TestObjPrefab.AddComponent<NetVarPermTestComp>();
-        }
-
-        protected override IEnumerator OnServerAndClientsConnected()
-        {
-            m_TestObjId = SpawnObject(m_TestObjPrefab, m_ServerNetworkManager).GetComponent<NetworkObject>().NetworkObjectId;
-            yield return null;
-        }
-
-        private IEnumerator WaitForPositionsAreEqual(NetworkVariable<Vector3> netvar, Vector3 expected)
-        {
-            yield return WaitForConditionOrTimeOut(() => netvar.Value == expected);
-            Assert.IsFalse(s_GlobalTimeoutHelper.TimedOut);
-        }
-
-        private IEnumerator WaitForOwnerWritableAreEqualOnAll()
-        {
-            yield return WaitForConditionOrTimeOut(CheckOwnerWritableAreEqualOnAll);
-            Assert.IsFalse(s_GlobalTimeoutHelper.TimedOut);
-        }
-
-        private bool CheckOwnerWritableAreEqualOnAll()
-        {
-            var testObjServer = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
-            var testCompServer = testObjServer.GetComponent<NetVarPermTestComp>();
-            foreach (var clientNetworkManager in m_ClientNetworkManagers)
-            {
-                var testObjClient = clientNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
-                var testCompClient = testObjClient.GetComponent<NetVarPermTestComp>();
-                if (testObjServer.OwnerClientId != testObjClient.OwnerClientId ||
-                    testCompServer.OwnerWritable_Position.Value != testCompClient.OwnerWritable_Position.Value ||
-                    testCompServer.OwnerWritable_Position.ReadPerm != testCompClient.OwnerWritable_Position.ReadPerm ||
-                    testCompServer.OwnerWritable_Position.WritePerm != testCompClient.OwnerWritable_Position.WritePerm)
-                {
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        private IEnumerator WaitForServerWritableAreEqualOnAll()
-        {
-            yield return WaitForConditionOrTimeOut(CheckServerWritableAreEqualOnAll);
-            Assert.IsFalse(s_GlobalTimeoutHelper.TimedOut);
-        }
-
-        private bool CheckServerWritableAreEqualOnAll()
-        {
-            var testObjServer = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
-            var testCompServer = testObjServer.GetComponent<NetVarPermTestComp>();
-            foreach (var clientNetworkManager in m_ClientNetworkManagers)
-            {
-                var testObjClient = clientNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
-                var testCompClient = testObjClient.GetComponent<NetVarPermTestComp>();
-                if (testCompServer.ServerWritable_Position.Value != testCompClient.ServerWritable_Position.Value ||
-                    testCompServer.ServerWritable_Position.ReadPerm != testCompClient.ServerWritable_Position.ReadPerm ||
-                    testCompServer.ServerWritable_Position.WritePerm != testCompClient.ServerWritable_Position.WritePerm)
-                {
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        private bool CheckOwnerReadWriteAreEqualOnOwnerAndServer()
-        {
-            var testObjServer = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
-            var testCompServer = testObjServer.GetComponent<NetVarPermTestComp>();
-            foreach (var clientNetworkManager in m_ClientNetworkManagers)
-            {
-                var testObjClient = clientNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
-                var testCompClient = testObjClient.GetComponent<NetVarPermTestComp>();
-                if (testObjServer.OwnerClientId == testObjClient.OwnerClientId &&
-                    testCompServer.OwnerReadWrite_Position.Value == testCompClient.ServerWritable_Position.Value &&
-                    testCompServer.OwnerReadWrite_Position.ReadPerm == testCompClient.ServerWritable_Position.ReadPerm &&
-                    testCompServer.OwnerReadWrite_Position.WritePerm == testCompClient.ServerWritable_Position.WritePerm)
-                {
-                    return true;
-                }
-            }
-            return false;
-        }
-
-        private bool CheckOwnerReadWriteAreNotEqualOnNonOwnerClients(NetVarPermTestComp ownerReadWriteObject)
-        {
-            foreach (var clientNetworkManager in m_ClientNetworkManagers)
-            {
-                var testObjClient = clientNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
-                var testCompClient = testObjClient.GetComponent<NetVarPermTestComp>();
-                if (testObjClient.OwnerClientId != ownerReadWriteObject.OwnerClientId ||
-                    ownerReadWriteObject.OwnerReadWrite_Position.Value == testCompClient.ServerWritable_Position.Value ||
-                    ownerReadWriteObject.OwnerReadWrite_Position.ReadPerm != testCompClient.ServerWritable_Position.ReadPerm ||
-                    ownerReadWriteObject.OwnerReadWrite_Position.WritePerm != testCompClient.ServerWritable_Position.WritePerm)
-                {
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        [UnityTest]
-        public IEnumerator ServerChangesOwnerWritableNetVar()
-        {
-            yield return WaitForOwnerWritableAreEqualOnAll();
-
-            var testObjServer = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
-            var testCompServer = testObjServer.GetComponent<NetVarPermTestComp>();
-
-            var oldValue = testCompServer.OwnerWritable_Position.Value;
-            var newValue = oldValue + new Vector3(Random.Range(0, 100.0f), Random.Range(0, 100.0f), Random.Range(0, 100.0f));
-
-            testCompServer.OwnerWritable_Position.Value = newValue;
-            yield return WaitForPositionsAreEqual(testCompServer.OwnerWritable_Position, newValue);
-
-            yield return WaitForOwnerWritableAreEqualOnAll();
-        }
-
-        [UnityTest]
-        public IEnumerator ServerChangesServerWritableNetVar()
-        {
-            yield return WaitForServerWritableAreEqualOnAll();
-
-            var testObjServer = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
-            var testCompServer = testObjServer.GetComponent<NetVarPermTestComp>();
-
-            var oldValue = testCompServer.ServerWritable_Position.Value;
-            var newValue = oldValue + new Vector3(Random.Range(0, 100.0f), Random.Range(0, 100.0f), Random.Range(0, 100.0f));
-
-            testCompServer.ServerWritable_Position.Value = newValue;
-            yield return WaitForPositionsAreEqual(testCompServer.ServerWritable_Position, newValue);
-
-            yield return WaitForServerWritableAreEqualOnAll();
-        }
-
-        [UnityTest]
-        public IEnumerator ClientChangesOwnerWritableNetVar()
-        {
-            yield return WaitForOwnerWritableAreEqualOnAll();
-
-            var testObjServer = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
-
-            int clientManagerIndex = m_ClientNetworkManagers.Length - 1;
-            var newOwnerClientId = m_ClientNetworkManagers[clientManagerIndex].LocalClientId;
-            testObjServer.ChangeOwnership(newOwnerClientId);
-            yield return WaitForTicks(m_ServerNetworkManager, 2);
-
-            yield return WaitForOwnerWritableAreEqualOnAll();
-
-            var testObjClient = m_ClientNetworkManagers[clientManagerIndex].SpawnManager.SpawnedObjects[m_TestObjId];
-            var testCompClient = testObjClient.GetComponent<NetVarPermTestComp>();
-
-            var oldValue = testCompClient.OwnerWritable_Position.Value;
-            var newValue = oldValue + new Vector3(Random.Range(0, 100.0f), Random.Range(0, 100.0f), Random.Range(0, 100.0f));
-
-            testCompClient.OwnerWritable_Position.Value = newValue;
-            yield return WaitForPositionsAreEqual(testCompClient.OwnerWritable_Position, newValue);
-
-            yield return WaitForOwnerWritableAreEqualOnAll();
-        }
-
-        /// <summary>
-        /// This tests the scenario where a client owner has both read and write
-        /// permissions set. The server should be the only instance that can read
-        /// the NetworkVariable.  ServerCannotChangeOwnerWritableNetVar performs
-        /// the same check to make sure the server cannot write to a client owner
-        /// NetworkVariable with owner write permissions.
-        /// </summary>
-        [UnityTest]
-        public IEnumerator ClientOwnerWithReadWriteChangesNetVar()
-        {
-            yield return WaitForOwnerWritableAreEqualOnAll();
-
-            var testObjServer = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
-
-            int clientManagerIndex = m_ClientNetworkManagers.Length - 1;
-            var newOwnerClientId = m_ClientNetworkManagers[clientManagerIndex].LocalClientId;
-            testObjServer.ChangeOwnership(newOwnerClientId);
-            yield return WaitForTicks(m_ServerNetworkManager, 2);
-
-            yield return WaitForOwnerWritableAreEqualOnAll();
-
-            var testObjClient = m_ClientNetworkManagers[clientManagerIndex].SpawnManager.SpawnedObjects[m_TestObjId];
-            var testCompClient = testObjClient.GetComponent<NetVarPermTestComp>();
-
-            var oldValue = testCompClient.OwnerReadWrite_Position.Value;
-            var newValue = oldValue + new Vector3(Random.Range(0, 100.0f), Random.Range(0, 100.0f), Random.Range(0, 100.0f));
-
-            testCompClient.OwnerWritable_Position.Value = newValue;
-            yield return WaitForPositionsAreEqual(testCompClient.OwnerWritable_Position, newValue);
-
-            // Verify the client owner and server match
-            yield return CheckOwnerReadWriteAreEqualOnOwnerAndServer();
-
-            // Verify the non-owner clients do not have the same Value but do have the same permissions
-            yield return CheckOwnerReadWriteAreNotEqualOnNonOwnerClients(testCompClient);
-        }
-
-
-        [UnityTest]
-        public IEnumerator ClientCannotChangeServerWritableNetVar()
-        {
-            yield return WaitForServerWritableAreEqualOnAll();
-
-            var testObjServer = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
-            var testCompServer = testObjServer.GetComponent<NetVarPermTestComp>();
-
-            int clientManagerIndex = m_ClientNetworkManagers.Length - 1;
-            var newOwnerClientId = m_ClientNetworkManagers[clientManagerIndex].LocalClientId;
-            testObjServer.ChangeOwnership(newOwnerClientId);
-            yield return WaitForTicks(m_ServerNetworkManager, 2);
-
-            yield return WaitForServerWritableAreEqualOnAll();
-
-            var testObjClient = m_ClientNetworkManagers[clientManagerIndex].SpawnManager.SpawnedObjects[m_TestObjId];
-            var testCompClient = testObjClient.GetComponent<NetVarPermTestComp>();
-
-            var oldValue = testCompClient.ServerWritable_Position.Value;
-            var newValue = oldValue + new Vector3(Random.Range(0, 100.0f), Random.Range(0, 100.0f), Random.Range(0, 100.0f));
-
-            Assert.That(() => testCompClient.ServerWritable_Position.Value = newValue, Throws.TypeOf<InvalidOperationException>());
-            yield return WaitForPositionsAreEqual(testCompServer.ServerWritable_Position, oldValue);
-
-            yield return WaitForServerWritableAreEqualOnAll();
-
-            testCompServer.ServerWritable_Position.Value = newValue;
-            yield return WaitForPositionsAreEqual(testCompServer.ServerWritable_Position, newValue);
-
-            yield return WaitForServerWritableAreEqualOnAll();
-        }
-
-        [UnityTest]
-        public IEnumerator ServerCannotChangeOwnerWritableNetVar()
-        {
-            yield return WaitForOwnerWritableAreEqualOnAll();
-
-            var testObjServer = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjId];
-            var testCompServer = testObjServer.GetComponent<NetVarPermTestComp>();
-
-            int clientManagerIndex = m_ClientNetworkManagers.Length - 1;
-            var newOwnerClientId = m_ClientNetworkManagers[clientManagerIndex].LocalClientId;
-            testObjServer.ChangeOwnership(newOwnerClientId);
-            yield return WaitForTicks(m_ServerNetworkManager, 2);
-
-            yield return WaitForOwnerWritableAreEqualOnAll();
-
-            var oldValue = testCompServer.OwnerWritable_Position.Value;
-            var newValue = oldValue + new Vector3(Random.Range(0, 100.0f), Random.Range(0, 100.0f), Random.Range(0, 100.0f));
-
-            Assert.That(() => testCompServer.OwnerWritable_Position.Value = newValue, Throws.TypeOf<InvalidOperationException>());
-            yield return WaitForPositionsAreEqual(testCompServer.OwnerWritable_Position, oldValue);
-
-            yield return WaitForOwnerWritableAreEqualOnAll();
-
-            var testObjClient = m_ClientNetworkManagers[clientManagerIndex].SpawnManager.SpawnedObjects[m_TestObjId];
-            var testCompClient = testObjClient.GetComponent<NetVarPermTestComp>();
-
-            testCompClient.OwnerWritable_Position.Value = newValue;
-            yield return WaitForPositionsAreEqual(testCompClient.OwnerWritable_Position, newValue);
-
-            yield return WaitForOwnerWritableAreEqualOnAll();
-        }
-    }
-
     internal struct TestStruct : INetworkSerializable, IEquatable<TestStruct>
     {
         public uint SomeInt;
@@ -438,6 +146,255 @@ namespace Unity.Netcode.RuntimeTests
         }
     }
 
+    /// <summary>
+    /// Handles the more generic conditional logic for NetworkList tests
+    /// which can be used with the <see cref="NetcodeIntegrationTest.WaitForConditionOrTimeOut"/>
+    /// that accepts anything derived from the <see cref="ConditionalPredicateBase"/> class
+    /// as a parameter.
+    /// </summary>
+    internal class NetworkListTestPredicate : ConditionalPredicateBase
+    {
+        private const int k_MaxRandomValue = 1000;
+
+        private Dictionary<NetworkListTestStates, Func<bool>> m_StateFunctions;
+
+        // Player1 component on the Server
+        private NetworkVariableTest m_Player1OnServer;
+
+        // Player1 component on client1
+        private NetworkVariableTest m_Player1OnClient1;
+
+        private string m_TestStageFailedMessage;
+
+        public enum NetworkListTestStates
+        {
+            Add,
+            ContainsLarge,
+            Contains,
+            VerifyData,
+            IndexOf,
+        }
+
+        private NetworkListTestStates m_NetworkListTestState;
+
+        public void SetNetworkListTestState(NetworkListTestStates networkListTestState)
+        {
+            m_NetworkListTestState = networkListTestState;
+        }
+
+        /// <summary>
+        /// Determines if the condition has been reached for the current NetworkListTestState
+        /// </summary>
+        protected override bool OnHasConditionBeenReached()
+        {
+            var isStateRegistered = m_StateFunctions.ContainsKey(m_NetworkListTestState);
+            Assert.IsTrue(isStateRegistered);
+            return m_StateFunctions[m_NetworkListTestState].Invoke();
+        }
+
+        /// <summary>
+        /// Provides all information about the players for both sides for simplicity and informative sake.
+        /// </summary>
+        /// <returns></returns>
+        private string ConditionFailedInfo()
+        {
+            return $"{m_NetworkListTestState} condition test failed:\n Server List Count: {m_Player1OnServer.TheList.Count} vs  Client List Count: {m_Player1OnClient1.TheList.Count}\n" +
+                $"Server List Count: {m_Player1OnServer.TheLargeList.Count} vs  Client List Count: {m_Player1OnClient1.TheLargeList.Count}\n" +
+                $"Server Delegate Triggered: {m_Player1OnServer.ListDelegateTriggered} | Client Delegate Triggered: {m_Player1OnClient1.ListDelegateTriggered}\n";
+        }
+
+        /// <summary>
+        /// When finished, check if a time out occurred and if so assert and provide meaningful information to troubleshoot why
+        /// </summary>
+        protected override void OnFinished()
+        {
+            Assert.IsFalse(TimedOut, $"{nameof(NetworkListTestPredicate)} timed out waiting for the {m_NetworkListTestState} condition to be reached! \n" + ConditionFailedInfo());
+        }
+
+        // Uses the ArrayOperator and validates that on both sides the count and values are the same
+        private bool OnVerifyData()
+        {
+            // Wait until both sides have the same number of elements
+            if (m_Player1OnServer.TheList.Count != m_Player1OnClient1.TheList.Count)
+            {
+                return false;
+            }
+
+            // Check the client values against the server values to make sure they match
+            for (int i = 0; i < m_Player1OnServer.TheList.Count; i++)
+            {
+                if (m_Player1OnServer.TheList[i] != m_Player1OnClient1.TheList[i])
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Verifies the data count, values, and that the ListDelegate on both sides was triggered
+        /// </summary>
+        private bool OnAdd()
+        {
+            bool wasTriggerred = m_Player1OnServer.ListDelegateTriggered && m_Player1OnClient1.ListDelegateTriggered;
+            return wasTriggerred && OnVerifyData();
+        }
+
+        /// <summary>
+        /// The current version of this test only verified the count of the large list, so that is what this does
+        /// </summary>
+        private bool OnContainsLarge()
+        {
+            return m_Player1OnServer.TheLargeList.Count == m_Player1OnClient1.TheLargeList.Count;
+        }
+
+        /// <summary>
+        /// Tests NetworkList.Contains which also verifies all values are the same on both sides
+        /// </summary>
+        private bool OnContains()
+        {
+            // Wait until both sides have the same number of elements
+            if (m_Player1OnServer.TheList.Count != m_Player1OnClient1.TheList.Count)
+            {
+                return false;
+            }
+
+            // Parse through all server values and use the NetworkList.Contains method to check if the value is in the list on the client side
+            foreach (var serverValue in m_Player1OnServer.TheList)
+            {
+                if (!m_Player1OnClient1.TheList.Contains(serverValue))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Tests NetworkList.IndexOf and verifies that all values are aligned on both sides
+        /// </summary>
+        private bool OnIndexOf()
+        {
+            foreach (var serverSideValue in m_Player1OnServer.TheList)
+            {
+                var indexToTest = m_Player1OnServer.TheList.IndexOf(serverSideValue);
+                if (indexToTest != m_Player1OnServer.TheList.IndexOf(serverSideValue))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        public NetworkListTestPredicate(NetworkVariableTest player1OnServer, NetworkVariableTest player1OnClient1, NetworkListTestStates networkListTestState, int elementCount)
+        {
+            m_NetworkListTestState = networkListTestState;
+            m_Player1OnServer = player1OnServer;
+            m_Player1OnClient1 = player1OnClient1;
+            m_StateFunctions = new Dictionary<NetworkListTestStates, Func<bool>>
+            {
+                { NetworkListTestStates.Add, OnAdd },
+                { NetworkListTestStates.ContainsLarge, OnContainsLarge },
+                { NetworkListTestStates.Contains, OnContains },
+                { NetworkListTestStates.VerifyData, OnVerifyData },
+                { NetworkListTestStates.IndexOf, OnIndexOf }
+            };
+
+            if (networkListTestState == NetworkListTestStates.ContainsLarge)
+            {
+                for (var i = 0; i < elementCount; ++i)
+                {
+                    m_Player1OnServer.TheLargeList.Add(new FixedString128Bytes());
+                }
+            }
+            else
+            {
+                for (int i = 0; i < elementCount; i++)
+                {
+                    m_Player1OnServer.TheList.Add(Random.Range(0, k_MaxRandomValue));
+                }
+            }
+        }
+    }
+
+    internal class NetvarDespawnShutdown : NetworkBehaviour
+    {
+        private NetworkVariable<int> m_IntNetworkVariable = new NetworkVariable<int>();
+        private NetworkList<int> m_IntList;
+
+        private void Awake()
+        {
+            m_IntList = new NetworkList<int>();
+        }
+
+        public override void OnNetworkDespawn()
+        {
+            if (IsServer)
+            {
+                m_IntNetworkVariable.Value = 5;
+                for (int i = 0; i < 10; i++)
+                {
+                    m_IntList.Add(i);
+                }
+            }
+            base.OnNetworkDespawn();
+        }
+    }
+
+    /// <summary>
+    /// Validates that setting values for NetworkVariable or NetworkList during the
+    /// OnNetworkDespawn method will not cause an exception to occur.
+    /// </summary>
+    internal class NetworkVariableModifyOnNetworkDespawn : NetcodeIntegrationTest
+    {
+        protected override int NumberOfClients => 1;
+
+        private GameObject m_TestPrefab;
+
+        protected override void OnOneTimeSetup()
+        {
+            NetworkVariableBase.IgnoreInitializeWarning = true;
+            base.OnOneTimeSetup();
+        }
+
+        protected override void OnOneTimeTearDown()
+        {
+            NetworkVariableBase.IgnoreInitializeWarning = false;
+            base.OnOneTimeTearDown();
+        }
+
+        protected override void OnServerAndClientsCreated()
+        {
+            m_TestPrefab = CreateNetworkObjectPrefab("NetVarDespawn");
+            m_TestPrefab.AddComponent<NetvarDespawnShutdown>();
+            base.OnServerAndClientsCreated();
+        }
+
+        private bool OnClientSpawnedTestPrefab(ulong networkObjectId)
+        {
+            var clientId = m_ClientNetworkManagers[0].LocalClientId;
+            if (!s_GlobalNetworkObjects.ContainsKey(clientId))
+            {
+                return false;
+            }
+
+            if (!s_GlobalNetworkObjects[clientId].ContainsKey(networkObjectId))
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        [UnityTest]
+        public IEnumerator ModifyNetworkVariableOrListOnNetworkDespawn()
+        {
+            var instance = SpawnObject(m_TestPrefab, m_ServerNetworkManager);
+            yield return WaitForConditionOrTimeOut(() => OnClientSpawnedTestPrefab(instance.GetComponent<NetworkObject>().NetworkObjectId));
+            m_ServerNetworkManager.Shutdown();
+            // As long as no excetptions occur, the test passes.
+        }
+    }
 
 #if !MULTIPLAYER_TOOLS
     [TestFixture(true)]
@@ -612,7 +569,9 @@ namespace Unity.Netcode.RuntimeTests
             InitializeServerAndClients(useHost);
 
             // client must not be allowed to write to a server auth variable
-            Assert.Throws<InvalidOperationException>(() => m_Player1OnClient1.TheScalar.Value = k_TestVal1);
+
+            LogAssert.Expect(LogType.Error, m_Player1OnClient1.TheScalar.GetWritePermissionError());
+            m_Player1OnClient1.TheScalar.Value = k_TestVal1;
         }
 
         /// <summary>
@@ -1053,7 +1012,8 @@ namespace Unity.Netcode.RuntimeTests
         }
 
         [Test]
-        public void TestUnsupportedManagedTypesWithUserSerializationDoNotThrowExceptions()
+        // Exceptions should be thrown in DA mode with UserNetworkVariableSerialization
+        public void TestUnsupportedManagedTypesWithUserSerializationDoNotThrowExceptionsInClientServerMode()
         {
             var variable = new NetworkVariable<string>();
             UserNetworkVariableSerialization<string>.ReadValue = (FastBufferReader reader, out string value) =>
@@ -1079,6 +1039,10 @@ namespace Unity.Netcode.RuntimeTests
                 variable.ReadField(reader);
                 Assert.AreEqual("012345", variable.Value);
             }
+            catch (Exception)
+            {
+                Assert.True(NetworkVariableSerialization<UserNetworkVariableSerialization<string>>.IsDistributedAuthority);
+            }
             finally
             {
                 UserNetworkVariableSerialization<string>.ReadValue = null;
@@ -5125,408 +5089,5 @@ namespace Unity.Netcode.RuntimeTests
             yield return base.OnTearDown();
         }
     }
-
-
-    /// <summary>
-    /// Handles the more generic conditional logic for NetworkList tests
-    /// which can be used with the <see cref="NetcodeIntegrationTest.WaitForConditionOrTimeOut"/>
-    /// that accepts anything derived from the <see cref="ConditionalPredicateBase"/> class
-    /// as a parameter.
-    /// </summary>
-    internal class NetworkListTestPredicate : ConditionalPredicateBase
-    {
-        private const int k_MaxRandomValue = 1000;
-
-        private Dictionary<NetworkListTestStates, Func<bool>> m_StateFunctions;
-
-        // Player1 component on the Server
-        private NetworkVariableTest m_Player1OnServer;
-
-        // Player1 component on client1
-        private NetworkVariableTest m_Player1OnClient1;
-
-        private string m_TestStageFailedMessage;
-
-        public enum NetworkListTestStates
-        {
-            Add,
-            ContainsLarge,
-            Contains,
-            VerifyData,
-            IndexOf,
-        }
-
-        private NetworkListTestStates m_NetworkListTestState;
-
-        public void SetNetworkListTestState(NetworkListTestStates networkListTestState)
-        {
-            m_NetworkListTestState = networkListTestState;
-        }
-
-        /// <summary>
-        /// Determines if the condition has been reached for the current NetworkListTestState
-        /// </summary>
-        protected override bool OnHasConditionBeenReached()
-        {
-            var isStateRegistered = m_StateFunctions.ContainsKey(m_NetworkListTestState);
-            Assert.IsTrue(isStateRegistered);
-            return m_StateFunctions[m_NetworkListTestState].Invoke();
-        }
-
-        /// <summary>
-        /// Provides all information about the players for both sides for simplicity and informative sake.
-        /// </summary>
-        /// <returns></returns>
-        private string ConditionFailedInfo()
-        {
-            return $"{m_NetworkListTestState} condition test failed:\n Server List Count: {m_Player1OnServer.TheList.Count} vs  Client List Count: {m_Player1OnClient1.TheList.Count}\n" +
-                $"Server List Count: {m_Player1OnServer.TheLargeList.Count} vs  Client List Count: {m_Player1OnClient1.TheLargeList.Count}\n" +
-                $"Server Delegate Triggered: {m_Player1OnServer.ListDelegateTriggered} | Client Delegate Triggered: {m_Player1OnClient1.ListDelegateTriggered}\n";
-        }
-
-        /// <summary>
-        /// When finished, check if a time out occurred and if so assert and provide meaningful information to troubleshoot why
-        /// </summary>
-        protected override void OnFinished()
-        {
-            Assert.IsFalse(TimedOut, $"{nameof(NetworkListTestPredicate)} timed out waiting for the {m_NetworkListTestState} condition to be reached! \n" + ConditionFailedInfo());
-        }
-
-        // Uses the ArrayOperator and validates that on both sides the count and values are the same
-        private bool OnVerifyData()
-        {
-            // Wait until both sides have the same number of elements
-            if (m_Player1OnServer.TheList.Count != m_Player1OnClient1.TheList.Count)
-            {
-                return false;
-            }
-
-            // Check the client values against the server values to make sure they match
-            for (int i = 0; i < m_Player1OnServer.TheList.Count; i++)
-            {
-                if (m_Player1OnServer.TheList[i] != m_Player1OnClient1.TheList[i])
-                {
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        /// <summary>
-        /// Verifies the data count, values, and that the ListDelegate on both sides was triggered
-        /// </summary>
-        private bool OnAdd()
-        {
-            bool wasTriggerred = m_Player1OnServer.ListDelegateTriggered && m_Player1OnClient1.ListDelegateTriggered;
-            return wasTriggerred && OnVerifyData();
-        }
-
-        /// <summary>
-        /// The current version of this test only verified the count of the large list, so that is what this does
-        /// </summary>
-        private bool OnContainsLarge()
-        {
-            return m_Player1OnServer.TheLargeList.Count == m_Player1OnClient1.TheLargeList.Count;
-        }
-
-        /// <summary>
-        /// Tests NetworkList.Contains which also verifies all values are the same on both sides
-        /// </summary>
-        private bool OnContains()
-        {
-            // Wait until both sides have the same number of elements
-            if (m_Player1OnServer.TheList.Count != m_Player1OnClient1.TheList.Count)
-            {
-                return false;
-            }
-
-            // Parse through all server values and use the NetworkList.Contains method to check if the value is in the list on the client side
-            foreach (var serverValue in m_Player1OnServer.TheList)
-            {
-                if (!m_Player1OnClient1.TheList.Contains(serverValue))
-                {
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        /// <summary>
-        /// Tests NetworkList.IndexOf and verifies that all values are aligned on both sides
-        /// </summary>
-        private bool OnIndexOf()
-        {
-            foreach (var serverSideValue in m_Player1OnServer.TheList)
-            {
-                var indexToTest = m_Player1OnServer.TheList.IndexOf(serverSideValue);
-                if (indexToTest != m_Player1OnServer.TheList.IndexOf(serverSideValue))
-                {
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        public NetworkListTestPredicate(NetworkVariableTest player1OnServer, NetworkVariableTest player1OnClient1, NetworkListTestStates networkListTestState, int elementCount)
-        {
-            m_NetworkListTestState = networkListTestState;
-            m_Player1OnServer = player1OnServer;
-            m_Player1OnClient1 = player1OnClient1;
-            m_StateFunctions = new Dictionary<NetworkListTestStates, Func<bool>>
-            {
-                { NetworkListTestStates.Add, OnAdd },
-                { NetworkListTestStates.ContainsLarge, OnContainsLarge },
-                { NetworkListTestStates.Contains, OnContains },
-                { NetworkListTestStates.VerifyData, OnVerifyData },
-                { NetworkListTestStates.IndexOf, OnIndexOf }
-            };
-
-            if (networkListTestState == NetworkListTestStates.ContainsLarge)
-            {
-                for (var i = 0; i < elementCount; ++i)
-                {
-                    m_Player1OnServer.TheLargeList.Add(new FixedString128Bytes());
-                }
-            }
-            else
-            {
-                for (int i = 0; i < elementCount; i++)
-                {
-                    m_Player1OnServer.TheList.Add(Random.Range(0, k_MaxRandomValue));
-                }
-            }
-        }
-    }
-
-    [TestFixtureSource(nameof(TestDataSource))]
-    internal class NetworkVariableInheritanceTests : NetcodeIntegrationTest
-    {
-        public NetworkVariableInheritanceTests(HostOrServer hostOrServer)
-            : base(hostOrServer)
-        {
-        }
-
-        protected override int NumberOfClients => 2;
-
-        public static IEnumerable<TestFixtureData> TestDataSource() =>
-            Enum.GetValues(typeof(HostOrServer)).OfType<HostOrServer>().Select(x => new TestFixtureData(x));
-
-        internal class ComponentA : NetworkBehaviour
-        {
-            public NetworkVariable<int> PublicFieldA = new NetworkVariable<int>(1);
-            protected NetworkVariable<int> m_ProtectedFieldA = new NetworkVariable<int>(2);
-            private NetworkVariable<int> m_PrivateFieldA = new NetworkVariable<int>(3);
-
-            public void ChangeValuesA(int pub, int pro, int pri)
-            {
-                PublicFieldA.Value = pub;
-                m_ProtectedFieldA.Value = pro;
-                m_PrivateFieldA.Value = pri;
-            }
-
-            public bool CompareValuesA(ComponentA other)
-            {
-                return PublicFieldA.Value == other.PublicFieldA.Value &&
-                    m_ProtectedFieldA.Value == other.m_ProtectedFieldA.Value &&
-                    m_PrivateFieldA.Value == other.m_PrivateFieldA.Value;
-            }
-        }
-
-        internal class ComponentB : ComponentA
-        {
-            public NetworkVariable<int> PublicFieldB = new NetworkVariable<int>(11);
-            protected NetworkVariable<int> m_ProtectedFieldB = new NetworkVariable<int>(22);
-            private NetworkVariable<int> m_PrivateFieldB = new NetworkVariable<int>(33);
-
-            public void ChangeValuesB(int pub, int pro, int pri)
-            {
-                PublicFieldB.Value = pub;
-                m_ProtectedFieldB.Value = pro;
-                m_PrivateFieldB.Value = pri;
-            }
-
-            public bool CompareValuesB(ComponentB other)
-            {
-                return PublicFieldB.Value == other.PublicFieldB.Value &&
-                    m_ProtectedFieldB.Value == other.m_ProtectedFieldB.Value &&
-                    m_PrivateFieldB.Value == other.m_PrivateFieldB.Value;
-            }
-        }
-
-        internal class ComponentC : ComponentB
-        {
-            public NetworkVariable<int> PublicFieldC = new NetworkVariable<int>(111);
-            protected NetworkVariable<int> m_ProtectedFieldC = new NetworkVariable<int>(222);
-            private NetworkVariable<int> m_PrivateFieldC = new NetworkVariable<int>(333);
-
-            public void ChangeValuesC(int pub, int pro, int pri)
-            {
-                PublicFieldC.Value = pub;
-                m_ProtectedFieldA.Value = pro;
-                m_PrivateFieldC.Value = pri;
-            }
-
-            public bool CompareValuesC(ComponentC other)
-            {
-                return PublicFieldC.Value == other.PublicFieldC.Value &&
-                    m_ProtectedFieldC.Value == other.m_ProtectedFieldC.Value &&
-                    m_PrivateFieldC.Value == other.m_PrivateFieldC.Value;
-            }
-        }
-
-        private GameObject m_TestObjectPrefab;
-        private ulong m_TestObjectId = 0;
-
-        protected override void OnOneTimeSetup()
-        {
-            NetworkVariableBase.IgnoreInitializeWarning = true;
-            base.OnOneTimeSetup();
-        }
-
-        protected override void OnOneTimeTearDown()
-        {
-            NetworkVariableBase.IgnoreInitializeWarning = false;
-            base.OnOneTimeTearDown();
-        }
-
-        protected override void OnServerAndClientsCreated()
-        {
-            m_TestObjectPrefab = CreateNetworkObjectPrefab($"[{nameof(NetworkVariableInheritanceTests)}.{nameof(m_TestObjectPrefab)}]");
-            m_TestObjectPrefab.AddComponent<ComponentA>();
-            m_TestObjectPrefab.AddComponent<ComponentB>();
-            m_TestObjectPrefab.AddComponent<ComponentC>();
-        }
-
-        protected override IEnumerator OnServerAndClientsConnected()
-        {
-            var serverTestObject = SpawnObject(m_TestObjectPrefab, m_ServerNetworkManager).GetComponent<NetworkObject>();
-            m_TestObjectId = serverTestObject.NetworkObjectId;
-
-            var serverTestComponentA = serverTestObject.GetComponent<ComponentA>();
-            var serverTestComponentB = serverTestObject.GetComponent<ComponentB>();
-            var serverTestComponentC = serverTestObject.GetComponent<ComponentC>();
-
-            serverTestComponentA.ChangeValuesA(1000, 2000, 3000);
-            serverTestComponentB.ChangeValuesA(1000, 2000, 3000);
-            serverTestComponentB.ChangeValuesB(1100, 2200, 3300);
-            serverTestComponentC.ChangeValuesA(1000, 2000, 3000);
-            serverTestComponentC.ChangeValuesB(1100, 2200, 3300);
-            serverTestComponentC.ChangeValuesC(1110, 2220, 3330);
-
-            yield return WaitForTicks(m_ServerNetworkManager, 2);
-        }
-
-        private bool CheckTestObjectComponentValuesOnAll()
-        {
-            var serverTestObject = m_ServerNetworkManager.SpawnManager.SpawnedObjects[m_TestObjectId];
-            var serverTestComponentA = serverTestObject.GetComponent<ComponentA>();
-            var serverTestComponentB = serverTestObject.GetComponent<ComponentB>();
-            var serverTestComponentC = serverTestObject.GetComponent<ComponentC>();
-            foreach (var clientNetworkManager in m_ClientNetworkManagers)
-            {
-                var clientTestObject = clientNetworkManager.SpawnManager.SpawnedObjects[m_TestObjectId];
-                var clientTestComponentA = clientTestObject.GetComponent<ComponentA>();
-                var clientTestComponentB = clientTestObject.GetComponent<ComponentB>();
-                var clientTestComponentC = clientTestObject.GetComponent<ComponentC>();
-                if (!serverTestComponentA.CompareValuesA(clientTestComponentA) ||
-                    !serverTestComponentB.CompareValuesA(clientTestComponentB) ||
-                    !serverTestComponentB.CompareValuesB(clientTestComponentB) ||
-                    !serverTestComponentC.CompareValuesA(clientTestComponentC) ||
-                    !serverTestComponentC.CompareValuesB(clientTestComponentC) ||
-                    !serverTestComponentC.CompareValuesC(clientTestComponentC))
-                {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        [UnityTest]
-        public IEnumerator TestInheritedFields()
-        {
-            yield return WaitForConditionOrTimeOut(CheckTestObjectComponentValuesOnAll);
-            Assert.IsFalse(s_GlobalTimeoutHelper.TimedOut, nameof(CheckTestObjectComponentValuesOnAll));
-        }
-    }
-
-    internal class NetvarDespawnShutdown : NetworkBehaviour
-    {
-        private NetworkVariable<int> m_IntNetworkVariable = new NetworkVariable<int>();
-        private NetworkList<int> m_IntList;
-
-        private void Awake()
-        {
-            m_IntList = new NetworkList<int>();
-        }
-
-        public override void OnNetworkDespawn()
-        {
-            if (IsServer)
-            {
-                m_IntNetworkVariable.Value = 5;
-                for (int i = 0; i < 10; i++)
-                {
-                    m_IntList.Add(i);
-                }
-            }
-            base.OnNetworkDespawn();
-        }
-    }
-
-    /// <summary>
-    /// Validates that setting values for NetworkVariable or NetworkList during the
-    /// OnNetworkDespawn method will not cause an exception to occur.
-    /// </summary>
-    internal class NetworkVariableModifyOnNetworkDespawn : NetcodeIntegrationTest
-    {
-        protected override int NumberOfClients => 1;
-
-        private GameObject m_TestPrefab;
-
-        protected override void OnOneTimeSetup()
-        {
-            NetworkVariableBase.IgnoreInitializeWarning = true;
-            base.OnOneTimeSetup();
-        }
-
-        protected override void OnOneTimeTearDown()
-        {
-            NetworkVariableBase.IgnoreInitializeWarning = false;
-            base.OnOneTimeTearDown();
-        }
-
-        protected override void OnServerAndClientsCreated()
-        {
-            m_TestPrefab = CreateNetworkObjectPrefab("NetVarDespawn");
-            m_TestPrefab.AddComponent<NetvarDespawnShutdown>();
-            base.OnServerAndClientsCreated();
-        }
-
-        private bool OnClientSpawnedTestPrefab(ulong networkObjectId)
-        {
-            var clientId = m_ClientNetworkManagers[0].LocalClientId;
-            if (!s_GlobalNetworkObjects.ContainsKey(clientId))
-            {
-                return false;
-            }
-
-            if (!s_GlobalNetworkObjects[clientId].ContainsKey(networkObjectId))
-            {
-                return false;
-            }
-
-            return true;
-        }
-
-        [UnityTest]
-        public IEnumerator ModifyNetworkVariableOrListOnNetworkDespawn()
-        {
-            var instance = SpawnObject(m_TestPrefab, m_ServerNetworkManager);
-            yield return WaitForConditionOrTimeOut(() => OnClientSpawnedTestPrefab(instance.GetComponent<NetworkObject>().NetworkObjectId));
-            m_ServerNetworkManager.Shutdown();
-            // As long as no excetptions occur, the test passes.
-        }
-    }
 }
 #endif

Tests/Runtime/NetworkVariable/OwnerPermissionTests.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Collections;
 using System.Collections.Generic;
 using Unity.Netcode.TestHelpers.Runtime;
@@ -50,7 +49,6 @@ namespace Unity.Netcode.RuntimeTests
         public override void OnNetworkSpawn()
         {
             Objects[CurrentlySpawning, NetworkManager.LocalClientId] = GetComponent<OwnerPermissionObject>();
-            //Debug.Log($"Object index ({CurrentlySpawning}) spawned on client {NetworkManager.LocalClientId}");
         }
 
         private void Awake()
@@ -85,6 +83,8 @@ namespace Unity.Netcode.RuntimeTests
         }
     }
 
+
+
     internal class OwnerPermissionHideTests : NetcodeIntegrationTest
     {
         protected override int NumberOfClients => 2;
@@ -130,70 +130,44 @@ namespace Unity.Netcode.RuntimeTests
                 for (var clientWriting = 0; clientWriting < 3; clientWriting++)
                 {
                     // ==== Server-writable NetworkVariable ====
-                    var gotException = false;
                     VerboseDebug($"Writing to server-write variable on object {objectIndex} on client {clientWriting}");
 
-                    try
-                    {
                     nextValueToWrite++;
-                        OwnerPermissionObject.Objects[objectIndex, clientWriting].MyNetworkVariableServer.Value = nextValueToWrite;
-                    }
-                    catch (Exception)
+                    if (clientWriting != serverIndex)
                     {
-                        gotException = true;
+                        LogAssert.Expect(LogType.Error, OwnerPermissionObject.Objects[objectIndex, clientWriting].MyNetworkVariableServer.GetWritePermissionError());
                     }
-
-                    // Verify server-owned netvar can only be written by server
-                    Debug.Assert(gotException == (clientWriting != serverIndex));
+                    OwnerPermissionObject.Objects[objectIndex, clientWriting].MyNetworkVariableServer.Value = nextValueToWrite;
 
                     // ==== Owner-writable NetworkVariable ====
-                    gotException = false;
                     VerboseDebug($"Writing to owner-write variable on object {objectIndex} on client {clientWriting}");
 
-                    try
-                    {
                     nextValueToWrite++;
-                        OwnerPermissionObject.Objects[objectIndex, clientWriting].MyNetworkVariableOwner.Value = nextValueToWrite;
-                    }
-                    catch (Exception)
+                    if (clientWriting != objectIndex)
                     {
-                        gotException = true;
+                        LogAssert.Expect(LogType.Error, OwnerPermissionObject.Objects[objectIndex, clientWriting].MyNetworkVariableOwner.GetWritePermissionError());
                     }
-
-                    // Verify client-owned netvar can only be written by owner
-                    Debug.Assert(gotException == (clientWriting != objectIndex));
+                    OwnerPermissionObject.Objects[objectIndex, clientWriting].MyNetworkVariableOwner.Value = nextValueToWrite;
 
                     // ==== Server-writable NetworkList ====
-                    gotException = false;
+                    VerboseDebug($"Writing to [Add] server-write NetworkList on object {objectIndex} on client {clientWriting}");
 
-                    try
-                    {
                     nextValueToWrite++;
-                        OwnerPermissionObject.Objects[objectIndex, clientWriting].MyNetworkListServer.Add(nextValueToWrite);
-                    }
-                    catch (Exception)
+                    if (clientWriting != serverIndex)
                     {
-                        gotException = true;
+                        LogAssert.Expect(LogType.Error, OwnerPermissionObject.Objects[objectIndex, clientWriting].MyNetworkListServer.GetWritePermissionError());
                     }
-
-                    // Verify server-owned networkList can only be written by server
-                    Debug.Assert(gotException == (clientWriting != serverIndex));
+                    OwnerPermissionObject.Objects[objectIndex, clientWriting].MyNetworkListServer.Add(nextValueToWrite);
 
                     // ==== Owner-writable NetworkList ====
-                    gotException = false;
+                    VerboseDebug($"Writing to [Add] owner-write NetworkList on object {objectIndex} on client {clientWriting}");
 
-                    try
-                    {
                     nextValueToWrite++;
-                        OwnerPermissionObject.Objects[objectIndex, clientWriting].MyNetworkListOwner.Add(nextValueToWrite);
-                    }
-                    catch (Exception)
+                    if (clientWriting != objectIndex)
                     {
-                        gotException = true;
+                        LogAssert.Expect(LogType.Error, OwnerPermissionObject.Objects[objectIndex, clientWriting].MyNetworkListOwner.GetWritePermissionError());
                     }
-
-                    // Verify client-owned networkList can only be written by owner
-                    Debug.Assert(gotException == (clientWriting != objectIndex));
+                    OwnerPermissionObject.Objects[objectIndex, clientWriting].MyNetworkListOwner.Add(nextValueToWrite);
 
                     yield return WaitForTicks(m_ServerNetworkManager, 5);
                     yield return WaitForTicks(m_ClientNetworkManagers[0], 5);

Tests/Runtime/NetworkVisibilityTests.cs

@@ -14,9 +14,11 @@ namespace Unity.Netcode.RuntimeTests
     internal class NetworkVisibilityTests : NetcodeIntegrationTest
     {
 
-        protected override int NumberOfClients => 1;
+        protected override int NumberOfClients => 2;
         private GameObject m_TestNetworkPrefab;
         private bool m_SceneManagementEnabled;
+        private GameObject m_SpawnedObject;
+        private NetworkManager m_SessionOwner;
 
         public NetworkVisibilityTests(SceneManagementState sceneManagementState, NetworkTopologyTypes networkTopologyType) : base(networkTopologyType)
         {
@@ -27,7 +29,11 @@ namespace Unity.Netcode.RuntimeTests
         {
             m_TestNetworkPrefab = CreateNetworkObjectPrefab("Object");
             m_TestNetworkPrefab.AddComponent<NetworkVisibilityComponent>();
+            if (!UseCMBService())
+            {
                 m_ServerNetworkManager.NetworkConfig.EnableSceneManagement = m_SceneManagementEnabled;
+            }
+
             foreach (var clientNetworkManager in m_ClientNetworkManagers)
             {
                 clientNetworkManager.NetworkConfig.EnableSceneManagement = m_SceneManagementEnabled;
@@ -38,7 +44,8 @@ namespace Unity.Netcode.RuntimeTests
 
         protected override IEnumerator OnServerAndClientsConnected()
         {
-            SpawnObject(m_TestNetworkPrefab, m_ServerNetworkManager);
+            m_SessionOwner = UseCMBService() ? m_ClientNetworkManagers[0] : m_ServerNetworkManager;
+            m_SpawnedObject = SpawnObject(m_TestNetworkPrefab, m_SessionOwner);
 
             yield return base.OnServerAndClientsConnected();
         }
@@ -46,13 +53,49 @@ namespace Unity.Netcode.RuntimeTests
         [UnityTest]
         public IEnumerator HiddenObjectsTest()
         {
+            var expectedCount = UseCMBService() ? 2 : 3;
 #if UNITY_2023_1_OR_NEWER
-            yield return WaitForConditionOrTimeOut(() => Object.FindObjectsByType<NetworkVisibilityComponent>(FindObjectsSortMode.None).Where((c) => c.IsSpawned).Count() == 2);
+            yield return WaitForConditionOrTimeOut(() => Object.FindObjectsByType<NetworkVisibilityComponent>(FindObjectsSortMode.None).Where((c) => c.IsSpawned).Count() == expectedCount);
 #else
-            yield return WaitForConditionOrTimeOut(() => Object.FindObjectsOfType<NetworkVisibilityComponent>().Where((c) => c.IsSpawned).Count() == 2);
+            yield return WaitForConditionOrTimeOut(() => Object.FindObjectsOfType<NetworkVisibilityComponent>().Where((c) => c.IsSpawned).Count() == expectedCount);
 #endif
 
             Assert.IsFalse(s_GlobalTimeoutHelper.TimedOut, "Timed out waiting for the visible object count to equal 2!");
         }
+
+        [UnityTest]
+        public IEnumerator HideShowAndDeleteTest()
+        {
+            var expectedCount = UseCMBService() ? 2 : 3;
+#if UNITY_2023_1_OR_NEWER
+            yield return WaitForConditionOrTimeOut(() => Object.FindObjectsByType<NetworkVisibilityComponent>(FindObjectsSortMode.None).Where((c) => c.IsSpawned).Count() == expectedCount);
+#else
+            yield return WaitForConditionOrTimeOut(() => Object.FindObjectsOfType<NetworkVisibilityComponent>().Where((c) => c.IsSpawned).Count() == expectedCount);
+#endif
+            AssertOnTimeout("Timed out waiting for the visible object count to equal 2!");
+
+            var sessionOwnerNetworkObject = m_SpawnedObject.GetComponent<NetworkObject>();
+            var clientIndex = UseCMBService() ? 1 : 0;
+            sessionOwnerNetworkObject.NetworkHide(m_ClientNetworkManagers[clientIndex].LocalClientId);
+#if UNITY_2023_1_OR_NEWER
+            yield return WaitForConditionOrTimeOut(() => Object.FindObjectsByType<NetworkVisibilityComponent>(FindObjectsSortMode.None).Where((c) => c.IsSpawned).Count() == expectedCount - 1);
+#else
+            yield return WaitForConditionOrTimeOut(() => Object.FindObjectsOfType<NetworkVisibilityComponent>().Where((c) => c.IsSpawned).Count() == expectedCount - 1);
+#endif
+            AssertOnTimeout($"Timed out waiting for {m_SpawnedObject.name} to be hidden from client!");
+            var networkObjectId = sessionOwnerNetworkObject.NetworkObjectId;
+            sessionOwnerNetworkObject.NetworkShow(m_ClientNetworkManagers[clientIndex].LocalClientId);
+            sessionOwnerNetworkObject.Despawn(true);
+
+            // Expect no exceptions
+            yield return s_DefaultWaitForTick;
+
+            // Now force a scenario where it normally would have caused an exception
+            m_SessionOwner.SpawnManager.ObjectsToShowToClient.Add(m_ClientNetworkManagers[clientIndex].LocalClientId, new System.Collections.Generic.List<NetworkObject>());
+            m_SessionOwner.SpawnManager.ObjectsToShowToClient[m_ClientNetworkManagers[clientIndex].LocalClientId].Add(null);
+
+            // Expect no exceptions
+            yield return s_DefaultWaitForTick;
+        }
     }
 }

Tests/Runtime/TransformInterpolationTests.cs

@@ -63,14 +63,10 @@ namespace Unity.Netcode.RuntimeTests
         private const int k_MaxThresholdFailures = 4;
         private int m_ExceededThresholdCount;
 
-        private void Update()
+        public override void OnUpdate()
         {
             base.OnUpdate();
 
-            if (!IsSpawned || TestComplete)
-            {
-                return;
-            }
 
             // Check the position of the nested object on the client
             if (CheckPosition)
@@ -92,6 +88,17 @@ namespace Unity.Netcode.RuntimeTests
                     m_ExceededThresholdCount = 0;
                 }
             }
+        }
+
+        private void Update()
+        {
+            base.OnUpdate();
+
+            if (!IsSpawned || !CanCommitToTransform || TestComplete)
+            {
+                return;
+            }
+
 
             // Move the nested object on the server
             if (IsMoving)
@@ -136,7 +143,6 @@ namespace Unity.Netcode.RuntimeTests
                 Assert.True(CanCommitToTransform, $"Using non-authority instance to update transform!");
                 transform.position = new Vector3(1000.0f, 1000.0f, 1000.0f);
             }
-
         }
     }
 

package.json

@@ -2,23 +2,23 @@
   "name": "com.unity.netcode.gameobjects",
   "displayName": "Netcode for GameObjects",
   "description": "Netcode for GameObjects is a high-level netcode SDK that provides networking capabilities to GameObject/MonoBehaviour workflows within Unity and sits on top of underlying transport layer.",
-  "version": "2.0.0-pre.2",
+  "version": "2.0.0",
   "unity": "6000.0",
   "dependencies": {
     "com.unity.nuget.mono-cecil": "1.11.4",
-    "com.unity.transport": "2.2.1"
+    "com.unity.transport": "2.3.0"
   },
   "_upm": {
-    "changelog": "### Added\n\n- Added `AnticipatedNetworkVariable<T>`, which adds support for client anticipation of `NetworkVariable` values, allowing for more responsive gameplay. (#2957)\n- Added `AnticipatedNetworkTransform`, which adds support for client anticipation of NetworkTransforms. (#2957)\n- Added `NetworkVariableBase.ExceedsDirtinessThreshold` to allow network variables to throttle updates by only sending updates when the difference between the current and previous values exceeds a threshold. (This is exposed in `NetworkVariable<T>` with the callback `NetworkVariable<T>.CheckExceedsDirtinessThreshold`). (#2957)\n- Added `NetworkVariableUpdateTraits`, which add additional throttling support: `MinSecondsBetweenUpdates` will prevent the `NetworkVariable` from sending updates more often than the specified time period (even if it exceeds the dirtiness threshold), while `MaxSecondsBetweenUpdates` will force a dirty `NetworkVariable` to send an update after the specified time period even if it has not yet exceeded the dirtiness threshold. (#2957)\n- Added virtual method `NetworkVariableBase.OnInitialize` which can be used by `NetworkVariable` subclasses to add initialization code. (#2957)\n- Added `NetworkTime.TickWithPartial`, which represents the current tick as a double that includes the fractional/partial tick value. (#2957)\n- Added `NetworkTickSystem.AnticipationTick`, which can be helpful with implementation of client anticipation. This value represents the tick the current local client was at at the beginning of the most recent network round trip, which enables it to correlate server update ticks with the client tick that may have triggered them. (#2957)\n- Added event `NetworkManager.OnSessionOwnerPromoted` that is invoked when a new session owner promotion occurs. (#2948)\n- Added `NetworkRigidBodyBase.GetLinearVelocity` and `NetworkRigidBodyBase.SetLinearVelocity` convenience/helper methods. (#2948)\n- Added `NetworkRigidBodyBase.GetAngularVelocity` and `NetworkRigidBodyBase.SetAngularVelocity` convenience/helper methods. (#2948)\n\n### Fixed\n\n- Fixed issue when `NetworkTransform` half float precision is enabled and ownership changes the current base position was not being synchronized. (#2948)\n- Fixed issue where `OnClientConnected` not being invoked on the session owner when connecting to a new distributed authority session. (#2948)\n- Fixed issue where Rigidbody micro-motion (i.e. relatively small velocities) would result in non-authority instances slightly stuttering as the body would come to a rest (i.e. no motion). Now, the threshold value can increase at higher velocities and can decrease slightly below the provided threshold to account for this. (#2948)\n\n### Changed\n\n- Changed `NetworkAnimator` no longer requires the `Animator` component to exist on the same `GameObject`. (#2957)\n- Changed `NetworkObjectReference` and `NetworkBehaviourReference` to allow null references when constructing and serializing. (#2957)\n- Changed the client's owned objects is now returned (`NetworkClient` and `NetworkSpawnManager`) as an array as opposed to a list for performance purposes. (#2948)\n- Changed `NetworkTransfrom.TryCommitTransformToServer` to be internal as it will be removed by the final 2.0.0 release. (#2948)\n- Changed `NetworkTransformEditor.OnEnable` to a virtual method to be able to customize a `NetworkTransform` derived class by creating a derived editor control from `NetworkTransformEditor`. (#2948)"
+    "changelog": "### Added\n\n- Added tooltips for all of the `NetworkObject` component's properties. (#3052)\n- Added message size validation to named and unnamed message sending functions for better error messages. (#3049)\n- Added \"Check for NetworkObject Component\" property to the Multiplayer->Netcode for GameObjects project settings. When disabled, this will bypass the in-editor `NetworkObject` check on `NetworkBehaviour` components. (#3031)\n- Added `NetworkTransform.SwitchTransformSpaceWhenParented` property that, when enabled, will handle the world to local, local to world, and local to local transform space transitions when interpolation is enabled. (#3013)\n- Added `NetworkTransform.TickSyncChildren` that, when enabled, will tick synchronize nested and/or child `NetworkTransform` components to eliminate any potential visual jittering that could occur if the `NetworkTransform` instances get into a state where their state updates are landing on different network ticks. (#3013)\n- Added `NetworkObject.AllowOwnerToParent` property to provide the ability to allow clients to parent owned objects when running in a client-server network topology. (#3013)\n- Added `NetworkObject.SyncOwnerTransformWhenParented` property to provide a way to disable applying the server's transform information in the parenting message on the client owner instance which can be useful for owner authoritative motion models. (#3013)\n- Added `NetcodeEditorBase` editor helper class to provide easier modification and extension of the SDK's components. (#3013)\n\n### Fixed\n\n- Fixed issue where `NetworkAnimator` would send updates to non-observer clients. (#3057)\n- Fixed issue where an exception could occur when receiving a universal RPC for a `NetworkObject` that has been despawned. (#3052)\n- Fixed issue where a NetworkObject hidden from a client that is then promoted to be session owner was not being synchronized with newly joining clients.(#3051)\n- Fixed issue where clients could have a wrong time delta on `NetworkVariableBase` which could prevent from sending delta state updates. (#3045)\n- Fixed issue where setting a prefab hash value during connection approval but not having a player prefab assigned could cause an exception when spawning a player. (#3042)\n- Fixed issue where the `NetworkSpawnManager.HandleNetworkObjectShow` could throw an exception if one of the `NetworkObject` components to show was destroyed during the same frame. (#3030)\n- Fixed issue where the `NetworkManagerHelper` was continuing to check for hierarchy changes when in play mode. (#3026)\n- Fixed issue with newly/late joined clients and `NetworkTransform` synchronization of parented `NetworkObject` instances. (#3013)\n- Fixed issue with smooth transitions between transform spaces when interpolation is enabled (requires `NetworkTransform.SwitchTransformSpaceWhenParented` to be enabled). (#3013)\n\n### Changed\n\n- Changed `NetworkTransformEditor` now uses `NetworkTransform` as the base type class to assure it doesn't display a foldout group when using the base `NetworkTransform` component class. (#3052)\n- Changed `NetworkAnimator.Awake` is now a protected virtual method. (#3052)\n- Changed  when invoking `NetworkManager.ConnectionManager.DisconnectClient` during a distributed authority session a more appropriate message is logged. (#3052)\n- Changed `NetworkTransformEditor` so it now derives from `NetcodeEditorBase`. (#3013)\n- Changed `NetworkRigidbodyBaseEditor` so it now derives from `NetcodeEditorBase`. (#3013)\n- Changed `NetworkManagerEditor` so it now derives from `NetcodeEditorBase`. (#3013)"
   },
   "upmCi": {
-    "footprint": "dffe7543c19c2670755cc7da27e1d4522c9414a9"
+    "footprint": "f1ef7566b7a89b1ee9c34cc13400735ae63964d4"
   },
   "documentationUrl": "https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@2.0/manual/index.html",
   "repository": {
     "url": "https://github.com/Unity-Technologies/com.unity.netcode.gameobjects.git",
     "type": "git",
-    "revision": "2ecbd14351cac29ab3a18cc159c0a82513e9d241"
+    "revision": "8a7ae9f91a53bdcabe5e7df783dd1884c07bcd6f"
   },
   "samples": [
     {