chore: netcode for entities 7.0.0 as a dependency, unified api behind a define

N4E becomes a hard dependency at 7.0.0, and com.unity.transport moves to 6.5.0 to match it.

N4E 7.0.0 ships its unified API - GhostObject, GhostBehaviour, GhostField - behind
NETCODE_GAMEOBJECT_BRIDGE_EXPERIMENTAL, which leaves those types internal in the configuration
NGO ships. A public type cannot derive from an internal one, so the unified path can no longer key
off the package being present: the UNIFIED_NETCODE versionDefine is removed from the four assembly
definitions and the symbol is set by the project instead, alongside N4E's own define.
NetworkObjectBridge is internal for the same reason, and UnifiedBootstrap raises an #error when
only one of the two defines is set.

With N4E present the two packages share the Unity.Netcode namespace, which breaks three things
outside the unified gates:

- N4E's Netcode facade type shadows the namespace, so 22 XML doc crefs and one nameof that
  qualified with Netcode. stopped resolving.
- N4E declares an INetworkStreamDriverConstructor in the shared root that the enclosing namespace
  finds ahead of NGO's, so the one implementation in the editor tests is fully qualified.
- N4E's source generator errors on an assembly that does not reference N4E, so the editor test
  assembly now references it.

Multiplayer Services 2.3.1 does not compile against N4E 7.0.0 and no fix is published, so it is
dropped from the test project manifests. Validation moves to trunk, the only editor that has
dropped N4E as a core package and can resolve the 7.0.0 request rather than its bundled 6.7.0.

The unified work is preserved and still compiles with both defines set: the N4E 6.7.0 spellings are
updated, and GhostObject.ApplyPostTransformMatrixScale, which N4E removed in its scale rework, is
reimplemented over the new PostTransformMatrix model. The unified CI job sets the defines itself
and is no longer a PR check.

Also disables the serialization tests that fail under CoreCLR so the package is not ejected from
the editor manifest batch.

Parts of this are taken from #4156.

Author: NoelStephensUnity

.yamato/_triggers.yml

@@ -90,7 +90,8 @@ pr_code_changes_checks:
     # Note that our daily tests will anyway run both test configurations in "minimal supported" and "trunk" configurations
     - .yamato/desktop-standalone-tests.yml#desktop_standalone_test_testproject_ubuntu_il2cpp_{{ pinnedTrunk }}
     - .yamato/cmb-service-standalone-tests.yml#cmb_service_standalone_test_testproject_ubuntu_il2cpp_{{ pinnedTrunk }}
-    - .yamato/_run-all.yml#run_all_unified_tests
+    # The unified (NGO + N4E) tests are no longer a PR check: the unified API is behind N4E's own
+    # experimental define, so it is not part of what NGO ships. Still run nightly and on "/ci unified".
     # Run code coverage test (PRs use the pinned "safe" trunk)
     - .yamato/code-coverage.yml#code_coverage_project_test_testproject_ubuntu_{{ pinnedTrunk }}
   triggers:

.yamato/project.metafile

@@ -175,16 +175,19 @@ test_platforms:
 # Editors to be used for testing. NGOv3.X official support started from 6000.7 editor
 # TODO: When a new editor will be released it should be added to this list
 
+# TEMPORARY: only trunk has dropped Netcode for Entities as a core package, so only there does the
+# com.unity.netcode 7.0.0 dependency resolve - a released editor's bundled 6.7.0 wins over the request.
+# Restore the released editors here once one ships without it. `all` is left alone as the reminder.
 validation_editors:
     default:
-        - 6000.7
+        - trunk
     all:
         - 6000.7.0a6
         - 6000.7
         - trunk
         - 1d47644d0e359a8139ae6f99217da3c4e47f4779
     minimal:
-        - 6000.7.0a6
+        - trunk
 pinnedTrunk:  1d47644d0e359a8139ae6f99217da3c4e47f4779
 
 

.yamato/unified-tests.yml

@@ -10,9 +10,10 @@
     # 2. For all unified editors (currently a single pinned alpha, see project.metafile)
 
 # QUALITY CONSIDERATIONS--------------------------------------------------------------------
-  # TODO: the manifest swap means testproject/Packages/manifest-unified.json has to be kept in sync
-  #       with manifest.json by hand. Revisit once N4E is a hard dependency of NGO and one manifest
-  #       can cover both cases.
+  # TODO: N4E is now a hard dependency, so the manifest swap only pins the N4E version and the two
+  #       manifests can be collapsed into one.
+  # This job is deliberately not part of the PR checks: N4E 7.0.0 ships the unified API behind its own
+  #       experimental define, so nothing in the shipping configuration compiles it.
 
 #------------------------------------------------------------------------------------
 
@@ -36,9 +37,11 @@ unified_test_{{ project.name }}_{{ platform.name }}_{{ editor }}:
     UNIFIED_TESTS: "true"
 
   commands:
