styly-netsync-server 0.11.0__tar.gz → 0.12.0__tar.gz

{styly_netsync_server-0.11.0 → styly_netsync_server-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: styly-netsync-server
-Version: 0.11.0
+Version: 0.12.0
 Summary: STYLY NetSync Server - Multiplayer framework for Location-Based Entertainment VR/MR experiences
 Author-email: "STYLY, Inc." <info@styly.inc>
 License-Expression: Apache-2.0
@@ -81,14 +81,16 @@ styly-netsync-simulator --server tcp://localhost --room my_room --clients 50
 
 ## Wire protocol compatibility
 
-- Current transform wire protocol is `protocolVersion = 4`.
-- Transform messages use `MSG_CLIENT_POSE` (11) and `MSG_ROOM_POSE` (12) with the compact V4 pose body.
-- v4 vs. v3: `xrOriginDelta` carries a Y component as a 4th `int16` (`dx, dy, dz, dyaw` = 8 bytes vs. v3's 6), so receivers can reconstruct the sender's rig-Y motion (e.g. elevators).
+- Current transform wire protocol is `protocolVersion = 5`.
+- Transform messages use `MSG_CLIENT_POSE` (11) and `MSG_ROOM_POSE` (12) with the compact V5 pose body.
+- v5 adds an optional `MovingFloorLocal` pose flag. Bound avatars send head, hands, and virtual transforms in the registered moving floor's local coordinates, and reuse the existing 8-byte physical slot as direct physical position/yaw.
+- Unbound v5 poses keep the v4 `xrOriginDelta` semantics: `xrOriginDelta` carries a Y component as a 4th `int16` (`dx, dy, dz, dyaw` = 8 bytes vs. v3's 6), so receivers can reconstruct the sender's rig-Y motion.
 - Legacy transform protocols (v2/v3) and JSON transform fallback are not supported.
 - Deploy Unity and Python updates together when changing transform protocol behavior.
-- Protocol v4 position quantization ranges:
+- Protocol v5 position quantization ranges:
   - Absolute (`headPosAbs` only): signed `int24` at `0.01 m` per unit, per-axis range `[-83,886.08 m, 83,886.07 m]`.
-  - XROrigin locomotion delta (`xrOriginDelta`, 4×`int16`: `dx, dy, dz, dyaw`): `0.01 m` per unit for translation, `0.1°` for yaw. Receivers reconstruct `physicalPos = invDeltaRot * (headPos − deltaPos)`; it is not on the wire as a separate absolute field.
+  - XROrigin locomotion delta for unbound poses (`xrOriginDelta`, 4×`int16`: `dx, dy, dz, dyaw`): `0.01 m` per unit for translation, `0.1°` for yaw. Receivers reconstruct `physicalPos = invDeltaRot * (headPos − deltaPos)`; it is not on the wire as a separate absolute field.
+  - Direct physical payload for moving-floor-local poses (`physical`, 4×`int16`: `x, y, z, yaw`): `0.01 m` per unit for translation, `0.1°` for yaw.
   - Head-relative (`right/left/virtual`): signed `int16` at `0.005 m` per unit, per-axis range `[-163.84 m, 163.835 m]`.
 - These are encoding limits, not a hard world-size cap. Worlds can be larger, but encoded axis values are clamped if they exceed the representable range.
 
@@ -96,7 +98,7 @@ styly-netsync-simulator --server tcp://localhost --room my_room --clients 50
 
 The following options summarize trade-offs when expanding absolute-position range.
 
-Assumed baseline (`protocolVersion=4`):
+Assumed unbound baseline (`protocolVersion=5`, `MovingFloorLocal` off):
 - Client pose body with `Physical+Head+Right+Left` valid and `virtualCount=0`: `46 bytes` (matches `test_client_body_size_with_full_pose_no_virtuals`).
 - Room per-client entry (`clientNo + poseTime + clientBody`): `56 bytes`.
 

{styly_netsync_server-0.11.0 → styly_netsync_server-0.12.0}/README.md

@@ -42,14 +42,16 @@ styly-netsync-simulator --server tcp://localhost --room my_room --clients 50
 
 ## Wire protocol compatibility
 
-- Current transform wire protocol is `protocolVersion = 4`.
-- Transform messages use `MSG_CLIENT_POSE` (11) and `MSG_ROOM_POSE` (12) with the compact V4 pose body.
-- v4 vs. v3: `xrOriginDelta` carries a Y component as a 4th `int16` (`dx, dy, dz, dyaw` = 8 bytes vs. v3's 6), so receivers can reconstruct the sender's rig-Y motion (e.g. elevators).
+- Current transform wire protocol is `protocolVersion = 5`.
+- Transform messages use `MSG_CLIENT_POSE` (11) and `MSG_ROOM_POSE` (12) with the compact V5 pose body.
+- v5 adds an optional `MovingFloorLocal` pose flag. Bound avatars send head, hands, and virtual transforms in the registered moving floor's local coordinates, and reuse the existing 8-byte physical slot as direct physical position/yaw.
+- Unbound v5 poses keep the v4 `xrOriginDelta` semantics: `xrOriginDelta` carries a Y component as a 4th `int16` (`dx, dy, dz, dyaw` = 8 bytes vs. v3's 6), so receivers can reconstruct the sender's rig-Y motion.
 - Legacy transform protocols (v2/v3) and JSON transform fallback are not supported.
 - Deploy Unity and Python updates together when changing transform protocol behavior.
-- Protocol v4 position quantization ranges:
+- Protocol v5 position quantization ranges:
   - Absolute (`headPosAbs` only): signed `int24` at `0.01 m` per unit, per-axis range `[-83,886.08 m, 83,886.07 m]`.
-  - XROrigin locomotion delta (`xrOriginDelta`, 4×`int16`: `dx, dy, dz, dyaw`): `0.01 m` per unit for translation, `0.1°` for yaw. Receivers reconstruct `physicalPos = invDeltaRot * (headPos − deltaPos)`; it is not on the wire as a separate absolute field.
+  - XROrigin locomotion delta for unbound poses (`xrOriginDelta`, 4×`int16`: `dx, dy, dz, dyaw`): `0.01 m` per unit for translation, `0.1°` for yaw. Receivers reconstruct `physicalPos = invDeltaRot * (headPos − deltaPos)`; it is not on the wire as a separate absolute field.
+  - Direct physical payload for moving-floor-local poses (`physical`, 4×`int16`: `x, y, z, yaw`): `0.01 m` per unit for translation, `0.1°` for yaw.
   - Head-relative (`right/left/virtual`): signed `int16` at `0.005 m` per unit, per-axis range `[-163.84 m, 163.835 m]`.
 - These are encoding limits, not a hard world-size cap. Worlds can be larger, but encoded axis values are clamped if they exceed the representable range.
 
@@ -57,7 +59,7 @@ styly-netsync-simulator --server tcp://localhost --room my_room --clients 50
 
 The following options summarize trade-offs when expanding absolute-position range.
 
-Assumed baseline (`protocolVersion=4`):
+Assumed unbound baseline (`protocolVersion=5`, `MovingFloorLocal` off):
 - Client pose body with `Physical+Head+Right+Left` valid and `virtualCount=0`: `46 bytes` (matches `test_client_body_size_with_full_pose_no_virtuals`).
 - Room per-client entry (`clientNo + poseTime + clientBody`): `56 bytes`.
 

{styly_netsync_server-0.11.0 → styly_netsync_server-0.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "styly-netsync-server"
-version = "0.11.0"
+version = "0.12.0"
 description = "STYLY NetSync Server - Multiplayer framework for Location-Based Entertainment VR/MR experiences"
 readme = "README.md"
 requires-python = ">=3.11"

{styly_netsync_server-0.11.0 → styly_netsync_server-0.12.0}/src/styly_netsync/binary_serializer.py

@@ -6,7 +6,7 @@ from typing import Any
 logger = logging.getLogger(__name__)
 
 # Message type identifiers
-PROTOCOL_VERSION = 4
+PROTOCOL_VERSION = 5
 MSG_CLIENT_TRANSFORM = 1
 MSG_ROOM_TRANSFORM = 2  # Legacy room transform with short IDs only
 MSG_RPC = 3  # Remote procedure call
@@ -32,7 +32,7 @@ MSG_OBJECT_OWNERSHIP_REJECTED = 17  # Server → Client (ROUTER): request reject
 _max_virtual_transforms = 50
 MAX_VIRTUAL_TRANSFORMS = _max_virtual_transforms  # Legacy alias for backward compat
 
-# Protocol v4 transform encoding constants
+# Protocol v5 transform encoding constants
 ABS_POS_SCALE = 0.01
 LOCO_POS_SCALE = 0.01
 REL_POS_SCALE = 0.005
@@ -69,6 +69,15 @@ POSE_FLAG_HEAD_VALID = 1 << 2
 POSE_FLAG_RIGHT_VALID = 1 << 3
 POSE_FLAG_LEFT_VALID = 1 << 4
 POSE_FLAG_VIRTUALS_VALID = 1 << 5
+POSE_FLAG_MOVING_FLOOR_LOCAL = 1 << 6
+
+
+def _compute_encoding_flags(flags: int) -> int:
+    """Return pose encoding flags for the sanitized pose flags."""
+    encoding_flags = ENCODING_FLAGS_DEFAULT
+    if flags & POSE_FLAG_MOVING_FLOOR_LOCAL:
+        encoding_flags &= ~ENCODING_PHYSICAL_IS_XRORIGIN_DELTA
+    return encoding_flags & 0xFF
 
 
 def get_max_virtual_transforms() -> int:
@@ -372,7 +381,7 @@ def _create_transform_dict(
 
 
 def _serialize_client_body(buffer: bytearray, client: dict[str, Any]) -> None:
-    """Serialize a client body in protocol v4 compact format."""
+    """Serialize a client body in protocol v5 compact format."""
     pose_seq = int(client.get("poseSeq", 0)) & 0xFFFF
     head = client.get("head", {}) or {}
     right = client.get("rightHand", {}) or {}
@@ -411,34 +420,51 @@ def _serialize_client_body(buffer: bytearray, client: dict[str, Any]) -> None:
             POSE_FLAG_RIGHT_VALID | POSE_FLAG_LEFT_VALID | POSE_FLAG_VIRTUALS_VALID
         )
 
+    encoding_flags = _compute_encoding_flags(flags)
     buffer.extend(struct.pack("<H", pose_seq))
     buffer.append(flags)
-    buffer.append(ENCODING_FLAGS_DEFAULT)
+    buffer.append(encoding_flags)
 
     physical_valid = bool(flags & POSE_FLAG_PHYSICAL_VALID)
     head_valid = bool(flags & POSE_FLAG_HEAD_VALID)
     right_valid = head_valid and bool(flags & POSE_FLAG_RIGHT_VALID)
     left_valid = head_valid and bool(flags & POSE_FLAG_LEFT_VALID)
     virtual_valid = head_valid and bool(flags & POSE_FLAG_VIRTUALS_VALID)
+    moving_floor_local = bool(flags & POSE_FLAG_MOVING_FLOOR_LOCAL)
 
     xr_origin_delta_x = float(client.get("xrOriginDeltaX", 0.0))
     xr_origin_delta_y = float(client.get("xrOriginDeltaY", 0.0))
     xr_origin_delta_z = float(client.get("xrOriginDeltaZ", 0.0))
     xr_origin_delta_yaw = float(client.get("xrOriginDeltaYaw", 0.0))
+    physical = client.get("physical", {}) or {}
     head_pos = _transform_get_position(head)
     head_rot = _transform_get_quaternion(head)
     head_rot_n = _normalize_quaternion(*head_rot)
 
     if physical_valid:
-        buffer.extend(
-            struct.pack(
-                "<hhhh",
-                _quantize_signed(xr_origin_delta_x, LOCO_POS_SCALE),
-                _quantize_signed(xr_origin_delta_y, LOCO_POS_SCALE),
-                _quantize_signed(xr_origin_delta_z, LOCO_POS_SCALE),
-                _quantize_signed(xr_origin_delta_yaw, PHYSICAL_YAW_SCALE),
+        if moving_floor_local:
+            physical_pos = _transform_get_position(physical)
+            physical_rot = _transform_get_quaternion(physical)
+            physical_yaw = _quaternion_to_yaw_degrees(*physical_rot)
+            buffer.extend(
+                struct.pack(
+                    "<hhhh",
+                    _quantize_signed(physical_pos[0], LOCO_POS_SCALE),
+                    _quantize_signed(physical_pos[1], LOCO_POS_SCALE),
+                    _quantize_signed(physical_pos[2], LOCO_POS_SCALE),
+                    _quantize_signed(physical_yaw, PHYSICAL_YAW_SCALE),
+                )
+            )
+        else:
+            buffer.extend(
+                struct.pack(
+                    "<hhhh",
+                    _quantize_signed(xr_origin_delta_x, LOCO_POS_SCALE),
+                    _quantize_signed(xr_origin_delta_y, LOCO_POS_SCALE),
+                    _quantize_signed(xr_origin_delta_z, LOCO_POS_SCALE),
+                    _quantize_signed(xr_origin_delta_yaw, PHYSICAL_YAW_SCALE),
+                )
             )
-        )
 
     if head_valid:
         _pack_int24_le(buffer, _quantize_signed_int24(head_pos[0], ABS_POS_SCALE))
@@ -852,7 +878,7 @@ def deserialize(data: bytes) -> tuple[int, dict[str, Any] | None, bytes]:
 
 
 def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any], int]:
-    """Deserialize protocol v4 compact pose body."""
+    """Deserialize protocol v5 compact pose body."""
     result: dict[str, Any] = {}
     result["poseSeq"] = struct.unpack("<H", data[offset : offset + 2])[0]
     offset += 2
@@ -868,11 +894,18 @@ def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any],
     right_valid = head_valid and bool(flags & POSE_FLAG_RIGHT_VALID)
     left_valid = head_valid and bool(flags & POSE_FLAG_LEFT_VALID)
     virtual_valid = head_valid and bool(flags & POSE_FLAG_VIRTUALS_VALID)
+    moving_floor_local = bool(flags & POSE_FLAG_MOVING_FLOOR_LOCAL)
 
     physical = _create_transform_dict(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, True)
-    head = _create_transform_dict(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, False)
-    right = _create_transform_dict(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, False)
-    left = _create_transform_dict(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, False)
+    head = _create_transform_dict(
+        0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, moving_floor_local
+    )
+    right = _create_transform_dict(
+        0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, moving_floor_local
+    )
+    left = _create_transform_dict(
+        0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, moving_floor_local
+    )
 
     head_pos = (0.0, 0.0, 0.0)
     head_rot = (0.0, 0.0, 0.0, 1.0)
@@ -882,15 +915,19 @@ def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any],
     xr_origin_delta_yaw = 0.0
 
     if physical_valid:
-        if (encoding_flags & ENCODING_PHYSICAL_IS_XRORIGIN_DELTA) == 0:
+        if (
+            not moving_floor_local
+            and (encoding_flags & ENCODING_PHYSICAL_IS_XRORIGIN_DELTA) == 0
+        ):
             raise ValueError(
                 "PhysicalValid set but XROrigin delta encoding flag is missing"
             )
         dx_q, dy_q, dz_q, dyaw_q = struct.unpack("<hhhh", data[offset : offset + 8])
-        xr_origin_delta_x = _dequantize_signed(dx_q, LOCO_POS_SCALE)
-        xr_origin_delta_y = _dequantize_signed(dy_q, LOCO_POS_SCALE)
-        xr_origin_delta_z = _dequantize_signed(dz_q, LOCO_POS_SCALE)
-        xr_origin_delta_yaw = _dequantize_signed(dyaw_q, PHYSICAL_YAW_SCALE)
+        if not moving_floor_local:
+            xr_origin_delta_x = _dequantize_signed(dx_q, LOCO_POS_SCALE)
+            xr_origin_delta_y = _dequantize_signed(dy_q, LOCO_POS_SCALE)
+            xr_origin_delta_z = _dequantize_signed(dz_q, LOCO_POS_SCALE)
+            xr_origin_delta_yaw = _dequantize_signed(dyaw_q, PHYSICAL_YAW_SCALE)
         offset += 8
 
     if head_valid:
@@ -913,10 +950,29 @@ def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any],
             head_rot[1],
             head_rot[2],
             head_rot[3],
-            False,
+            moving_floor_local,
         )
 
-    if physical_valid and head_valid:
+    if physical_valid and moving_floor_local:
+        physical_pos = (
+            _dequantize_signed(dx_q, LOCO_POS_SCALE),
+            _dequantize_signed(dy_q, LOCO_POS_SCALE),
+            _dequantize_signed(dz_q, LOCO_POS_SCALE),
+        )
+        physical_rot = _yaw_degrees_to_quaternion(
+            _dequantize_signed(dyaw_q, PHYSICAL_YAW_SCALE)
+        )
+        physical = _create_transform_dict(
+            physical_pos[0],
+            physical_pos[1],
+            physical_pos[2],
+            physical_rot[0],
+            physical_rot[1],
+            physical_rot[2],
+            physical_rot[3],
+            True,
+        )
+    elif physical_valid and head_valid:
         translated_x = head_pos[0] - xr_origin_delta_x
         translated_y = head_pos[1] - xr_origin_delta_y
         translated_z = head_pos[2] - xr_origin_delta_z
@@ -970,7 +1026,7 @@ def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any],
             abs_rot[1],
             abs_rot[2],
             abs_rot[3],
