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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: styly-netsync-server
-Version: 0.10.3
+Version: 0.11.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,12 +81,14 @@ styly-netsync-simulator --server tcp://localhost --room my_room --clients 50
 
 ## Wire protocol compatibility
 
-- Current transform wire protocol is `protocolVersion = 3`.
-- Transform messages use `MSG_CLIENT_POSE` (11) and `MSG_ROOM_POSE` (12) with the compact V3 pose body.
-- Legacy transform protocol v2 and JSON transform fallback are not supported.
+- 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).
+- Legacy transform protocols (v2/v3) and JSON transform fallback are not supported.
 - Deploy Unity and Python updates together when changing transform protocol behavior.
-- Protocol v3 position quantization ranges:
-  - Absolute (`physicalPos`, `headPosAbs`): signed `int24` at `0.01 m` per unit, per-axis range `[-83,886.08 m, 83,886.07 m]`.
+- Protocol v4 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.
   - 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.
 
@@ -94,18 +96,18 @@ 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=3`):
-- Client pose body with `Physical+Head+Right+Left` valid and `virtualCount=0`: `49 bytes`
-- Room per-client entry (`clientNo + poseTime + clientBody`): `59 bytes`
+Assumed baseline (`protocolVersion=4`):
+- 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`.
 
 | Option | Absolute Position Encoding | Per-axis Range | Client Body Delta | Room Per-client Delta |
 |---|---|---:|---:|---:|
-| A. Coarser scale (current integer width) | `int24 @ 0.02m` | `[-167,772.16m, 167,772.14m]` | `+0B` (`49 -> 49`) | `+0B` (`59 -> 59`) |
-| B. Cell + local | `cell(i16, 256m) + local(int24 @ 0.01m)` | `[-8,472,494.08m, 8,472,238.07m]` | `+6B` (`49 -> 55`, `+12.2%`) | `+6B` (`59 -> 65`, `+10.2%`) |
-| C. Cell + local (large cell) | `cell(i16, 1024m) + local(int24 @ 0.01m)` | `[-33,638,318.08m, 33,637,294.07m]` | `+6B` (`49 -> 55`, `+12.2%`) | `+6B` (`59 -> 65`, `+10.2%`) |
+| A. Coarser scale (current integer width) | `int24 @ 0.02m` | `[-167,772.16m, 167,772.14m]` | `+0B` (`46 -> 46`) | `+0B` (`56 -> 56`) |
+| B. Cell + local | `cell(i16, 256m) + local(int24 @ 0.01m)` | `[-8,472,494.08m, 8,472,238.07m]` | `+6B` (`46 -> 52`, `+13.0%`) | `+6B` (`56 -> 62`, `+10.7%`) |
+| C. Cell + local (large cell) | `cell(i16, 1024m) + local(int24 @ 0.01m)` | `[-33,638,318.08m, 33,637,294.07m]` | `+6B` (`46 -> 52`, `+13.0%`) | `+6B` (`56 -> 62`, `+10.7%`) |
 
 Notes:
-- Option B/C deltas assume both absolute transforms are present (`physicalPos` and `headPosAbs`).
+- Only `headPosAbs` is on the wire as an absolute field; `physicalPos` is reconstructed from `headPosAbs + xrOriginDelta`. Option B/C deltas therefore apply to `headPosAbs` only.
 - Option B/C can reduce average overhead if `cell` is transmitted only when changed, but that requires extra state and flags in the wire format.
 
 ## Configuration
@@ -160,7 +162,7 @@ The server launches an embedded FastAPI application that exposes REST endpoints
 
 ```json
 {
-  "vars": {
+  "variables": {
     "name": "Jack",
     "lang": "EN"
   }
@@ -179,11 +181,35 @@ The server launches an embedded FastAPI application that exposes REST endpoints
 ```bash
 curl -sS -X POST "http://127.0.0.1:8800/v1/rooms/default_room/devices/00000000-0000-0000-0000-000000000000/client-variables" \
   -H "Content-Type: application/json" \