-    # Swap in the manifest that has the unified packages and versions required.
-    # Without the N4E package, UNIFIED_NETCODE is undefined and the unified API excluded.
+    # Swap in the manifest that pins the N4E version the unified API is written against.
     - cp {{ project.path }}/Packages/manifest-unified.json {{ project.path }}/Packages/manifest.json
+    # Turn the unified API on. UNIFIED_NETCODE is opt-in, and N4E keeps its GameObject bridge internal
+    # until NETCODE_GAMEOBJECT_BRIDGE_EXPERIMENTAL is defined, so both are needed here and nowhere else.
+    - sed -i "s/UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT/UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT;NETCODE_GAMEOBJECT_BRIDGE_EXPERIMENTAL;UNIFIED_NETCODE;OUT_OF_BAND_RPC/" {{ project.path }}/ProjectSettings/ProjectSettings.asset
     - unity-downloader-cli --fast --wait -u {{ editor }} -c Editor
     - UnifiedTestRunner --testproject={{ project.path }} --suite=playmode --artifacts-path=test-results --editor-location=.Editor --rerun-strategy=Test --retry={{ num_test_retries }} --clean-library-on-rerun --timeout={{ test_timeout }}
   artifacts:

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -10,8 +10,12 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 ### Added
 
+- Netcode for Entities (`com.unity.netcode` 7.0.0) is now a dependency, so installing Netcode for GameObjects also brings it, and its own dependencies (Entities, Burst, Collections), into the project.
+
 ### Changed
 
+- The `com.unity.transport` dependency moved from 2.6.0 to 6.5.0, the version Netcode for Entities 7.0.0 requires.
+
 - Changed `NetworkTransform.UseHalfFloatPrecision` to synchronize position with a resolution of approximately 1mm regardless of how far an object has travelled. Previously the resolution could degrade to approximately 3cm. This does not increase bandwidth, but projects using `NetworkTransform.UseUnreliableDeltas` will send full precision position updates more often. (#4129)
 
 - All editor assembly definitions are renamed with `Unity.Netcode.GameObjects.x` variants

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

@@ -1,7 +1,6 @@
 using System.Collections.Generic;
 #if UNIFIED_NETCODE
-using Unity.NetCode;
-using Unity.NetCode.Editor;
+using Unity.Netcode.Editor;
 #endif
 using UnityEditor;
 using UnityEngine;

com.unity.netcode.gameobjects/Editor/Unity.Netcode.Editor.asmdef

@@ -46,11 +46,6 @@
             "expression": "0.2.0",
             "define": "MULTIPLAYER_SERVICES_SDK_INSTALLED"
         },
-        {
-            "name": "com.unity.netcode",
-            "expression": "1.10.1",
-            "define": "UNIFIED_NETCODE"
-        },
         {
             "name": "com.unity.multiplayer.playmode",
             "expression": "0.1.0",

com.unity.netcode.gameobjects/Runtime/Components/AnticipatedNetworkTransform.cs

@@ -21,13 +21,13 @@ namespace Unity.Netcode.Components
     /// resulting in a "snap" to the new value if it is different from the anticipated value.</description></item>
     ///
     /// <item><description><b>Smooth:</b> In this mode (with <see cref="StaleDataHandling"/> set to
-    /// <see cref="Netcode.StaleDataHandling.Ignore"/> and an <see cref="NetworkBehaviour.OnReanticipate"/> callback that calls
+    /// <see cref="StaleDataHandling.Ignore"/> and an <see cref="NetworkBehaviour.OnReanticipate"/> callback that calls
     /// <see cref="Smooth"/> from the anticipated value to the authority value with an appropriate
     /// <see cref="Mathf.Lerp"/>-style smooth function), when a more up-to-date value is received from the authority,
     /// it will interpolate over time from an incorrect anticipated value to the correct authoritative value.</description></item>
     ///
     /// <item><description><b>Constant Reanticipation:</b> In this mode (with <see cref="StaleDataHandling"/> set to
-    /// <see cref="Netcode.StaleDataHandling.Reanticipate"/> and an <see cref="NetworkBehaviour.OnReanticipate"/> that calculates a
+    /// <see cref="StaleDataHandling.Reanticipate"/> and an <see cref="NetworkBehaviour.OnReanticipate"/> that calculates a
     /// new anticipated value based on the current authoritative value), when a more up-to-date value is received from
     /// the authority, user code calculates a new anticipated value, possibly calling <see cref="Smooth"/> to interpolate
     /// between the previous anticipation and the new anticipation. This is useful for values that change frequently and
@@ -101,11 +101,11 @@ private void Reset()
         /// Defines what the behavior should be if we receive a value from the server with an earlier associated
         /// time value than the anticipation time value.
         /// <br/><br/>
-        /// If this is <see cref="Netcode.StaleDataHandling.Ignore"/>, the stale data will be ignored and the authoritative
+        /// If this is <see cref="StaleDataHandling.Ignore"/>, the stale data will be ignored and the authoritative
         /// value will not replace the anticipated value until the anticipation time is reached. <see cref="OnAuthoritativeValueChanged"/>
         /// and <see cref="OnReanticipate"/> will also not be invoked for this stale data.
         /// <br/><br/>
-        /// If this is <see cref="Netcode.StaleDataHandling.Reanticipate"/>, the stale data will replace the anticipated data and
+        /// If this is <see cref="StaleDataHandling.Reanticipate"/>, the stale data will replace the anticipated data and
         /// <see cref="OnAuthoritativeValueChanged"/> and <see cref="OnReanticipate"/> will be invoked.
         /// In this case, the authoritativeTime value passed to <see cref="OnReanticipate"/> will be lower than
         /// the anticipationTime value, and that callback can be used to calculate a new anticipated value.

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

@@ -1,5 +1,6 @@
 #if UNIFIED_NETCODE
-using Unity.NetCode;
+using Unity.Mathematics;
+using Unity.Transforms;
 using UnityEngine;
 
 namespace Unity.Netcode
@@ -13,7 +14,9 @@ namespace Unity.Netcode
 
     [DefaultExecutionOrder(GhostObject.ExecutionOrder + 1)]
     //BREAK --- Fix this on UNIFIED side 1st
-    public partial class NetworkObjectBridge : GhostBehaviour
+    // Internal: GhostBehaviour is only public when NETCODE_GAMEOBJECT_BRIDGE_EXPERIMENTAL is defined, and a public
+    // type cannot derive from an internal one.
+    internal partial class NetworkObjectBridge : GhostBehaviour
     {
         // DefaultExecutionOrder
         // TODO: Define a const for the value used on GhostObject and use that value
@@ -83,5 +86,42 @@ internal void ApplyScale(Vector3 scale)
             Ghost.ApplyPostTransformMatrixScale(scale);
         }
     }