-            False,
+            moving_floor_local,
         )
 
     if left_valid:
@@ -999,7 +1055,7 @@ def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any],
             abs_rot[1],
             abs_rot[2],
             abs_rot[3],
-            False,
+            moving_floor_local,
         )
 
     virtual_count = data[offset]
@@ -1041,7 +1097,7 @@ def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any],
                     abs_rot[1],
                     abs_rot[2],
                     abs_rot[3],
-                    False,
+                    moving_floor_local,
                 )
             )
 
@@ -1058,7 +1114,7 @@ def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any],
 
 
 def _deserialize_client_transform(data: bytes, offset: int) -> dict[str, Any]:
-    """Deserialize client pose (v4) from binary data."""
+    """Deserialize client pose (v5) from binary data."""
     result: dict[str, Any] = {}
 
     protocol_version = data[offset]
@@ -1096,7 +1152,7 @@ def _deserialize_rpc_message(data: bytes, offset: int) -> dict[str, Any]:
 
 
 def _deserialize_room_transform(data: bytes, offset: int) -> dict[str, Any]:
-    """Deserialize room pose (v4) with client numbers only."""
+    """Deserialize room pose (v5) with client numbers only."""
     result: dict[str, Any] = {}
 
     protocol_version = data[offset]

{styly_netsync_server-0.11.0 → styly_netsync_server-0.12.0}/src/styly_netsync/server.py

