feat: hybrid NetcodeConfig defaults (#4144)

* feat: auto-configure NetcodeConfig for hybrid mode

When Netcode for Entities is installed and a registered network prefab
carries a GhostObject, the project's NetCodeConfig is now aligned with
what NGO needs rather than leaving it to the user to discover.

The two settings hybrid mode cannot run without (single world hosting,
and automatic bootstrapping disabled since NetworkManager owns world
creation) are corrected whenever they drift. The Netcode for Entities
tick rates are driven from NetworkConfig.TickRate so that ghost
transform updates land on the same interval as everything else. The
snapshot, interpolation and transport values tuned against the 2000
instance stress test are applied once and then left alone, so a user's
own edits survive; Project Settings > Multiplayer > Netcode for
GameObjects can restore them.

The config is never created here. Netcode for Entities already creates
one unconditionally from its own InitializeOnLoadMethod, and creating a
second lands the project in its multiple-config error path.

Also:
- UnifiedIsConfiguredCorrectly now validates EnableClientServerBootstrap
  and warns when the two tick rates diverge. Its two log messages were
  missing their string interpolation prefixes.
- m_TempStreamSize returns to the Netcode for Entities default of 8192.
  GhostSendSystem takes max(TempStreamInitialSize, dataStream.Capacity),
  and capacity is DefaultSnapshotPacketSize, so 4192 had no effect.
- Unity.Netcode.Editor.Tests gains the UNIFIED_NETCODE version define.
  Without it any hybrid editor test compiles away and reports zero cases
  rather than failing.
- Adds a measurement fixture for sizing DefaultSnapshotPacketSize. It is
  marked Explicit so its 24 cases stay out of the suites.

* style

Some comment clean up.

* fix and test

Fixing some things u-pr caught and adding a test to validate the update.

* refactor

Refactoring when the NetcodeConfig default settings are written.
Assuring that the NetcodeConfig tick rate is always the currently set tick rate when starting a session.

* test

Updating to use a more NGO like testing pattern.
Some comment clean up is included.

* update

resolving concern over the .EndVertical();

* style

removing white space.

* chore: n4e 7.0.0 spellings, review feedback and snapshot size

N4E 7.0.0 renamed NetCodeConfig to NetcodeConfig and moved its types into
Unity.Netcode. Use the 7.0.0 spelling, aliased for 6.7.0 the way the rest of
the unified code already is.

The editor test assembly still declared UNIFIED_NETCODE as a versionDefine
after #4158 made it project-level, so its unified block compiled while the
runtime's did not. It also referenced Unity.NetCode by name alongside the GUID
for the same assembly. Both removed, UNIFIED_NETCODE_7_0_0 added.

The snapshot packet size drops from 15000 to 4096. A snapshot is sent
unreliably, so losing any one of its fragments loses the whole snapshot: 4096
spans 3 datagrams at the 1400 byte MTU where 15000 spanned 11, and still caps
~840 ghosts at the measured 4.87 bytes each. The defaults version is bumped so
a project that already recorded the marker picks the new value up.

Review feedback:
- The experimental opt-in is gone. N4E ships as a normal 3.0.0 release.
- ResolveGlobalConfig's project scan is gone. N4E assigns NetcodeConfig.Global
  from an InitializeOnLoadMethod and delayCall runs after those complete, so
  there is nothing left for a scan to catch.
- The apply log uses the contextual logger at Developer level.
- UnifiedIsConfiguredCorrectly reports which setting is wrong rather than
  discarding the reason it already computed.

* feat: hybrid NetcodeConfig values applied at session start

Netcode for GameObjects no longer writes anything into the NetcodeConfig asset. NetworkManager writes the
in-memory global config immediately before the world is created from it, and Netcode for Entities seeds its
world singletons from that.

Two values are driven, both measured rather than assumed:

- The tick rates. NGO's own send queues are flushed by a system in N4E's SimulationSystemGroup, so a
  simulation rate below NetworkConfig.TickRate starves NGO's outbound traffic. N4E defaults to 60 and NGO
  to 30.
- The snapshot packet size, behind the new NetworkConfig.AutoConfigureSnapshotSize. N4E's default of one
  MTU round-robins above roughly 230 GhostObjects: at 512 instances it holds a 13.51Hz effective update
  rate against a 30Hz tick, where 4096 holds 30.00Hz with no saturated snapshots. Below that count the cap
  is never reached, so it costs nothing.

UnifiedBootstrap no longer delegates to base.Initialize. Entities selects the most derived ICustomBootstrap,
so this type is the only one it instantiates under UNIFIED_NETCODE and N4E's own Initialize is never reached
on its own. Calling it only gave N4E a chance to create worlds this bootstrap would then reject, which is why
EnableClientServerBootstrap had to be configured at all. It no longer does.

Removed with it: the editor applier, the Project Settings section, the applied-defaults version marker, and
the interpolation, despawn reservation and transport queue values. Those were tuned against a 2000 instance
stress test and are either inside N4E's own recommended ranges or inert below the snapshot cap.

The FailValidation and ClientDoesNotRequest hybrid test cases are removed pending a separate fix: the server
schedules its disconnect reason into N4E's outgoing RPC buffer and then tears the connection down in the same
call, before RpcSystem transmits it.

* test: move the connection approval latch fix out of this PR

The polled disconnect reason check belongs with the fix for the defect it found, not with the
NetcodeConfig changes. Only the removal of the FailValidation hybrid fixture stays here.

* chore: verbosity pass

Drops a stray blank line that was the only remaining change in NetcodeForGameObjectsProjectSettings, so
that file leaves the diff. Trims the comments that carried mechanism or measurements the PR description
already covers, keeping the reason each value or omission exists.

* chore: clarify the AutoConfigureSnapshotSize tooltip

---------

Co-authored-by: Unity Netcode CI <74025435+netcode-ci-service@users.noreply.github.com>

Author: NoelStephensUnity

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -10,6 +10,9 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 ### Added
 
+- Added alignment of the Netcode for Entities tick rates with `NetworkConfig.TickRate` when a session carrying `GhostObject` prefabs is started, so `GhostObject` updates land on the same interval as the rest of Netcode for GameObjects. (#4144)
+- Added `NetworkConfig.AutoConfigureSnapshotSize`, enabled by default, which sets the Netcode for Entities snapshot packet size to 4096 bytes when a session carrying `GhostObject` prefabs is started. Netcode for Entities defaults to a single MTU, which updates `GhostObject`s well below the tick rate at the instance counts Netcode for GameObjects projects typically run. Disable it to manage the value yourself. (#4144)
+
 ### Changed
 
 ### Deprecated
@@ -22,6 +25,8 @@ Additional documentation and release notes are available at [Multiplayer Documen
 - Issue where a `NetworkObject` that was moved into another scene while hidden from a client spawned in that client's active scene when it was shown with `NetworkShow`, instead of the scene it is in on the server. (#4176)
 - Fixed issue where a prefab added to a `NetworkPrefabsList` while a session was running was registered more than once and logged a duplicate `GlobalObjectIdHash` error. (#4184)
 - Fixed an issue where mixed authority nested `NetworkTransform` instances could stop child/nested instances from updating because an authoritative `NetworkTransform` (root or otherwise) would remove the `NetworkObject` from the update group, preventing non-authoritative instances from updating their state on the authority side. (#4169)
+- Issue where the hybrid mode `NetcodeConfig` validation messages were not interpolated, so they reported placeholders instead of the setting that was wrong. (#4144)
+- Issue where a hybrid mode session failed to start unless `NetcodeConfig.EnableClientServerBootstrap` was set to `DisableAutomaticBootstrap`. Netcode for GameObjects creates the world itself and no longer needs that setting changed. (#4144)
 
 ### Security
 

com.unity.netcode.gameobjects/Editor/NetworkManagerEditor.cs

@@ -37,6 +37,9 @@ public class NetworkManagerEditor : NetcodeEditorBase<NetworkManager>
         private SerializedProperty m_ProtocolVersionProperty;
         private SerializedProperty m_NetworkTransportProperty;
         private SerializedProperty m_TickRateProperty;
+#if UNIFIED_NETCODE
+        private SerializedProperty m_AutoConfigureSnapshotSizeProperty;
+#endif
 #if MULTIPLAYER_SERVICES_SDK_INSTALLED
         private SerializedProperty m_AutoSpawnPlayerPrefabClientSide;
         private SerializedProperty m_NetworkTopologyProperty;
@@ -114,6 +117,9 @@ private void Initialize()
             m_ProtocolVersionProperty = m_NetworkConfigProperty.FindPropertyRelative("ProtocolVersion");
             m_NetworkTransportProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkTransport");
             m_TickRateProperty = m_NetworkConfigProperty.FindPropertyRelative("TickRate");
+#if UNIFIED_NETCODE
+            m_AutoConfigureSnapshotSizeProperty = m_NetworkConfigProperty.FindPropertyRelative(nameof(NetworkConfig.AutoConfigureSnapshotSize));
+#endif
 #if MULTIPLAYER_SERVICES_SDK_INSTALLED
             m_NetworkTopologyProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkTopology");
             // Only display the auto spawn property when the distributed authority network topology is selected
@@ -157,6 +163,9 @@ private void CheckNullProperties()
             m_ProtocolVersionProperty = m_NetworkConfigProperty.FindPropertyRelative("ProtocolVersion");
             m_NetworkTransportProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkTransport");
             m_TickRateProperty = m_NetworkConfigProperty.FindPropertyRelative("TickRate");
+#if UNIFIED_NETCODE
+            m_AutoConfigureSnapshotSizeProperty = m_NetworkConfigProperty.FindPropertyRelative(nameof(NetworkConfig.AutoConfigureSnapshotSize));
+#endif
 #if MULTIPLAYER_SERVICES_SDK_INSTALLED
             m_NetworkTopologyProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkTopology");
             // Only display the auto spawn property when the distributed authority network topology is selected
@@ -198,6 +207,12 @@ private void DisplayNetworkManagerProperties()
                 EditorGUILayout.PropertyField(m_LogLevelProperty);
                 EditorGUILayout.Space();
 
+#if UNIFIED_NETCODE
+                EditorGUILayout.LabelField("Hybrid Settings", EditorStyles.boldLabel);
+                EditorGUILayout.PropertyField(m_AutoConfigureSnapshotSizeProperty);
+                EditorGUILayout.Space();
+#endif
+
                 EditorGUILayout.LabelField("Network Settings", EditorStyles.boldLabel);
 #if MULTIPLAYER_SERVICES_SDK_INSTALLED
                 EditorGUILayout.PropertyField(m_NetworkTopologyProperty);
@@ -221,6 +236,7 @@ private void DisplayNetworkManagerProperties()
                     }
                 }
                 EditorGUILayout.PropertyField(m_TickRateProperty);
+
                 EditorGUILayout.PropertyField(m_SpawnTimeOutProperty);
                 EditorGUILayout.PropertyField(m_ConnectionApprovalProperty);
                 if (m_NetworkManager.NetworkConfig.ConnectionApproval)

com.unity.netcode.gameobjects/Runtime/Components/Helpers/UnifiedBootstrap.cs

@@ -63,11 +63,9 @@ public override bool Initialize(string defaultWorldName)
             }
 
             AutoConnectPort = Port;
-            if (base.Initialize(defaultWorldName))
-            {
-                Debug.LogError($"[{nameof(UnifiedBootstrap)}] Auto-bootstrap is enabled!!! This will break the POC!");
-                return true;
-            }
+
+            // NetworkManager owns world creation here, so base.Initialize is deliberately not called: it would
+            // let Netcode for Entities create worlds this bootstrap then has to reject.
 
             if (networkManager != null)
             {

com.unity.netcode.gameobjects/Runtime/Configuration/HybridNetcodeDefaults.cs

@@ -0,0 +1,80 @@
+#if UNIFIED_NETCODE
+#if !UNIFIED_NETCODE_7_0_0
+using NetcodeConfig = Unity.NetCode.NetCodeConfig;
+#endif
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// This handles applying two <see cref="NetcodeConfig"/> settings NGO requires and an optional recommended snapshot size when running in hybrid mode.
+    /// </summary>
+    /// <remarks>
+    /// This intentionally does not modify the <see cref="NetcodeConfig"/> asset to preserve the default settings and/or any user adjustments other than the ones required.
+    /// </remarks>
+    internal static class HybridNetcodeDefaults
+    {
+        // A hybrid ghost costs ~4.87 bytes per snapshot, so this carries ~840 of them at the full tick rate, which
+        // covers the 200-1000 moving instances projects typically run. The default MTU size will round-robin at around ~230 instances.
+        internal const int SnapshotPacketSize = 4096;
+
+        /// <summary>
+        /// Assures N4E's tick rate matches NGO's <see cref="NetworkConfig.TickRate"/> setting.
+        /// </summary>
+        /// <remarks>
+        /// Not cosmetic: NGO's own send queues are flushed by a system in N4E's SimulationSystemGroup, which steps at
+        /// SimulationTickRate, so a rate below <see cref="NetworkConfig.TickRate"/> starves NGO's outbound traffic.
+        /// </remarks>
+        /// <param name="config">The configuration to determine if NGO's tick rate should be applied.</param>
+        /// <param name="tickRate">The owning <see cref="NetworkManager"/>'s configured tick rate.</param>
+        /// <returns>True if anything changed.</returns>
+        internal static bool ApplyTickRate(NetcodeConfig config, uint tickRate)
+        {
+            var rate = (int)tickRate;
+            if (config.ClientServerTickRate.SimulationTickRate == rate && config.ClientServerTickRate.NetworkTickRate == rate)
+            {
+                return false;
+            }
+
+            // Both are written because you can set NetworkTickRate to 0 which N4E would then use SimulationTickRate.
+            // Keeping both locked in at NGO's tick rate (runtime only) assures there can be no deviation.
+            config.ClientServerTickRate.SimulationTickRate = rate;
+            config.ClientServerTickRate.NetworkTickRate = rate;
+            return true;
+        }
+
+        /// <summary>
+        /// Sets N4E's snapshot packet size to <see cref="SnapshotPacketSize"/>.
+        /// </summary>
+        /// <param name="config">The config to correct.</param>
+        /// <returns>True if anything changed.</returns>
+        internal static bool ApplySnapshotPacketSize(NetcodeConfig config)
+        {
+            if (config.GhostSendSystemData.DefaultSnapshotPacketSize == SnapshotPacketSize)
+            {
+                return false;
+            }
+
+            config.GhostSendSystemData.DefaultSnapshotPacketSize = SnapshotPacketSize;
+            return true;
+        }
+
+        /// <summary>
+        /// Determines if the NetcodeConfig about to be used to start a session meets the required settings.
+        /// </summary>
+        /// <param name="config">The config to check.</param>
+        /// <param name="reason">Populated with a user-facing description of what is wrong.</param>
+        /// <returns>True when <paramref name="config"/> is not configured correctly.</returns>
+        internal static bool IsMissingRequired(NetcodeConfig config, out string reason)
+        {
+            if (config.HostWorldModeSelection != NetcodeConfig.HostWorldMode.SingleWorld)
+            {
+                reason = $"{nameof(NetcodeConfig.HostWorldModeSelection)} must be {nameof(NetcodeConfig.HostWorldMode.SingleWorld)} but is {config.HostWorldModeSelection}";
+                return true;
+            }
+
+            reason = null;
+            return false;
+        }
+    }
+}
+#endif

com.unity.netcode.gameobjects/Runtime/Configuration/HybridNetcodeDefaults.cs.meta

@@ -52,6 +52,20 @@ public class NetworkConfig
         [Tooltip("The tickrate. This value controls how often netcode runs user code and sends out data. The value is in 'ticks per seconds' which means a value of 50 will result in 50 ticks being executed per second or a fixed delta time of 0.02.")]
         public uint TickRate = 30;
 
+#if UNIFIED_NETCODE
+        /// <summary>
+        /// Whether Netcode for GameObjects sets the Netcode for Entities snapshot packet size when a session
+        /// carrying GhostObjects starts.
+        /// </summary>
+        /// <remarks>
+        /// The default suits the 200-1000 moving instances most projects run. Netcode for Entities' own default is
+        /// one MTU, which round-robins above roughly 230 GhostObjects and drops their update rate well below
+        /// <see cref="TickRate"/>. Turn this off to keep whatever the NetcodeConfig asset specifies.
+        /// </remarks>
+        [Tooltip("When enabled, NGO will drive the N4E snapshot size setting for this project. The value defaults to 4096 bytes. This is a measured estimate for a project that uses the default tick rate of 30 and could have roughly 200-1000 spawned hybrid prefab instances.")]
+        public bool AutoConfigureSnapshotSize = true;
+#endif
+
         /// <summary>
         /// The amount of seconds for the server to wait for the connection approval handshake to complete before the client is disconnected.
         ///

com.unity.netcode.gameobjects/Runtime/Configuration/NetworkConfig.cs

@@ -1416,13 +1416,33 @@ private bool UnifiedIsConfiguredCorrectly()
                 Log.Error(new Context(LogLevel.Error, $"You must create a {nameof(NetcodeConfig)} and set it to a single world in order to run in hybrid mode!").AddTag("Unified"));
                 return false;
             }
-            if (NetcodeConfig.Global.HostWorldModeSelection != NetcodeConfig.HostWorldMode.SingleWorld)
+            if (HybridNetcodeDefaults.IsMissingRequired(NetcodeConfig.Global, out var reason))
             {
-                Log.Error(new Context(LogLevel.Error, $"You must configure {nameof(NetcodeConfig)} to only use a single world in order to run in hybrid mode!").AddTag("Unified"));
+                Log.Error(new Context(LogLevel.Error, $"The {nameof(NetcodeConfig)} cannot be used in hybrid mode: {reason}.").AddTag("Unified"));
                 return false;
             }
             return true;
         }
+
+        /// <summary>
+        /// Invoked before creating the world for a hybrid mode session to assure the required NetcodeConfig settings are applied.
+        /// </summary>
+        /// <remarks>
+        /// Netcode for Entities copies the config into its world singletons once, at world creation, so this is the
+        /// point where it takes effect. This occurs during runtime to avoid modification of the NetcodeConfig asset.
+        /// </remarks>
+        private void UnifiedApplyNetcodeConfig()
+        {
+            if (HybridNetcodeDefaults.ApplyTickRate(NetcodeConfig.Global, NetworkConfig.TickRate))
+            {
+                Log.Info(new Context(LogLevel.Developer, $"The {nameof(NetcodeConfig)} tick rates have been set to {nameof(NetworkConfig)}.{nameof(NetworkConfig.TickRate)} ({NetworkConfig.TickRate}).").AddTag("Unified"));
+            }
+
+            if (NetworkConfig.AutoConfigureSnapshotSize && HybridNetcodeDefaults.ApplySnapshotPacketSize(NetcodeConfig.Global))
+            {
+                Log.Info(new Context(LogLevel.Developer, $"The {nameof(NetcodeConfig)} snapshot packet size has been set to {HybridNetcodeDefaults.SnapshotPacketSize}. Disable {nameof(NetworkConfig)}.{nameof(NetworkConfig.AutoConfigureSnapshotSize)} to manage it yourself.").AddTag("Unified"));
+            }
+        }
 #endif
 
         /// <summary>
@@ -1466,6 +1486,7 @@ public bool StartServer()
                     ShutdownInternal();
                     return false;
                 }
+                UnifiedApplyNetcodeConfig();
                 if (LogLevel <= LogLevel.Developer)
                 {
                     Log.Info(new Context(LogLevel.Developer, "Creating world: Default world"));
@@ -1545,6 +1566,7 @@ public bool StartClient()
                     ShutdownInternal();
                     return false;
                 }
+                UnifiedApplyNetcodeConfig();
                 Log.Info(new Context(LogLevel.Developer, "Creating world: Default world"));
                 InitializeNetcodeWorld();
             }
@@ -1619,6 +1641,7 @@ public bool StartHost()
                     ShutdownInternal();
                     return false;
                 }