+
+    /// <summary>
+    /// Stands in for N4E's <c>GhostObject.ApplyPostTransformMatrixScale</c>, removed by the 6.7.0 non-uniform
+    /// scale rework that gave the GameObject-to-entity transform sync ownership of the
+    /// <see cref="PostTransformMatrix"/>. Remove this once N4E exposes a supported way to push scale to a ghost.
+    /// </summary>
+    internal static class GhostObjectScaleExtensions
+    {
+        /// <summary>
+        /// A ghost that replicates 3D scale stores it in its <see cref="PostTransformMatrix"/> and holds
+        /// <see cref="LocalTransform.Scale"/> at 1, because consumers multiply the two. A ghost authored with
+        /// <c>UseUniformScale</c> has no matrix - and cannot gain one at runtime, since the component is only in the
+        /// replicated set when the prefab is registered - so only the uniform scale can be applied there.
+        /// </summary>
+        internal static void ApplyPostTransformMatrixScale(this GhostObject ghost, Vector3 scale)
+        {
+            var entityManager = ghost.World.EntityManager;
+            var entity = ghost.Entity;
+            var localTransform = entityManager.GetComponentData<LocalTransform>(entity);
+
+            if (entityManager.HasComponent<PostTransformMatrix>(entity))
+            {
+                entityManager.SetComponentData(entity, new PostTransformMatrix { Value = float4x4.Scale(scale) });
+                localTransform.Scale = 1f;
+            }
+            else
+            {
+                if (!Mathf.Approximately(scale.x, scale.y) || !Mathf.Approximately(scale.y, scale.z))
+                {
+                    Debug.LogWarning($"[{nameof(NetworkObjectBridge)}] Non-uniform scale {scale} cannot be replicated by a ghost authored for uniform scale; applying {scale.x} to all axes.", ghost);
+                }
+                localTransform.Scale = scale.x;
+            }
+
+            entityManager.SetComponentData(entity, localTransform);
+        }
+    }
 }
 #endif

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

@@ -1,7 +1,9 @@
+#if UNIFIED_NETCODE && !NETCODE_GAMEOBJECT_BRIDGE_EXPERIMENTAL
+#error UNIFIED_NETCODE also requires NETCODE_GAMEOBJECT_BRIDGE_EXPERIMENTAL: Netcode for Entities keeps its GameObject bridge (GhostObject, GhostBehaviour, GhostField) internal until that define is set.
+#endif
 #if UNIFIED_NETCODE
 using System;
 using Unity.Entities;
-using Unity.NetCode;
 using UnityEngine;
 
 namespace Unity.Netcode

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

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using Unity.Collections;
 using Unity.Entities;
-using Unity.NetCode;
 using UnityEngine;
 
 namespace Unity.Netcode.Components