@@ -1056,7 +1056,7 @@ class NetSyncServer:
                         except UnicodeDecodeError as e:
                             logger.error(f"Failed to decode room ID: {e}")
                             continue
-                        # Protocol v4 binary-only handling (no JSON fallback)
+                        # Protocol v5 binary-only handling (no JSON fallback)
                         try:
                             msg_type, data, raw_payload = binary_serializer.deserialize(
                                 message_bytes
@@ -1127,7 +1127,7 @@ class NetSyncServer:
                                 logger.warning(f"Unknown binary msg_type: {msg_type}")
                         except Exception as e:
                             logger.warning(
-                                "Failed to decode protocol v4 message from room %s: %s",
+                                "Failed to decode protocol v5 message from room %s: %s",
                                 room_id,
                                 e,
                             )

{styly_netsync_server-0.11.0 → styly_netsync_server-0.12.0}/src/styly_netsync_server.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: styly-netsync-server
-Version: 0.11.0
+Version: 0.12.0
 Summary: STYLY NetSync Server - Multiplayer framework for Location-Based Entertainment VR/MR experiences
 Author-email: "STYLY, Inc." <info@styly.inc>
 License-Expression: Apache-2.0
@@ -81,14 +81,16 @@ styly-netsync-simulator --server tcp://localhost --room my_room --clients 50
 
 ## Wire protocol compatibility
 
-- Current transform wire protocol is `protocolVersion = 4`.
-- Transform messages use `MSG_CLIENT_POSE` (11) and `MSG_ROOM_POSE` (12) with the compact V4 pose body.
-- v4 vs. v3: `xrOriginDelta` carries a Y component as a 4th `int16` (`dx, dy, dz, dyaw` = 8 bytes vs. v3's 6), so receivers can reconstruct the sender's rig-Y motion (e.g. elevators).
+- Current transform wire protocol is `protocolVersion = 5`.
+- Transform messages use `MSG_CLIENT_POSE` (11) and `MSG_ROOM_POSE` (12) with the compact V5 pose body.
+- v5 adds an optional `MovingFloorLocal` pose flag. Bound avatars send head, hands, and virtual transforms in the registered moving floor's local coordinates, and reuse the existing 8-byte physical slot as direct physical position/yaw.
+- Unbound v5 poses keep the v4 `xrOriginDelta` semantics: `xrOriginDelta` carries a Y component as a 4th `int16` (`dx, dy, dz, dyaw` = 8 bytes vs. v3's 6), so receivers can reconstruct the sender's rig-Y motion.
 - Legacy transform protocols (v2/v3) and JSON transform fallback are not supported.
 - Deploy Unity and Python updates together when changing transform protocol behavior.
-- Protocol v4 position quantization ranges:
+- Protocol v5 position quantization ranges:
   - Absolute (`headPosAbs` only): signed `int24` at `0.01 m` per unit, per-axis range `[-83,886.08 m, 83,886.07 m]`.
-  - XROrigin locomotion delta (`xrOriginDelta`, 4×`int16`: `dx, dy, dz, dyaw`): `0.01 m` per unit for translation, `0.1°` for yaw. Receivers reconstruct `physicalPos = invDeltaRot * (headPos − deltaPos)`; it is not on the wire as a separate absolute field.
+  - XROrigin locomotion delta for unbound poses (`xrOriginDelta`, 4×`int16`: `dx, dy, dz, dyaw`): `0.01 m` per unit for translation, `0.1°` for yaw. Receivers reconstruct `physicalPos = invDeltaRot * (headPos − deltaPos)`; it is not on the wire as a separate absolute field.
+  - Direct physical payload for moving-floor-local poses (`physical`, 4×`int16`: `x, y, z, yaw`): `0.01 m` per unit for translation, `0.1°` for yaw.
   - Head-relative (`right/left/virtual`): signed `int16` at `0.005 m` per unit, per-axis range `[-163.84 m, 163.835 m]`.
 - These are encoding limits, not a hard world-size cap. Worlds can be larger, but encoded axis values are clamped if they exceed the representable range.
 
@@ -96,7 +98,7 @@ styly-netsync-simulator --server tcp://localhost --room my_room --clients 50
 
 The following options summarize trade-offs when expanding absolute-position range.
 
-Assumed baseline (`protocolVersion=4`):
+Assumed unbound baseline (`protocolVersion=5`, `MovingFloorLocal` off):
 - Client pose body with `Physical+Head+Right+Left` valid and `virtualCount=0`: `46 bytes` (matches `test_client_body_size_with_full_pose_no_virtuals`).
 - Room per-client entry (`clientNo + poseTime + clientBody`): `56 bytes`.
 

{styly_netsync_server-0.11.0 → styly_netsync_server-0.12.0}/tests/test_binary_serializer.py

@@ -288,12 +288,12 @@ def _reconstruct_physical_from_head_and_delta(
     return (px, ty, pz), physical_rot
 
 
-class TestTransformSerializationV4:
-    """Tests for protocol v4 transform compact serialization."""
+class TestTransformSerializationV5:
+    """Tests for protocol v5 transform compact serialization."""
 
-    def test_protocol_version_is_v4(self) -> None:
-        """Protocol version constant should be at v4."""
-        assert binary_serializer.PROTOCOL_VERSION == 4
+    def test_protocol_version_is_v5(self) -> None:
+        """Protocol version constant should be at v5."""
+        assert binary_serializer.PROTOCOL_VERSION == 5
 
     def test_client_roundtrip_without_flags_infers_valid_bits(self) -> None:
         """Serializer should infer valid bits when flags are omitted."""
@@ -418,7 +418,7 @@ class TestTransformSerializationV4:
 
             assert msg_type == binary_serializer.MSG_CLIENT_POSE
             assert decoded is not None
-            assert decoded["protocolVersion"] == 4
+            assert decoded["protocolVersion"] == 5
             assert len(raw) > 0
 
             o_head = original["head"]
@@ -615,7 +615,7 @@ class TestTransformSerializationV4:
         assert abs(decoded["xrOriginDeltaYaw"] - 179.9) <= 0.1
 
     def test_client_body_size_with_full_pose_no_virtuals(self) -> None:
-        """Full pose body (no virtuals) should match current protocol v4 byte size."""
+        """Full pose body (no virtuals) should match current protocol byte size."""
         payload = {
             "deviceId": "size-check",
             "poseSeq": 1,
@@ -638,11 +638,142 @@ class TestTransformSerializationV4:
         _, _, raw = binary_serializer.deserialize(
             binary_serializer.serialize_client_transform(payload)
         )
-        # v4 added a Y component to xrOriginDelta (+2 bytes vs. v3's 44).
         assert len(raw) == 46
 
+    def test_moving_floor_local_body_size_matches_unbound(self) -> None:
+        """Moving-floor-local pose should not add bytes to the pose body."""
+        rng = random.Random(4242)
+        unbound = _build_random_client_pose(rng, virtual_count=0)
+        unbound["flags"] = (
+            binary_serializer.POSE_FLAG_PHYSICAL_VALID
+            | binary_serializer.POSE_FLAG_HEAD_VALID
+            | binary_serializer.POSE_FLAG_RIGHT_VALID
+            | binary_serializer.POSE_FLAG_LEFT_VALID
+        )
+        bound = dict(unbound)
+        bound["flags"] = (
+            unbound["flags"] | binary_serializer.POSE_FLAG_MOVING_FLOOR_LOCAL
+        )
+        bound["physical"] = _build_transform(
+            (0.15, 1.62, -0.08),
+            (
+                0.0,
+                math.sin(math.radians(35.0) * 0.5),
+                0.0,
+                math.cos(math.radians(35.0) * 0.5),
+            ),
+        )
+
+        _, _, unbound_raw = binary_serializer.deserialize(
+            binary_serializer.serialize_client_transform(unbound)
+        )
+        _, _, bound_raw = binary_serializer.deserialize(
+            binary_serializer.serialize_client_transform(bound)
+        )
+
+        assert len(unbound_raw) == 46
+        assert len(bound_raw) == len(unbound_raw)
+
+    def test_moving_floor_local_roundtrip_uses_direct_physical(self) -> None:
+        """Bound poses use direct physical pose and keep head-relative channels intact."""
+        physical_yaw = 42.0
+        physical_rot = (
+            0.0,
+            math.sin(math.radians(physical_yaw) * 0.5),
+            0.0,
+            math.cos(math.radians(physical_yaw) * 0.5),
+        )
+        payload = {
+            "deviceId": "floor-local",
+            "poseSeq": 313,
+            "flags": (
+                binary_serializer.POSE_FLAG_PHYSICAL_VALID
+                | binary_serializer.POSE_FLAG_HEAD_VALID
+                | binary_serializer.POSE_FLAG_RIGHT_VALID
+                | binary_serializer.POSE_FLAG_LEFT_VALID
+                | binary_serializer.POSE_FLAG_VIRTUALS_VALID
+                | binary_serializer.POSE_FLAG_MOVING_FLOOR_LOCAL
+            ),
+            "xrOriginDeltaX": 99.0,
+            "xrOriginDeltaY": 99.0,
+            "xrOriginDeltaZ": 99.0,
+            "xrOriginDeltaYaw": 99.0,
+            "physical": _build_transform((0.25, 1.7, -0.1), physical_rot),
+            "head": _build_transform(
+                (2.0, 3.0, 4.0), _random_unit_quaternion(random.Random(501))
+            ),
+            "rightHand": _build_transform(
+                (2.35, 2.8, 4.1), _random_unit_quaternion(random.Random(502))
+            ),
+            "leftHand": _build_transform(
+                (1.65, 2.8, 3.9), _random_unit_quaternion(random.Random(503))
+            ),
+            "virtuals": [
+                _build_transform(
+                    (2.0, 3.3, 4.7), _random_unit_quaternion(random.Random(504))
+                )
+            ],
+        }
+
+        _, decoded, _ = binary_serializer.deserialize(
+            binary_serializer.serialize_client_transform(payload)
+        )
+        assert decoded is not None
+        assert decoded["flags"] & binary_serializer.POSE_FLAG_MOVING_FLOOR_LOCAL
+        assert (
+            decoded["encodingFlags"]
+            & binary_serializer.ENCODING_PHYSICAL_IS_XRORIGIN_DELTA
+        ) == 0
+        assert decoded["xrOriginDeltaX"] == 0.0
+        assert decoded["xrOriginDeltaY"] == 0.0
+        assert decoded["xrOriginDeltaZ"] == 0.0
+        assert decoded["xrOriginDeltaYaw"] == 0.0
+
+        assert abs(decoded["physical"]["posX"] - 0.25) <= 0.01
+        assert abs(decoded["physical"]["posY"] - 1.7) <= 0.01
+        assert abs(decoded["physical"]["posZ"] + 0.1) <= 0.01
+        decoded_physical_yaw = _yaw_deg_from_quaternion(
+            (
+                decoded["physical"]["rotX"],
+                decoded["physical"]["rotY"],
+                decoded["physical"]["rotZ"],
+                decoded["physical"]["rotW"],
+            )
+        )
+        assert abs(decoded_physical_yaw - physical_yaw) <= 0.1
+
+        src_head = payload["head"]
+        dst_head = decoded["head"]
+        assert abs(dst_head["posX"] - src_head["posX"]) <= 0.01
+        assert abs(dst_head["posY"] - src_head["posY"]) <= 0.01
+        assert abs(dst_head["posZ"] - src_head["posZ"]) <= 0.01
+
+        src_right = payload["rightHand"]
+        dst_right = decoded["rightHand"]
+        assert (
+            abs(
+                (dst_right["posX"] - dst_head["posX"])
+                - (src_right["posX"] - src_head["posX"])
+            )
+            <= 0.005
+        )
+        assert (
+            abs(
+                (dst_right["posY"] - dst_head["posY"])
+                - (src_right["posY"] - src_head["posY"])
+            )
+            <= 0.005
+        )
+        assert (
+            abs(
+                (dst_right["posZ"] - dst_head["posZ"])
+                - (src_right["posZ"] - src_head["posZ"])
+            )
+            <= 0.005
+        )
+
     def test_physical_requires_delta_encoding_flag(self) -> None:
-        """PhysicalValid frames must carry the XROrigin-delta encoding bit."""
+        """Unbound PhysicalValid frames must carry the XROrigin-delta encoding bit."""
         payload = {
             "deviceId": "missing-delta-flag",
             "poseSeq": 7,
@@ -682,7 +813,7 @@ class TestTransformSerializationV4:
         c2["poseTime"] = 223.456
 
         room_payload = {
-            "roomId": "room-v4",
+            "roomId": "room-v5",
             "broadcastTime": 999.123,
             "clients": [c1, c2],
         }
@@ -691,8 +822,8 @@ class TestTransformSerializationV4:
 
         assert msg_type == binary_serializer.MSG_ROOM_POSE
         assert decoded is not None
-        assert decoded["protocolVersion"] == 4
-        assert decoded["roomId"] == "room-v4"
+        assert decoded["protocolVersion"] == 5
+        assert decoded["roomId"] == "room-v5"
         assert len(decoded["clients"]) == 2
 
         for src, dst in zip(room_payload["clients"], decoded["clients"], strict=True):
@@ -705,6 +836,45 @@ class TestTransformSerializationV4:
             assert abs(src_head["posY"] - dst_head["posY"]) <= 0.01
             assert abs(src_head["posZ"] - dst_head["posZ"]) <= 0.01
 
+    def test_room_relay_preserves_moving_floor_local_flag(self) -> None:
+        """Room serialization should preserve moving-floor-local pose bodies."""
+        rng = random.Random(2027)
+        bound = _build_random_client_pose(rng, virtual_count=1)
+        bound["clientNo"] = 303
+        bound["poseTime"] = 333.456
+        bound["flags"] = (
+            int(bound["flags"]) | binary_serializer.POSE_FLAG_MOVING_FLOOR_LOCAL
+        )
+        bound["physical"] = _build_transform(
+            (0.2, 1.65, 0.05),
+            (
+                0.0,
+                math.sin(math.radians(-15.0) * 0.5),
+                0.0,
+                math.cos(math.radians(-15.0) * 0.5),
+            ),
+        )
+
+        encoded = binary_serializer.serialize_room_transform(
+            {
+                "roomId": "room-floor-local",
+                "broadcastTime": 1000.0,
+                "clients": [bound],
+            }
+        )
+        msg_type, decoded, _ = binary_serializer.deserialize(encoded)
+
+        assert msg_type == binary_serializer.MSG_ROOM_POSE
+        assert decoded is not None
+        assert len(decoded["clients"]) == 1
+        client = decoded["clients"][0]
+        assert client["flags"] & binary_serializer.POSE_FLAG_MOVING_FLOOR_LOCAL
+        assert (
+            client["encodingFlags"]
+            & binary_serializer.ENCODING_PHYSICAL_IS_XRORIGIN_DELTA
+        ) == 0
+        assert abs(client["physical"]["posY"] - 1.65) <= 0.01
+
     def test_foot_invariant_head_minus_physical_equals_delta_y(self) -> None:
         """head.y - reconstructed physical.y must equal xrOriginDeltaY.