+                UnifiedApplyNetcodeConfig();
                 Log.Info(new Context(LogLevel.Developer, "Creating world: Default world"));
                 InitializeNetcodeWorld();
             }

com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs

@@ -0,0 +1,100 @@
+#if UNIFIED_NETCODE
+using NUnit.Framework;
+#if !UNIFIED_NETCODE_7_0_0
+using NetcodeConfig = Unity.NetCode.NetCodeConfig;
+#endif
+using UnityEngine;
+
+namespace Unity.Netcode.GameObjects.EditorTests
+{
+    /// <summary>
+    /// Validates the <see cref="NetcodeConfig"/> values NGO drives in hybrid mode.
+    /// </summary>
+    internal class HybridNetcodeDefaultsTests
+    {
+        // Stands in for a value the user chose. Far enough from SnapshotPacketSize that a partial apply cannot
+        // look like a pass.
+        private const int k_UserPacketSize = 9000;
+
+        private NetcodeConfig m_Config;
+
+        [SetUp]
+        public void SetUp()
+        {
+            m_Config = ScriptableObject.CreateInstance<NetcodeConfig>();
+            m_Config.Reset();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            Object.DestroyImmediate(m_Config);
+        }
+
+        [TestCase(30u)]
+        [TestCase(60u)]
+        public void ApplyTickRateLocksSimulationAndNetworkRates(uint tickRate)
+        {
+            Assert.IsTrue(HybridNetcodeDefaults.ApplyTickRate(m_Config, tickRate), "The first apply should report a change.");
+            Assert.AreEqual((int)tickRate, m_Config.ClientServerTickRate.SimulationTickRate, "SimulationTickRate should be the requested rate.");
+            Assert.AreEqual((int)tickRate, m_Config.ClientServerTickRate.NetworkTickRate, "NetworkTickRate should track SimulationTickRate.");
+
+            Assert.IsFalse(HybridNetcodeDefaults.ApplyTickRate(m_Config, tickRate), "Re-applying the same rate should report no change.");
+        }
+
+        [Test]
+        public void ApplySnapshotPacketSizeOverridesTheNetcodeForEntitiesDefault()
+        {
+            // Zero is N4E's default and means one MTU, which round-robins well below the tick rate at the instance
+            // counts NGO projects run.
+            m_Config.GhostSendSystemData.DefaultSnapshotPacketSize = 0;
+
+            Assert.IsTrue(HybridNetcodeDefaults.ApplySnapshotPacketSize(m_Config), "The first apply should report a change.");
+            Assert.AreEqual(HybridNetcodeDefaults.SnapshotPacketSize, m_Config.GhostSendSystemData.DefaultSnapshotPacketSize, "DefaultSnapshotPacketSize should be the NGO value.");
+
+            Assert.IsFalse(HybridNetcodeDefaults.ApplySnapshotPacketSize(m_Config), "Re-applying an unchanged config should report no change.");
+        }
+
+        [Test]
+        public void ApplySnapshotPacketSizeLeavesTheTickRatesAlone()
+        {
+            HybridNetcodeDefaults.ApplyTickRate(m_Config, 60);
+            m_Config.GhostSendSystemData.DefaultSnapshotPacketSize = k_UserPacketSize;
+
+            HybridNetcodeDefaults.ApplySnapshotPacketSize(m_Config);
+            Assert.AreEqual(60, m_Config.ClientServerTickRate.SimulationTickRate, "The snapshot size pass should leave SimulationTickRate alone.");
+            Assert.AreEqual(60, m_Config.ClientServerTickRate.NetworkTickRate, "The snapshot size pass should leave NetworkTickRate alone.");
+        }
+
+        [Test]
+        public void IsMissingRequiredDetectsBinaryWorlds()
+        {
+            m_Config.HostWorldModeSelection = NetcodeConfig.HostWorldMode.SingleWorld;
+            Assert.IsFalse(HybridNetcodeDefaults.IsMissingRequired(m_Config, out _), "A single world config should be valid for hybrid mode.");
+
+            m_Config.HostWorldModeSelection = NetcodeConfig.HostWorldMode.BinaryWorlds;
+            Assert.IsTrue(HybridNetcodeDefaults.IsMissingRequired(m_Config, out var reason), "Binary worlds should be reported as invalid.");
+            Assert.That(reason, Does.Contain(nameof(NetcodeConfig.HostWorldModeSelection)), "The reason should name the setting that is wrong.");
+        }
+
+        /// <summary>
+        /// NGO no longer requires the bootstrap setting, because <c>UnifiedBootstrap</c> never delegates to the
+        /// Netcode for Entities bootstrap that reads it.
+        /// </summary>
+        [Test]
+        public void AutomaticBootstrapIsNotRequiredToBeDisabled()
+        {
+            m_Config.HostWorldModeSelection = NetcodeConfig.HostWorldMode.SingleWorld;
+            m_Config.EnableClientServerBootstrap = NetcodeConfig.AutomaticBootstrapSetting.EnableAutomaticBootstrap;
+
+            Assert.IsFalse(HybridNetcodeDefaults.IsMissingRequired(m_Config, out _), "Automatic bootstrapping should no longer block hybrid mode.");
+        }
+
+        [Test]
+        public void SnapshotPacketSizeIsOptOutThroughNetworkConfig()
+        {
+            Assert.IsTrue(new NetworkConfig().AutoConfigureSnapshotSize, "The snapshot size should be configured by default, with an opt out.");
+        }
+    }
+}
+#endif

com.unity.netcode.gameobjects/Tests/Editor/HybridNetcodeDefaultsTests.cs

@@ -35,6 +35,11 @@
             "expression": "",
             "define": "MULTIPLAYER_TOOLS"
         },
+        {
+            "name": "com.unity.netcode",
+            "expression": "7.0.0",
+            "define": "UNIFIED_NETCODE_7_0_0"
+        },
         {
             "name": "Unity",
             "expression": "6000.1.0a1",