-  -d '{"vars":{"name":"Jack","lang":"EN"}}'
+  -d '{"variables":{"name":"Jack","lang":"EN"}}'
 ```
 
 The response includes the current mapping status (`clientNo` or `null`) and whether each key was `"applied"` or `"queued"`.
 
+- Read endpoints:
+  - `GET /v1/rooms/{roomId}/devices/{deviceId}/client-variables` — returns all client variables for the device.
+
+    ```json
+    {"clientNo": 7, "variables": {"name": "Jack", "lang": "EN"}}
+    ```
+
+    If the device has no `clientNo` mapping yet, returns `{"clientNo": null, "variables": {}}`.
+
+  - `GET /v1/rooms/{roomId}/devices/{deviceId}/client-variables/{name}` — returns a single variable.
+
+    ```json
+    {"clientNo": 7, "value": "Jack"}
+    ```
+
+    Returns `404` if the device is unmapped or the variable is not set.
+
+- Example:
+
+  ```bash
+  curl -sS "http://127.0.0.1:8800/v1/rooms/default_room/devices/00000000-0000-0000-0000-000000000000/client-variables"
+  curl -sS "http://127.0.0.1:8800/v1/rooms/default_room/devices/00000000-0000-0000-0000-000000000000/client-variables/name"
+  ```
+
 ### Global variables
 
 - Endpoint: `POST /v1/rooms/{roomId}/global-variables`
@@ -191,7 +217,7 @@ The response includes the current mapping status (`clientNo` or `null`) and whet
 
 ```json
 {
-  "vars": {
+  "variables": {
     "score": "42",
     "stage": "lobby"
   }
@@ -210,7 +236,33 @@ The response includes the current mapping status (`clientNo` or `null`) and whet
 ```bash
 curl -sS -X POST "http://127.0.0.1:8800/v1/rooms/default_room/global-variables" \
   -H "Content-Type: application/json" \
-  -d '{"vars":{"score":"42","stage":"lobby"}}'
+  -d '{"variables":{"score":"42","stage":"lobby"}}'
 ```
 
 The response includes the room ID and whether each key was `"applied"`, `"queued"`, or `"failed"`.
+
+- Read endpoints:
+  - `GET /v1/rooms/{roomId}/global-variables` — returns all global variables for the room.
+
+    ```json
+    {"variables": {"score": "42", "stage": "lobby"}}
+    ```
+
+  - `GET /v1/rooms/{roomId}/global-variables/{name}` — returns a single variable.
+
+    ```json
+    {"value": "42"}
+    ```
+
+    Returns `404` if the variable is not set.
+
+- Example:
+
+  ```bash
+  curl -sS "http://127.0.0.1:8800/v1/rooms/default_room/global-variables"
+  curl -sS "http://127.0.0.1:8800/v1/rooms/default_room/global-variables/score"
+  ```
+
+### Read consistency
+
+GET endpoints return a snapshot of the REST bridge's in-process cache, which is populated by PUB-SUB broadcasts from the server. The first request to a room lazily creates a bridge and may return an empty snapshot until the initial broadcasts arrive — retry after a short delay if needed.

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

@@ -42,12 +42,14 @@ styly-netsync-simulator --server tcp://localhost --room my_room --clients 50
 
 ## Wire protocol compatibility
 
-- Current transform wire protocol is `protocolVersion = 3`.
-- Transform messages use `MSG_CLIENT_POSE` (11) and `MSG_ROOM_POSE` (12) with the compact V3 pose body.
-- Legacy transform protocol v2 and JSON transform fallback are not supported.
+- 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).
+- Legacy transform protocols (v2/v3) and JSON transform fallback are not supported.
 - Deploy Unity and Python updates together when changing transform protocol behavior.
-- Protocol v3 position quantization ranges:
-  - Absolute (`physicalPos`, `headPosAbs`): signed `int24` at `0.01 m` per unit, per-axis range `[-83,886.08 m, 83,886.07 m]`.
+- Protocol v4 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.
   - 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.
 
@@ -55,18 +57,18 @@ 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=3`):
-- Client pose body with `Physical+Head+Right+Left` valid and `virtualCount=0`: `49 bytes`
-- Room per-client entry (`clientNo + poseTime + clientBody`): `59 bytes`
+Assumed baseline (`protocolVersion=4`):
+- 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`.
 
 | Option | Absolute Position Encoding | Per-axis Range | Client Body Delta | Room Per-client Delta |
 |---|---|---:|---:|---:|
-| A. Coarser scale (current integer width) | `int24 @ 0.02m` | `[-167,772.16m, 167,772.14m]` | `+0B` (`49 -> 49`) | `+0B` (`59 -> 59`) |
-| B. Cell + local | `cell(i16, 256m) + local(int24 @ 0.01m)` | `[-8,472,494.08m, 8,472,238.07m]` | `+6B` (`49 -> 55`, `+12.2%`) | `+6B` (`59 -> 65`, `+10.2%`) |
-| C. Cell + local (large cell) | `cell(i16, 1024m) + local(int24 @ 0.01m)` | `[-33,638,318.08m, 33,637,294.07m]` | `+6B` (`49 -> 55`, `+12.2%`) | `+6B` (`59 -> 65`, `+10.2%`) |
+| A. Coarser scale (current integer width) | `int24 @ 0.02m` | `[-167,772.16m, 167,772.14m]` | `+0B` (`46 -> 46`) | `+0B` (`56 -> 56`) |
+| B. Cell + local | `cell(i16, 256m) + local(int24 @ 0.01m)` | `[-8,472,494.08m, 8,472,238.07m]` | `+6B` (`46 -> 52`, `+13.0%`) | `+6B` (`56 -> 62`, `+10.7%`) |
+| C. Cell + local (large cell) | `cell(i16, 1024m) + local(int24 @ 0.01m)` | `[-33,638,318.08m, 33,637,294.07m]` | `+6B` (`46 -> 52`, `+13.0%`) | `+6B` (`56 -> 62`, `+10.7%`) |
 
 Notes:
-- Option B/C deltas assume both absolute transforms are present (`physicalPos` and `headPosAbs`).
+- Only `headPosAbs` is on the wire as an absolute field; `physicalPos` is reconstructed from `headPosAbs + xrOriginDelta`. Option B/C deltas therefore apply to `headPosAbs` only.
 - Option B/C can reduce average overhead if `cell` is transmitted only when changed, but that requires extra state and flags in the wire format.
 
 ## Configuration
@@ -121,7 +123,7 @@ The server launches an embedded FastAPI application that exposes REST endpoints
 
 ```json
 {
-  "vars": {
+  "variables": {
     "name": "Jack",
     "lang": "EN"
   }
@@ -140,11 +142,35 @@ The server launches an embedded FastAPI application that exposes REST endpoints
 ```bash
 curl -sS -X POST "http://127.0.0.1:8800/v1/rooms/default_room/devices/00000000-0000-0000-0000-000000000000/client-variables" \
   -H "Content-Type: application/json" \
-  -d '{"vars":{"name":"Jack","lang":"EN"}}'
+  -d '{"variables":{"name":"Jack","lang":"EN"}}'
 ```
 
 The response includes the current mapping status (`clientNo` or `null`) and whether each key was `"applied"` or `"queued"`.
 
+- Read endpoints:
+  - `GET /v1/rooms/{roomId}/devices/{deviceId}/client-variables` — returns all client variables for the device.
+
+    ```json
+    {"clientNo": 7, "variables": {"name": "Jack", "lang": "EN"}}
+    ```
+
+    If the device has no `clientNo` mapping yet, returns `{"clientNo": null, "variables": {}}`.
+
+  - `GET /v1/rooms/{roomId}/devices/{deviceId}/client-variables/{name}` — returns a single variable.
+
+    ```json
+    {"clientNo": 7, "value": "Jack"}
+    ```
+
+    Returns `404` if the device is unmapped or the variable is not set.
+
+- Example:
+
+  ```bash
+  curl -sS "http://127.0.0.1:8800/v1/rooms/default_room/devices/00000000-0000-0000-0000-000000000000/client-variables"
+  curl -sS "http://127.0.0.1:8800/v1/rooms/default_room/devices/00000000-0000-0000-0000-000000000000/client-variables/name"
+  ```
+
 ### Global variables
 
 - Endpoint: `POST /v1/rooms/{roomId}/global-variables`
@@ -152,7 +178,7 @@ The response includes the current mapping status (`clientNo` or `null`) and whet
 
 ```json
 {
-  "vars": {
+  "variables": {
     "score": "42",
     "stage": "lobby"
   }
@@ -171,7 +197,33 @@ The response includes the current mapping status (`clientNo` or `null`) and whet
 ```bash
 curl -sS -X POST "http://127.0.0.1:8800/v1/rooms/default_room/global-variables" \
   -H "Content-Type: application/json" \
-  -d '{"vars":{"score":"42","stage":"lobby"}}'
+  -d '{"variables":{"score":"42","stage":"lobby"}}'
 ```
 
 The response includes the room ID and whether each key was `"applied"`, `"queued"`, or `"failed"`.
+
+- Read endpoints:
+  - `GET /v1/rooms/{roomId}/global-variables` — returns all global variables for the room.
+
+    ```json
+    {"variables": {"score": "42", "stage": "lobby"}}
+    ```
+
+  - `GET /v1/rooms/{roomId}/global-variables/{name}` — returns a single variable.
+
+    ```json
+    {"value": "42"}
+    ```
+
+    Returns `404` if the variable is not set.
+
+- Example:
+
+  ```bash
+  curl -sS "http://127.0.0.1:8800/v1/rooms/default_room/global-variables"
+  curl -sS "http://127.0.0.1:8800/v1/rooms/default_room/global-variables/score"
+  ```
+
+### Read consistency
+
+GET endpoints return a snapshot of the REST bridge's in-process cache, which is populated by PUB-SUB broadcasts from the server. The first request to a room lazily creates a bridge and may return an empty snapshot until the initial broadcasts arrive — retry after a short delay if needed.

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "styly-netsync-server"
-version = "0.10.3"
+version = "0.11.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.10.3 → styly_netsync_server-0.11.0}/src/styly_netsync/binary_serializer.py

@@ -6,7 +6,7 @@ from typing import Any
 logger = logging.getLogger(__name__)
 
 # Message type identifiers
-PROTOCOL_VERSION = 3
+PROTOCOL_VERSION = 4
 MSG_CLIENT_TRANSFORM = 1
 MSG_ROOM_TRANSFORM = 2  # Legacy room transform with short IDs only
 MSG_RPC = 3  # Remote procedure call
@@ -19,6 +19,11 @@ MSG_CLIENT_VAR_SET = 9  # Set client variable
 MSG_CLIENT_VAR_SYNC = 10  # Sync client variables
 MSG_CLIENT_POSE = 11
 MSG_ROOM_POSE = 12
+MSG_OBJECT_POSE = 13  # Client → Server: owned object Transform
+MSG_ROOM_OBJECTS = 14  # Server → Clients (PUB): room object states
+MSG_OBJECT_OWNERSHIP_REQUEST = 15  # Client → Server: RequestOwnership/ReleaseOwnership
+MSG_OBJECT_OWNERSHIP_CHANGED = 16  # Server → Clients (ROUTER): ownership changed
+MSG_OBJECT_OWNERSHIP_REJECTED = 17  # Server → Client (ROUTER): request rejected
 
 # Transform data type identifiers (deprecated - kept for reference)
 
@@ -27,7 +32,7 @@ MSG_ROOM_POSE = 12
 _max_virtual_transforms = 50
 MAX_VIRTUAL_TRANSFORMS = _max_virtual_transforms  # Legacy alias for backward compat
 
-# Protocol v3 transform encoding constants
+# Protocol v4 transform encoding constants
 ABS_POS_SCALE = 0.01
 LOCO_POS_SCALE = 0.01
 REL_POS_SCALE = 0.005
@@ -367,7 +372,7 @@ def _create_transform_dict(
 
 
 def _serialize_client_body(buffer: bytearray, client: dict[str, Any]) -> None:
-    """Serialize a client body in protocol v3 compact format."""
+    """Serialize a client body in protocol v4 compact format."""
     pose_seq = int(client.get("poseSeq", 0)) & 0xFFFF
     head = client.get("head", {}) or {}
     right = client.get("rightHand", {}) or {}
@@ -375,6 +380,7 @@ def _serialize_client_body(buffer: bytearray, client: dict[str, Any]) -> None:
     virtuals = client.get("virtuals", []) or []
     has_xr_origin_delta = (
         "xrOriginDeltaX" in client
+        or "xrOriginDeltaY" in client
         or "xrOriginDeltaZ" in client
         or "xrOriginDeltaYaw" in client
     )
@@ -416,6 +422,7 @@ def _serialize_client_body(buffer: bytearray, client: dict[str, Any]) -> None:
     virtual_valid = head_valid and bool(flags & POSE_FLAG_VIRTUALS_VALID)
 
     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))
     head_pos = _transform_get_position(head)
@@ -425,8 +432,9 @@ def _serialize_client_body(buffer: bytearray, client: dict[str, Any]) -> None:
     if physical_valid:
         buffer.extend(
             struct.pack(
-                "<hhh",
+                "<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),
             )
@@ -777,7 +785,10 @@ def deserialize(data: bytes) -> tuple[int, dict[str, Any] | None, bytes]:
     offset += 1
 
     # Validate message type is within valid range
-    if message_type < MSG_CLIENT_TRANSFORM or message_type > MSG_ROOM_POSE:
+    if (
+        message_type < MSG_CLIENT_TRANSFORM
+        or message_type > MSG_OBJECT_OWNERSHIP_REJECTED
+    ):
         # Return invalid message type with None data instead of raising exception
         return message_type, None, b""
 
@@ -806,6 +817,28 @@ def deserialize(data: bytes) -> tuple[int, dict[str, Any] | None, bytes]:
             return message_type, _deserialize_client_var_set(data, offset), b""
         elif message_type == MSG_CLIENT_VAR_SYNC:
             return message_type, _deserialize_client_var_sync(data, offset), b""
+        elif message_type == MSG_OBJECT_POSE:
+            return message_type, _deserialize_object_pose(data, offset), b""
+        elif message_type == MSG_ROOM_OBJECTS:
+            return message_type, _deserialize_room_objects(data, offset), b""
+        elif message_type == MSG_OBJECT_OWNERSHIP_REQUEST:
+            return (
+                message_type,
+                _deserialize_object_ownership_request(data, offset),
+                b"",
+            )
+        elif message_type == MSG_OBJECT_OWNERSHIP_CHANGED:
+            return (
+                message_type,
+                _deserialize_object_ownership_changed(data, offset),
+                b"",
+            )
+        elif message_type == MSG_OBJECT_OWNERSHIP_REJECTED:
+            return (
+                message_type,
+                _deserialize_object_ownership_rejected(data, offset),
+                b"",
+            )
         else:
             # Should not reach here due to validation above
             return message_type, None, b""
@@ -819,7 +852,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 v3 compact pose body."""
+    """Deserialize protocol v4 compact pose body."""
     result: dict[str, Any] = {}
     result["poseSeq"] = struct.unpack("<H", data[offset : offset + 2])[0]
     offset += 2
@@ -844,6 +877,7 @@ def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any],
     head_pos = (0.0, 0.0, 0.0)
     head_rot = (0.0, 0.0, 0.0, 1.0)
     xr_origin_delta_x = 0.0
+    xr_origin_delta_y = 0.0
     xr_origin_delta_z = 0.0
     xr_origin_delta_yaw = 0.0
 
@@ -852,11 +886,12 @@ def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any],
             raise ValueError(
                 "PhysicalValid set but XROrigin delta encoding flag is missing"
             )
-        dx_q, dz_q, dyaw_q = struct.unpack("<hhh", data[offset : offset + 6])
+        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)
-        offset += 6
+        offset += 8
 
     if head_valid:
         hx_q, offset = _unpack_int24_le(data, offset)
@@ -883,7 +918,7 @@ def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any],
 
     if physical_valid and head_valid:
         translated_x = head_pos[0] - xr_origin_delta_x
-        translated_y = head_pos[1]
+        translated_y = head_pos[1] - xr_origin_delta_y
         translated_z = head_pos[2] - xr_origin_delta_z
         physical_pos = _rotate_yaw_vector(
             translated_x,
@@ -1011,6 +1046,7 @@ def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any],
             )
 
     result["xrOriginDeltaX"] = xr_origin_delta_x
+    result["xrOriginDeltaY"] = xr_origin_delta_y
     result["xrOriginDeltaZ"] = xr_origin_delta_z
     result["xrOriginDeltaYaw"] = xr_origin_delta_yaw
     result["physical"] = physical
@@ -1022,7 +1058,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 (v3) from binary data."""
+    """Deserialize client pose (v4) from binary data."""
     result: dict[str, Any] = {}
 
     protocol_version = data[offset]
@@ -1060,7 +1096,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 (v3) with client numbers only."""
+    """Deserialize room pose (v4) with client numbers only."""
     result: dict[str, Any] = {}
 
     protocol_version = data[offset]
@@ -1225,3 +1261,207 @@ def _deserialize_client_var_sync(data: bytes, offset: int) -> dict[str, Any]:
         result["clientVariables"][str(client_no)] = variables
 
     return result
+
+
+# ---------------------------------------------------------------------------
+# NetSyncObject serialization / deserialization
+# ---------------------------------------------------------------------------
+
+
+def serialize_object_pose(data: dict[str, Any]) -> bytes:
+    """Serialize object pose message (Client -> Server)."""
+    buffer = bytearray()
+    buffer.append(MSG_OBJECT_POSE)
+    buffer.append(PROTOCOL_VERSION)
+    object_id = int(data.get("objectId", 0)) & 0xFFFFFFFF
+    buffer.extend(struct.pack("<I", object_id))
+    buffer.extend(struct.pack("<H", int(data.get("poseSeq", 0)) & 0xFFFF))
+    # Position: int24 x3
+    _pack_int24_le(
+        buffer, _quantize_signed_int24(float(data.get("posX", 0.0)), ABS_POS_SCALE)
+    )
+    _pack_int24_le(
+        buffer, _quantize_signed_int24(float(data.get("posY", 0.0)), ABS_POS_SCALE)
+    )
+    _pack_int24_le(
+        buffer, _quantize_signed_int24(float(data.get("posZ", 0.0)), ABS_POS_SCALE)
+    )
+    # Rotation: smallest-three 32-bit
+    qx = float(data.get("rotX", 0.0))
+    qy = float(data.get("rotY", 0.0))
+    qz = float(data.get("rotZ", 0.0))
+    qw = float(data.get("rotW", 1.0))
+    packed_rot = _compress_quaternion_smallest_three(qx, qy, qz, qw)
+    buffer.extend(struct.pack("<I", packed_rot))
+    return bytes(buffer)
+
+
+def serialize_room_objects(
+    room_id: str, broadcast_time: float, objects: list[dict[str, Any]]
+) -> bytes:
+    """Serialize room objects broadcast message (Server -> Clients via PUB)."""
+    buffer = bytearray()
+    buffer.append(MSG_ROOM_OBJECTS)
+    buffer.append(PROTOCOL_VERSION)
+    buffer.extend(struct.pack("<d", broadcast_time))
+    buffer.extend(struct.pack("<H", len(objects)))
+    for obj in objects:
+        object_id = int(obj.get("objectId", 0)) & 0xFFFFFFFF
+        buffer.extend(struct.pack("<I", object_id))
+        buffer.extend(struct.pack("<H", int(obj.get("ownerClientNo", 0)) & 0xFFFF))
+        buffer.extend(struct.pack("<H", int(obj.get("poseSeq", 0)) & 0xFFFF))
+        buffer.extend(struct.pack("<d", float(obj.get("poseTime", 0.0))))
+        # body_bytes already contains pos(9B) + rot(4B) = 13 bytes
+        body = obj.get("bodyBytes", b"")
+        if body:
+            buffer.extend(body)
+        else:
+            # Fallback: serialize from individual fields
+            _pack_int24_le(
+                buffer,
+                _quantize_signed_int24(float(obj.get("posX", 0.0)), ABS_POS_SCALE),
+            )
+            _pack_int24_le(
+                buffer,
+                _quantize_signed_int24(float(obj.get("posY", 0.0)), ABS_POS_SCALE),
+            )
+            _pack_int24_le(
+                buffer,
+                _quantize_signed_int24(float(obj.get("posZ", 0.0)), ABS_POS_SCALE),
+            )
+            qx = float(obj.get("rotX", 0.0))
+            qy = float(obj.get("rotY", 0.0))
+            qz = float(obj.get("rotZ", 0.0))
+            qw = float(obj.get("rotW", 1.0))
+            buffer.extend(
+                struct.pack("<I", _compress_quaternion_smallest_three(qx, qy, qz, qw))
+            )
+    return bytes(buffer)
+
+
+def serialize_object_ownership_changed(
+    object_id: int, new_owner: int, previous_owner: int
+) -> bytes:
+    """Serialize ownership changed notification (Server -> Clients via ROUTER)."""
+    buffer = bytearray()
+    buffer.append(MSG_OBJECT_OWNERSHIP_CHANGED)
+    buffer.extend(struct.pack("<I", object_id & 0xFFFFFFFF))
+    buffer.extend(struct.pack("<H", new_owner & 0xFFFF))
+    buffer.extend(struct.pack("<H", previous_owner & 0xFFFF))
+    return bytes(buffer)
+
+
+def serialize_object_ownership_rejected(
+    object_id: int, current_owner: int, reason_code: int
+) -> bytes:
+    """Serialize ownership rejected notification (Server -> Client via ROUTER)."""
+    buffer = bytearray()
+    buffer.append(MSG_OBJECT_OWNERSHIP_REJECTED)
+    buffer.extend(struct.pack("<I", object_id & 0xFFFFFFFF))
+    buffer.extend(struct.pack("<H", current_owner & 0xFFFF))
+    buffer.append(reason_code & 0xFF)
+    return bytes(buffer)
+
+
+def _deserialize_object_pose(data: bytes, offset: int) -> dict[str, Any]:
+    """Deserialize object pose (Client -> Server)."""
+    result: dict[str, Any] = {}
+    protocol_version = data[offset]
+    offset += 1
+    if protocol_version != PROTOCOL_VERSION:
+        raise ValueError(f"Unsupported protocol version: {protocol_version}")
+    result["objectId"] = struct.unpack("<I", data[offset : offset + 4])[0]
+    offset += 4
+    result["poseSeq"] = struct.unpack("<H", data[offset : offset + 2])[0]
+    offset += 2
+    # Extract body bytes (pos 9B + rot 4B = 13 bytes) for caching
+    body_start = offset
+    px, offset = _unpack_int24_le(data, offset)
+    py, offset = _unpack_int24_le(data, offset)
+    pz, offset = _unpack_int24_le(data, offset)
+    packed_rot = struct.unpack("<I", data[offset : offset + 4])[0]
+    offset += 4
+    result["bodyBytes"] = data[body_start:offset]
+    result["posX"] = _dequantize_signed(px, ABS_POS_SCALE)
+    result["posY"] = _dequantize_signed(py, ABS_POS_SCALE)
+    result["posZ"] = _dequantize_signed(pz, ABS_POS_SCALE)
+    qx, qy, qz, qw = _decompress_quaternion_smallest_three(packed_rot)
+    result["rotX"] = qx
+    result["rotY"] = qy
+    result["rotZ"] = qz
+    result["rotW"] = qw
+    return result
+
+
+def _deserialize_room_objects(data: bytes, offset: int) -> dict[str, Any]:
+    """Deserialize room objects broadcast."""
+    result: dict[str, Any] = {}
+    protocol_version = data[offset]
+    offset += 1
+    if protocol_version != PROTOCOL_VERSION:
+        raise ValueError(f"Unsupported protocol version: {protocol_version}")
+    result["broadcastTime"] = struct.unpack("<d", data[offset : offset + 8])[0]
+    offset += 8
+    object_count = struct.unpack("<H", data[offset : offset + 2])[0]
+    offset += 2
+    objects: list[dict[str, Any]] = []
+    for _ in range(object_count):
+        obj: dict[str, Any] = {}
+        obj["objectId"] = struct.unpack("<I", data[offset : offset + 4])[0]
+        offset += 4
+        obj["ownerClientNo"] = struct.unpack("<H", data[offset : offset + 2])[0]
+        offset += 2
+        obj["poseSeq"] = struct.unpack("<H", data[offset : offset + 2])[0]
+        offset += 2
+        obj["poseTime"] = struct.unpack("<d", data[offset : offset + 8])[0]
+        offset += 8
+        px, offset = _unpack_int24_le(data, offset)
+        py, offset = _unpack_int24_le(data, offset)
+        pz, offset = _unpack_int24_le(data, offset)
+        packed_rot = struct.unpack("<I", data[offset : offset + 4])[0]
+        offset += 4
+        obj["posX"] = _dequantize_signed(px, ABS_POS_SCALE)
+        obj["posY"] = _dequantize_signed(py, ABS_POS_SCALE)
+        obj["posZ"] = _dequantize_signed(pz, ABS_POS_SCALE)
+        qx, qy, qz, qw = _decompress_quaternion_smallest_three(packed_rot)
+        obj["rotX"] = qx
+        obj["rotY"] = qy
+        obj["rotZ"] = qz
+        obj["rotW"] = qw
+        objects.append(obj)
+    result["objects"] = objects
+    return result
+
+
+def _deserialize_object_ownership_request(data: bytes, offset: int) -> dict[str, Any]:
+    """Deserialize ownership request (Client -> Server)."""
+    result: dict[str, Any] = {}
+    result["operationType"] = data[offset]
+    offset += 1
+    result["objectId"] = struct.unpack("<I", data[offset : offset + 4])[0]
+    offset += 4
+    return result
+
+
+def _deserialize_object_ownership_changed(data: bytes, offset: int) -> dict[str, Any]:
+    """Deserialize ownership changed notification."""
+    result: dict[str, Any] = {}
+    result["objectId"] = struct.unpack("<I", data[offset : offset + 4])[0]
+    offset += 4
+    result["newOwnerClientNo"] = struct.unpack("<H", data[offset : offset + 2])[0]
+    offset += 2
+    result["previousOwnerClientNo"] = struct.unpack("<H", data[offset : offset + 2])[0]
+    offset += 2
+    return result
+
+
+def _deserialize_object_ownership_rejected(data: bytes, offset: int) -> dict[str, Any]:
+    """Deserialize ownership rejected notification."""
+    result: dict[str, Any] = {}
+    result["objectId"] = struct.unpack("<I", data[offset : offset + 4])[0]
+    offset += 4
+    result["currentOwnerClientNo"] = struct.unpack("<H", data[offset : offset + 2])[0]
+    offset += 2
+    result["reasonCode"] = data[offset]
+    offset += 1
+    return result