update

Applying Paolo's suggested changes.
Improved the comment that was a tad confusing.

Author: NoelStephensUnity

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

@@ -20,6 +20,16 @@ public struct NetworkDeltaPosition : INetworkSerializable
         /// </remarks>
         internal const float MaxDeltaBeforeAdjustment = 2f;
 
+        /// <summary>
+        /// Masks off a half float's sign bit, leaving its magnitude.
+        /// </summary>
+        internal const ushort HalfMagnitudeMask = 0x7FFF;
+
+        /// <summary>
+        /// The bit pattern of the largest finite half float (65504); anything above it is an infinity or a NaN.
+        /// </summary>
+        internal const ushort LargestFiniteHalfBits = 0x7BFF;
+
         /// <summary>
         /// The HalfVector3 used to synchronize the delta in position
         /// </summary>
@@ -162,7 +172,8 @@ public void UpdateFrom(ref Vector3 vector3, int networkTick)
                     HalfVector3.Axis[i] = math.half(DeltaPosition[i]);
                     HalfDeltaConvertedBack[i] = Mathf.HalfToFloat(HalfVector3.Axis[i].value);
 
-                    // Left unchanged when skipped so it is still applied once movement resumes.
+                    // Only recompute the carried loss when it was applied. Leaving it alone otherwise is
+                    // what keeps it around to apply once movement resumes.
                     if (applyPrecisionLoss)
                     {
                         PrecisionLossDelta[i] = DeltaPosition[i] - HalfDeltaConvertedBack[i];
@@ -196,10 +207,10 @@ public void UpdateFrom(ref Vector3 vector3, int networkTick)
         internal static float HalfPrecisionQuantum(float value)
         {
             // The step size is symmetric about zero, so the sign is dropped.
-            var magnitude = (ushort)(math.half(value).value & 0x7FFF);
+            var magnitude = (ushort)(math.half(value).value & HalfMagnitudeMask);
 
-            // Guard only: stepping past the largest finite half float would give infinity.
-            if (magnitude >= 0x7BFF)
+            // Guard only: stepping past this would give infinity.
+            if (magnitude >= LargestFiniteHalfBits)
             {
                 return MaxDeltaBeforeAdjustment;
             }

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

@@ -16,6 +16,13 @@ internal class NetworkDeltaPositionTests
         // Lossy as a half float, and two of them still fit under the collapse threshold.
         private const float k_LossyStep = 0.7f;
 
+        // The largest finite half float.
+        private const float k_LargestFiniteHalf = 65504.0f;
+
+        // Finite, but far enough past the half float range that the conversion itself rounds to infinity,
+        // which reaches the guard by a different path than handing it an infinity outright.
+        private const float k_RoundsToInfinity = 70000.0f;
+
         // Past the threshold and exactly representable, so the collapse cannot hinge on rounding.
         private const float k_CollapsingStep = NetworkDeltaPosition.MaxDeltaBeforeAdjustment + 0.5f;
 
@@ -307,11 +314,9 @@ public void QuantumIsTheSmallestChangeTheEncodingCanSee()
         [Test]
         public void QuantumIsGuardedAtTheTopOfTheRange()
         {
-            // 70000f is the finite one: the conversion itself rounds to infinity, which reaches the guard
-            // by a different path than handing it an infinity outright.
             var values = new[]
             {
-                65504.0f, -65504.0f, 70000.0f,
+                k_LargestFiniteHalf, -k_LargestFiniteHalf, k_RoundsToInfinity,
                 float.PositiveInfinity, float.NegativeInfinity, float.NaN,
             };
 
@@ -328,13 +333,14 @@ public void QuantumIsNeverNonFiniteOrZero()
         {
             // Why the guard exists: an infinite step size would make the "has it moved?" comparison in
             // UpdateFrom false for every input, silently stopping the rounding loss from being applied.
-            var unguarded = Mathf.HalfToFloat(0x7BFF + 1) - Mathf.HalfToFloat(0x7BFF);
+            const ushort topOfRange = NetworkDeltaPosition.LargestFiniteHalfBits;
+            var unguarded = Mathf.HalfToFloat(topOfRange + 1) - Mathf.HalfToFloat(topOfRange);
             Assert.IsTrue(float.IsInfinity(unguarded) || float.IsNaN(unguarded),
                 "The unguarded computation at the top of the range should be non-finite, which is why the guard exists.");
 
             var values = new[]
             {
-                0.0f, float.Epsilon, 1e-7f, 0.5f, 1.0f, 100.0f, 65503.0f, 65504.0f, -65504.0f, 70000.0f,
+                0.0f, float.Epsilon, 1e-7f, 0.5f, 1.0f, 100.0f, 65503.0f, k_LargestFiniteHalf, -k_LargestFiniteHalf, k_RoundsToInfinity,
                 float.PositiveInfinity, float.NegativeInfinity, float.NaN,
             };