styly-netsync-server 0.13.0__tar.gz → 0.14.0__tar.gz

{styly_netsync_server-0.13.0 → styly_netsync_server-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: styly-netsync-server
-Version: 0.13.0
+Version: 0.14.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

{styly_netsync_server-0.13.0 → styly_netsync_server-0.14.0}/pyproject.toml

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

@@ -6,7 +6,10 @@ from typing import Any
 logger = logging.getLogger(__name__)
 
 # Message type identifiers
-PROTOCOL_VERSION = 5
+# v6: Network Variable wire messages dropped the per-write timestamp field.
+# Bumped so mixed old/new builds fail the handshake instead of silently
+# misparsing NV traffic (the version byte rides on transform/object messages).
+PROTOCOL_VERSION = 6
 MSG_CLIENT_TRANSFORM = 1
 MSG_ROOM_TRANSFORM = 2  # Legacy room transform with short IDs only
 MSG_RPC = 3  # Remote procedure call
@@ -686,7 +689,7 @@ def serialize_global_var_set(data: dict[str, Any]) -> bytes:
     """Serialize global variable set message
 
     Args:
-        data: Dictionary with senderClientNo, variableName, variableValue, timestamp
+        data: Dictionary with senderClientNo, variableName, variableValue
     """
     buffer = bytearray()
 
@@ -704,9 +707,6 @@ def serialize_global_var_set(data: dict[str, Any]) -> bytes:
     value = data.get("variableValue", "")[:1024]
     _pack_string(buffer, value, use_ushort=True)
 
-    # Timestamp (8 bytes double)
-    buffer.extend(struct.pack("<d", data.get("timestamp", 0.0)))
-
     return bytes(buffer)
 
 
@@ -729,7 +729,6 @@ def serialize_global_var_sync(data: dict[str, Any]) -> bytes:
     for var in variables:
         _pack_string(buffer, var.get("name", "")[:64])
         _pack_string(buffer, var.get("value", "")[:1024], use_ushort=True)
-        buffer.extend(struct.pack("<d", var.get("timestamp", 0.0)))
         buffer.extend(struct.pack("<H", var.get("lastWriterClientNo", 0)))
 
     return bytes(buffer)
@@ -739,7 +738,8 @@ def serialize_client_var_set(data: dict[str, Any]) -> bytes:
     """Serialize client variable set message
 
     Args:
-        data: Dictionary with senderClientNo, targetClientNo, variableName, variableValue, timestamp
+        data: Dictionary with senderClientNo, targetClientNo, variableName,
+            variableValue
     """
     buffer = bytearray()
 
@@ -760,9 +760,6 @@ def serialize_client_var_set(data: dict[str, Any]) -> bytes:
     value = data.get("variableValue", "")[:1024]
     _pack_string(buffer, value, use_ushort=True)
 
-    # Timestamp (8 bytes double)
-    buffer.extend(struct.pack("<d", data.get("timestamp", 0.0)))
-
     return bytes(buffer)
 
 
@@ -770,7 +767,7 @@ def serialize_client_var_clear(data: dict[str, Any]) -> bytes:
     """Serialize client variable clear message.
 
     Args:
-        data: Dictionary with senderClientNo and timestamp.
+        data: Dictionary with senderClientNo.
     """
     buffer = bytearray()
 
@@ -780,9 +777,6 @@ def serialize_client_var_clear(data: dict[str, Any]) -> bytes:
     # Sender client number (2 bytes)
     buffer.extend(struct.pack("<H", data.get("senderClientNo", 0)))
 
-    # Timestamp (8 bytes double)
-    buffer.extend(struct.pack("<d", data.get("timestamp", 0.0)))
-
     return bytes(buffer)
 
 
@@ -811,7 +805,6 @@ def serialize_client_var_sync(data: dict[str, Any]) -> bytes:
         for var in variables:
             _pack_string(buffer, var.get("name", "")[:64])
             _pack_string(buffer, var.get("value", "")[:1024], use_ushort=True)
-            buffer.extend(struct.pack("<d", var.get("timestamp", 0.0)))
             buffer.extend(struct.pack("<H", var.get("lastWriterClientNo", 0)))
 
     return bytes(buffer)
@@ -1247,10 +1240,6 @@ def _deserialize_global_var_set(data: bytes, offset: int) -> dict[str, Any]:
     # Variable value
     result["variableValue"], offset = _unpack_string(data, offset, use_ushort=True)
 
-    # Timestamp (8 bytes double)
-    result["timestamp"] = struct.unpack("<d", data[offset : offset + 8])[0]
-    offset += 8
-
     return result
 
 
@@ -1267,8 +1256,6 @@ def _deserialize_global_var_sync(data: bytes, offset: int) -> dict[str, Any]:
         var = {}
         var["name"], offset = _unpack_string(data, offset)
         var["value"], offset = _unpack_string(data, offset, use_ushort=True)
-        var["timestamp"] = struct.unpack("<d", data[offset : offset + 8])[0]
-        offset += 8
         var["lastWriterClientNo"] = struct.unpack("<H", data[offset : offset + 2])[0]
         offset += 2
         result["variables"].append(var)
@@ -1294,10 +1281,6 @@ def _deserialize_client_var_set(data: bytes, offset: int) -> dict[str, Any]:
     # Variable value
     result["variableValue"], offset = _unpack_string(data, offset, use_ushort=True)
 
-    # Timestamp (8 bytes double)
-    result["timestamp"] = struct.unpack("<d", data[offset : offset + 8])[0]
-    offset += 8
-
     return result
 
 
@@ -1307,10 +1290,6 @@ def _deserialize_client_var_clear(data: bytes, offset: int) -> dict[str, Any]:
 
     # Sender client number (2 bytes)
     result["senderClientNo"] = struct.unpack("<H", data[offset : offset + 2])[0]
-    offset += 2
-
-    # Timestamp (8 bytes double)
-    result["timestamp"] = struct.unpack("<d", data[offset : offset + 8])[0]
 
     return result
 
@@ -1336,8 +1315,6 @@ def _deserialize_client_var_sync(data: bytes, offset: int) -> dict[str, Any]:
             var = {}
             var["name"], offset = _unpack_string(data, offset)
             var["value"], offset = _unpack_string(data, offset, use_ushort=True)
-            var["timestamp"] = struct.unpack("<d", data[offset : offset + 8])[0]
-            offset += 8
             var["lastWriterClientNo"] = struct.unpack("<H", data[offset : offset + 2])[
                 0
             ]

{styly_netsync_server-0.13.0 → styly_netsync_server-0.14.0}/src/styly_netsync/client.py

@@ -1222,7 +1222,6 @@ class net_sync_manager:
                 "senderClientNo": self._client_no,
                 "variableName": name,
                 "variableValue": value,
-                "timestamp": time.time(),
             }
             message = binary_serializer.serialize_global_var_set(var_data)
             return self._enqueue_control(
@@ -1244,7 +1243,6 @@ class net_sync_manager:
                 "targetClientNo": target_client_no,
                 "variableName": name,
                 "variableValue": value,
-                "timestamp": time.time(),
             }
             message = binary_serializer.serialize_client_var_set(var_data)
             return self._enqueue_control(
@@ -1263,7 +1261,6 @@ class net_sync_manager:
         try:
             clear_data = {
                 "senderClientNo": self._client_no,
-                "timestamp": time.time(),
             }
             message = binary_serializer.serialize_client_var_clear(clear_data)
             sent = self._enqueue_control(

{styly_netsync_server-0.13.0 → styly_netsync_server-0.14.0}/src/styly_netsync/client_simulator.py

@@ -648,7 +648,6 @@ class NetworkTransport:
                 "targetClientNo": sender_client_no,  # Set variable for ourselves
                 "variableName": var_name,
                 "variableValue": value,
-                "timestamp": time.time(),
             }
             binary_data = serialize_client_var_set(var_data)
             self.socket.send_multipart(

{styly_netsync_server-0.13.0 → styly_netsync_server-0.14.0}/src/styly_netsync/server.py

@@ -309,18 +309,24 @@ class NetSyncServer:
         # Network Variables storage
         self.global_variables: dict[str, dict[str, Any]] = (
             {}
-        )  # room_id -> {var_name: {value, timestamp, lastWriterClientNo}}
+        )  # room_id -> {var_name: {value, version, lastWriterClientNo}}
         self.client_variables: dict[str, dict[str, dict[str, Any]]] = (
             {}
-        )  # room_id -> {device_id -> {var_name: {value, timestamp, lastWriterClientNo}}}
+        )  # room_id -> {device_id -> {var_name: {value, version, lastWriterClientNo}}}
+
+        # Per-room monotonic write sequence. The server assigns the ordering for
+        # Network Variable last-writer-wins instead of trusting client-supplied
+        # timestamps, whose device clocks can drift on offline LAN deployments.
+        # The assigned sequence is stored in each variable's "version" field.
+        self.nv_write_seq: dict[str, int] = {}  # room_id -> last assigned write seq
 
         # NV Pending buffers for coalescing (latest-wins per key)
         self.pending_global_nv: dict[str, dict[str, tuple]] = (
             {}
-        )  # room_id -> {var_name: (sender_client_no, value, timestamp)}
+        )  # room_id -> {var_name: (sender_client_no, value)}
         self.pending_client_nv: dict[str, dict[tuple, tuple]] = (
             {}
-        )  # room_id -> {(target_client_no, var_name): (sender_client_no, value, timestamp)}
+        )  # room_id -> {(target_client_no, var_name): (sender_client_no, value)}
 
         # NV flush cadence configuration (from config)
         self.nv_flush_interval = config.nv_flush_interval
@@ -758,6 +764,7 @@ class NetSyncServer:
             # Initialize Network Variables for the room
             self.global_variables[room_id] = {}
             self.client_variables[room_id] = {}
+            self.nv_write_seq[room_id] = 0
 
             # Initialize NV pending buffers
             self.pending_global_nv[room_id] = {}
@@ -1486,12 +1493,22 @@ class NetSyncServer:
                     f"High NV request rate in room {room_id}: {len(self.nv_monitor_window[room_id])} req/s"
                 )
 
+    def _next_nv_seq(self, room_id: str) -> int:
+        """Return the next per-room monotonic NV write sequence.
+
+        Caller must hold ``_rooms_lock``. This sequence is the server-assigned
+        ordering authority for last-writer-wins, replacing client timestamps so
+        that skewed device clocks cannot freeze or steal Network Variables.
+        """
+        seq = self.nv_write_seq.get(room_id, 0) + 1
+        self.nv_write_seq[room_id] = seq
+        return seq
+
     def _buffer_global_var_set(self, room_id: str, data: dict[str, Any]) -> None:
         """Buffer global variable set request for later processing"""
         sender_client_no = data.get("senderClientNo", 0)
         var_name = data.get("variableName", "")[: self.MAX_VAR_NAME_LENGTH]
         var_value = data.get("variableValue", "")[: self.MAX_VAR_VALUE_LENGTH]
-        timestamp = data.get("timestamp", time.monotonic())
 
         if not var_name:
             return
@@ -1503,7 +1520,6 @@ class NetSyncServer:
             self.pending_global_nv[room_id][var_name] = (
                 sender_client_no,
                 var_value,
-                timestamp,
             )
 
     def _apply_global_var_set(
@@ -1512,7 +1528,6 @@ class NetSyncServer:
         sender_client_no: int,
         var_name: str,
         var_value: str,
-        timestamp: float,
     ) -> bool:
         """Apply global variable update (used by flush, returns True if applied)"""
         with self._rooms_lock:
@@ -1522,25 +1537,19 @@ class NetSyncServer:
                 logger.warning(f"Global variable limit reached in room {room_id}")
                 return False
 
-            # Conflict resolution: last-writer-wins with timestamp comparison
+            # Skip if value unchanged (no-op)
             if var_name in global_vars:
-                existing = global_vars[var_name]
-                # Skip if value unchanged (no-op)
-                if existing.get("value") == var_value:
+                if global_vars[var_name].get("value") == var_value:
                     return False
-                if timestamp < existing["timestamp"] or (
-                    timestamp == existing["timestamp"]
-                    and sender_client_no < existing["lastWriterClientNo"]
-                ):
-                    return False  # Ignore older or lower priority update
 
             # Store old value for logging
             old_value = global_vars.get(var_name, {}).get("value", None)
 
-            # Update variable
+            # Last-writer-wins ordered by the server-assigned write sequence,
+            # not client timestamps (device clocks can drift offline).
             global_vars[var_name] = {
                 "value": var_value,
-                "timestamp": timestamp,
+                "version": self._next_nv_seq(room_id),
                 "lastWriterClientNo": sender_client_no,
             }
 
@@ -1554,14 +1563,11 @@ class NetSyncServer:
         sender_client_no = data.get("senderClientNo", 0)
         var_name = data.get("variableName", "")[: self.MAX_VAR_NAME_LENGTH]
         var_value = data.get("variableValue", "")[: self.MAX_VAR_VALUE_LENGTH]
-        timestamp = data.get("timestamp", time.monotonic())
 
         if not var_name:
             return
 
-        if self._apply_global_var_set(
-            room_id, sender_client_no, var_name, var_value, timestamp
-        ):
+        if self._apply_global_var_set(room_id, sender_client_no, var_name, var_value):
             # Broadcast sync to all clients
             self._broadcast_global_var_sync(room_id)
 
@@ -1571,7 +1577,6 @@ class NetSyncServer:
         target_client_no = data.get("targetClientNo", 0)
         var_name = data.get("variableName", "")[: self.MAX_VAR_NAME_LENGTH]
         var_value = data.get("variableValue", "")[: self.MAX_VAR_VALUE_LENGTH]
-        timestamp = data.get("timestamp", time.monotonic())
 
         if not var_name:
             return
@@ -1584,7 +1589,6 @@ class NetSyncServer:
             self.pending_client_nv[room_id][key] = (
                 sender_client_no,
                 var_value,
-                timestamp,
             )
 
     def _apply_client_var_set(
@@ -1594,7 +1598,6 @@ class NetSyncServer:
         target_client_no: int,
         var_name: str,
         var_value: str,
-        timestamp: float,
     ) -> bool:
         """Apply a client variable update addressed by volatile client number."""
         with self._rooms_lock:
@@ -1613,7 +1616,6 @@ class NetSyncServer:
                 target_device_id,
                 var_name,
                 var_value,
-                timestamp,
             )
 
     def _apply_client_var_set_for_device(
@@ -1623,7 +1625,6 @@ class NetSyncServer:
         target_device_id: str,
         var_name: str,
         var_value: str,
-        timestamp: float,
     ) -> bool:
         """Apply a client variable update to the authoritative device-keyed store."""
         with self._rooms_lock:
@@ -1641,25 +1642,19 @@ class NetSyncServer:
                 )
                 return False
 
-            # Conflict resolution: last-writer-wins with timestamp comparison
+            # Skip if value unchanged (no-op)
             if var_name in client_vars:
-                existing = client_vars[var_name]
-                # Skip if value unchanged (no-op)
-                if existing.get("value") == var_value:
+                if client_vars[var_name].get("value") == var_value:
                     return False
-                if timestamp < existing["timestamp"] or (
-                    timestamp == existing["timestamp"]
-                    and sender_client_no < existing["lastWriterClientNo"]
-                ):
-                    return False  # Ignore older or lower priority update
 
             # Store old value for logging
             old_value = client_vars.get(var_name, {}).get("value", None)
 
-            # Update variable
+            # Last-writer-wins ordered by the server-assigned write sequence,
+            # not client timestamps (device clocks can drift offline).
             client_vars[var_name] = {
                 "value": var_value,
-                "timestamp": timestamp,
+                "version": self._next_nv_seq(room_id),
                 "lastWriterClientNo": sender_client_no,
             }
 
@@ -1672,7 +1667,6 @@ class NetSyncServer:
         self, room_id: str, device_id: str, variables: dict[str, str]
     ) -> tuple[int | None, dict[str, str]]:
         """Upsert REST-provided client variables into the device-keyed store."""
-        timestamp = time.time()
         statuses: dict[str, str] = {}
         changed = False
 
@@ -1703,12 +1697,20 @@ class NetSyncServer:
                     device_id,
                     var_name,
                     var_value,
-                    timestamp,
                 )
                 after = self.client_variables[room_id].get(device_id, {}).get(var_name)
                 changed = changed or applied or before != after
                 statuses[name] = "applied" if client_no is not None else "queued"
 
+                # This REST write is now the authoritative latest value for the
+                # key. Drop any older live write still buffered for the same
+                # (client_no, var_name) so the next flush cannot resurrect a
+                # stale value over it (mirrors delete/clear pruning).
+                if client_no is not None:
+                    self._remove_pending_client_vars_locked(
+                        room_id, client_no, var_name
+                    )
+
         if client_no is not None and changed:
             self._broadcast_client_var_sync(room_id, {client_no})
 
@@ -1823,13 +1825,12 @@ class NetSyncServer:
         target_client_no = data.get("targetClientNo", 0)
         var_name = data.get("variableName", "")[: self.MAX_VAR_NAME_LENGTH]
         var_value = data.get("variableValue", "")[: self.MAX_VAR_VALUE_LENGTH]
-        timestamp = data.get("timestamp", time.monotonic())
 
         if not var_name:
             return
 
         if self._apply_client_var_set(
-            room_id, sender_client_no, target_client_no, var_name, var_value, timestamp
+            room_id, sender_client_no, target_client_no, var_name, var_value
         ):
             # Broadcast sync to all clients
             self._broadcast_client_var_sync(room_id)
@@ -1850,7 +1851,6 @@ class NetSyncServer:
                 {
                     "name": var_name,
                     "value": var_data["value"],
-                    "timestamp": var_data["timestamp"],
                     "lastWriterClientNo": var_data["lastWriterClientNo"],
                 }
             )
@@ -1899,7 +1899,6 @@ class NetSyncServer:
                     {
                         "name": var_name,
                         "value": var_data["value"],
-                        "timestamp": var_data["timestamp"],
                         "lastWriterClientNo": var_data["lastWriterClientNo"],
                     }
                 )
@@ -1970,25 +1969,30 @@ class NetSyncServer:
         """Drain all pending NV updates for a room in one go."""
         start = time.perf_counter()
 
+        applied_globals: list[str] = []
+        applied_client_nos: set[int] = set()
+
+        # Drain and apply under a single lock hold. _rooms_lock is an RLock, so
+        # the nested acquisitions inside _apply_* are reentrant. Holding the lock
+        # across both steps prevents an immediate write (e.g. a REST upsert) from
+        # interleaving in the drain/apply gap, where a stale buffered write would
+        # otherwise overwrite the newer immediate one (last-writer-wins is now
+        # ordered by application order, not by client timestamps).
         with self._rooms_lock:
-            pending_globals = self.pending_global_nv.get(room_id, {})
-            pending_clients = self.pending_client_nv.get(room_id, {})
-            globals_to_apply = list(pending_globals.items())
-            clients_to_apply = list(pending_clients.items())
+            globals_to_apply = list(self.pending_global_nv.get(room_id, {}).items())
+            clients_to_apply = list(self.pending_client_nv.get(room_id, {}).items())
             self.pending_global_nv[room_id] = {}
             self.pending_client_nv[room_id] = {}
 
-        applied_globals: list[str] = []
-        for var_name, (sender, value, ts) in globals_to_apply:
-            if self._apply_global_var_set(room_id, sender, var_name, value, ts):
-                applied_globals.append(var_name)
+            for var_name, (sender, value) in globals_to_apply:
+                if self._apply_global_var_set(room_id, sender, var_name, value):
+                    applied_globals.append(var_name)
 
-        applied_client_nos: set[int] = set()
-        for (target_client_no, var_name), (sender, value, ts) in clients_to_apply:
-            if self._apply_client_var_set(
-                room_id, sender, target_client_no, var_name, value, ts
-            ):
-                applied_client_nos.add(target_client_no)
+            for (target_client_no, var_name), (sender, value) in clients_to_apply:
+                if self._apply_client_var_set(
+                    room_id, sender, target_client_no, var_name, value
+                ):
+                    applied_client_nos.add(target_client_no)
 
         # Send NV syncs via ROUTER unicast for reliable delivery
         if applied_globals:
@@ -2000,7 +2004,6 @@ class NetSyncServer:
                         {
                             "name": name,
                             "value": d["value"],
-                            "timestamp": d["timestamp"],
                             "lastWriterClientNo": d["lastWriterClientNo"],
                         }
                     )
@@ -2434,6 +2437,8 @@ class NetSyncServer:
                         del self.pending_global_nv[room_id]
                     if room_id in self.pending_client_nv:
                         del self.pending_client_nv[room_id]
+                    if room_id in self.nv_write_seq:
+                        del self.nv_write_seq[room_id]
                     if room_id in self.room_last_nv_flush:
                         del self.room_last_nv_flush[room_id]
                     if room_id in self.nv_monitor_window:

{styly_netsync_server-0.13.0 → styly_netsync_server-0.14.0}/src/styly_netsync_server.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: styly-netsync-server
-Version: 0.13.0
+Version: 0.14.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

{styly_netsync_server-0.13.0 → styly_netsync_server-0.14.0}/src/styly_netsync_server.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ tests/test_discovery_probe.py
 tests/test_logging_cli.py
 tests/test_multi_nic.py
 tests/test_nv_protocol.py
+tests/test_nv_server_ordering.py
 tests/test_object_sync.py
 tests/test_port_error_message.py
 tests/test_python_client.py

{styly_netsync_server-0.13.0 → styly_netsync_server-0.14.0}/tests/test_binary_serializer.py

@@ -289,11 +289,11 @@ def _reconstruct_physical_from_head_and_delta(
 
 
 class TestTransformSerializationV5:
-    """Tests for protocol v5 transform compact serialization."""
+    """Tests for protocol v6 transform compact serialization."""
 
-    def test_protocol_version_is_v5(self) -> None:
-        """Protocol version constant should be at v5."""
-        assert binary_serializer.PROTOCOL_VERSION == 5
+    def test_protocol_version_is_v6(self) -> None:
+        """Protocol version constant should be at v6."""
+        assert binary_serializer.PROTOCOL_VERSION == 6
 
     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 TestTransformSerializationV5:
 
             assert msg_type == binary_serializer.MSG_CLIENT_POSE
             assert decoded is not None
-            assert decoded["protocolVersion"] == 5
+            assert decoded["protocolVersion"] == 6
             assert len(raw) > 0
 
             o_head = original["head"]
@@ -822,7 +822,7 @@ class TestTransformSerializationV5:
 
         assert msg_type == binary_serializer.MSG_ROOM_POSE
         assert decoded is not None
-        assert decoded["protocolVersion"] == 5
+        assert decoded["protocolVersion"] == 6
         assert decoded["roomId"] == "room-v5"
         assert len(decoded["clients"]) == 2
 
@@ -1085,7 +1085,7 @@ class TestClientVariableClearSerialization:
 
     def test_roundtrip_client_variable_clear(self) -> None:
         """Client variable clear message round-trips correctly."""
-        data = {"senderClientNo": 7, "timestamp": 1234.5}
+        data = {"senderClientNo": 7}
 
         serialized = binary_serializer.serialize_client_var_clear(data)
         msg_type, result, _ = binary_serializer.deserialize(serialized)

{styly_netsync_server-0.13.0 → styly_netsync_server-0.14.0}/tests/test_client_variable_device_store.py

@@ -61,9 +61,7 @@ class TestServerClientVariableDeviceStore:
     def test_client_no_write_stores_by_device_id(self, server: NetSyncServer) -> None:
         _map_device(server, "room1", "device-a", 7)
 
-        applied = server._apply_client_var_set(
-            "room1", 2, 7, "score", "100", time.time()
-        )
+        applied = server._apply_client_var_set("room1", 2, 7, "score", "100")
 
         assert applied is True
         assert server.client_variables["room1"]["device-a"]["score"]["value"] == "100"
@@ -75,8 +73,8 @@ class TestServerClientVariableDeviceStore:
         _map_device(server, "room1", "device-a", 7)
         _map_device(server, "room1", "device-b", 8)
 
-        server._apply_client_var_set("room1", 2, 7, "score", "100", time.time())
-        server._apply_client_var_set("room1", 2, 8, "score", "200", time.time())
+        server._apply_client_var_set("room1", 2, 7, "score", "100")
+        server._apply_client_var_set("room1", 2, 8, "score", "200")
 
         assert server.client_variables["room1"]["device-a"]["score"]["value"] == "100"
         assert server.client_variables["room1"]["device-b"]["score"]["value"] == "200"
@@ -101,7 +99,7 @@ class TestServerClientVariableDeviceStore:
         self, server: NetSyncServer
     ) -> None:
         _map_device(server, "room1", "device-a", 7)
-        server._apply_client_var_set("room1", 2, 7, "score", "100", time.time())
+        server._apply_client_var_set("room1", 2, 7, "score", "100")
 
         payload = server._build_client_var_sync_payload("room1")
         assert payload is not None
@@ -158,7 +156,7 @@ class TestServerClientVariableDeviceStore:
         self, server: NetSyncServer
     ) -> None:
         _map_device(server, "room1", "device-a", 7)
-        server._apply_client_var_set("room1", 2, 7, "score", "100", time.time())
+        server._apply_client_var_set("room1", 2, 7, "score", "100")
         server.device_id_last_seen["device-a"] = (
             time.monotonic() - server.DEVICE_ID_EXPIRY_TIME - 1.0
         )
@@ -174,7 +172,7 @@ class TestServerClientVariableDeviceStore:
     ) -> None:
         _map_device(server, "room1", "device-a", 7)
         server.client_transform_body_cache[7] = b"old"
-        server._apply_client_var_set("room1", 2, 7, "score", "100", time.time())
+        server._apply_client_var_set("room1", 2, 7, "score", "100")
         server.device_id_last_seen["device-a"] = (
             time.monotonic() - server.DEVICE_ID_EXPIRY_TIME - 1.0
         )
@@ -193,8 +191,8 @@ class TestServerClientVariableDeviceStore:
         server.upsert_client_variables_for_device(
             "room1", "device-a", {"a": "1", "b": "2"}
         )
-        server.pending_client_nv["room1"][(7, "a")] = (7, "stale", time.time())
-        server.pending_client_nv["room1"][(8, "a")] = (8, "other", time.time())
+        server.pending_client_nv["room1"][(7, "a")] = (7, "stale")
+        server.pending_client_nv["room1"][(8, "a")] = (8, "other")
         server._send_ctrl_to_room_via_router.reset_mock()
 
         server._handle_client_var_clear(
@@ -363,7 +361,7 @@ class TestRestClientVariableDeviceStore:
     ) -> None:
         _map_device(server, "room1", "device-a", 7)
         server.upsert_client_variables_for_device("room1", "device-a", {"a": "1"})
-        server.pending_client_nv["room1"][(7, "a")] = (7, "stale", time.time())
+        server.pending_client_nv["room1"][(7, "a")] = (7, "stale")
         server._send_ctrl_to_room_via_router.reset_mock()
         tc = self._client(server)
 

styly_netsync_server-0.14.0/tests/test_nv_server_ordering.py

@@ -0,0 +1,147 @@
+"""Server-authoritative Network Variable ordering (issue #448).
+
+The server assigns a per-room monotonic write sequence for last-writer-wins
+instead of trusting client-supplied timestamps, so skewed device clocks on
+offline LAN deployments cannot freeze or steal Network Variables.
+"""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Iterator
+from unittest.mock import MagicMock
+
+import pytest
+
+from styly_netsync.server import NetSyncServer
+
+
+@pytest.fixture()
+def server() -> Iterator[NetSyncServer]:
+    srv = NetSyncServer(enable_server_discovery=False)
+    srv._send_ctrl_to_room_via_router = MagicMock()  # type: ignore[method-assign]
+    yield srv
+    srv.context.term()
+
+
+def _map_device(
+    srv: NetSyncServer, room_id: str, device_id: str, client_no: int
+) -> None:
+    srv._initialize_room(room_id)
+    srv.room_device_id_to_client_no[room_id][device_id] = client_no
+    srv.room_client_no_to_device_id[room_id][client_no] = device_id
+    srv.device_id_last_seen[device_id] = time.monotonic()
+
+
+class TestGlobalVariableServerOrdering:
+    def test_last_applied_write_wins(self, server: NetSyncServer) -> None:
+        server._initialize_room("room1")
+
+        assert server._apply_global_var_set("room1", 1, "score", "100") is True
+        assert server._apply_global_var_set("room1", 2, "score", "200") is True
+
+        stored = server.global_variables["room1"]["score"]
+        assert stored["value"] == "200"
+        assert stored["lastWriterClientNo"] == 2
+
+    def test_write_sequence_is_monotonic_and_server_assigned(
+        self, server: NetSyncServer
+    ) -> None:
+        server._initialize_room("room1")
+        assert server.nv_write_seq["room1"] == 0
+
+        server._apply_global_var_set("room1", 1, "a", "1")
+        server._apply_global_var_set("room1", 1, "b", "2")
+
+        assert server.global_variables["room1"]["a"]["version"] == 1
+        assert server.global_variables["room1"]["b"]["version"] == 2
+        assert server.nv_write_seq["room1"] == 2
+
+    def test_no_op_value_does_not_consume_sequence(self, server: NetSyncServer) -> None:
+        server._initialize_room("room1")
+        assert server._apply_global_var_set("room1", 1, "a", "1") is True
+        seq_after_first = server.nv_write_seq["room1"]
+
+        # Same value -> no-op, returns False and must not bump the sequence
+        assert server._apply_global_var_set("room1", 2, "a", "1") is False
+        assert server.nv_write_seq["room1"] == seq_after_first
+
+
+class TestClientVariableServerOrdering:
+    def test_last_applied_write_wins(self, server: NetSyncServer) -> None:
+        _map_device(server, "room1", "device-a", 7)
+
+        assert server._apply_client_var_set("room1", 2, 7, "hp", "10") is True
+        assert server._apply_client_var_set("room1", 3, 7, "hp", "20") is True
+
+        stored = server.client_variables["room1"]["device-a"]["hp"]
+        assert stored["value"] == "20"
+        assert stored["lastWriterClientNo"] == 3
+
+    def test_rest_and_live_writes_share_one_sequence_domain(
+        self, server: NetSyncServer
+    ) -> None:
+        _map_device(server, "room1", "device-a", 7)
+
+        server._apply_client_var_set("room1", 2, 7, "hp", "10")
+        live_seq = server.client_variables["room1"]["device-a"]["hp"]["version"]
+
+        server.upsert_client_variables_for_device("room1", "device-a", {"hp": "30"})
+        rest_seq = server.client_variables["room1"]["device-a"]["hp"]["version"]
+
+        assert rest_seq > live_seq
+        assert server.client_variables["room1"]["device-a"]["hp"]["value"] == "30"
+
+
+class TestLiveVsRestOrderingRegression:
+    """Regression: a newer REST write must not be clobbered by an older live
+    write that was still buffered when the REST write arrived.
+
+    Live socket writes are coalesced into a pending buffer and applied later by
+    ``_flush_nv_drain``; REST writes apply immediately. Once client timestamps
+    were removed, an out-of-order application no longer self-rejects, so the
+    REST path must prune any superseded buffered write for the same key.
+    """
+
+    def test_buffered_live_write_does_not_overwrite_newer_rest_write(
+        self, server: NetSyncServer
+    ) -> None:
+        _map_device(server, "room1", "device-a", 7)
+
+        # An older live client write is buffered, awaiting the next flush.
+        server._buffer_client_var_set(
+            "room1",
+            {
+                "senderClientNo": 7,
+                "targetClientNo": 7,
+                "variableName": "hp",
+                "variableValue": "10",
+            },
+        )
+
+        # A REST upsert applies a newer value immediately.
+        server.upsert_client_variables_for_device("room1", "device-a", {"hp": "20"})
+
+        # Draining must not resurrect the stale buffered "10" over the REST "20".
+        server._flush_nv_drain("room1")
+
+        assert server.client_variables["room1"]["device-a"]["hp"]["value"] == "20"
+
+
+class TestRoomCleanupReleasesNvWriteSeq:
+    """Regression: room cleanup must drop nv_write_seq so per-room sequence
+    entries do not accumulate under room churn."""
+
+    def test_nv_write_seq_entry_is_removed_on_room_cleanup(
+        self, server: NetSyncServer
+    ) -> None:
+        server._initialize_room("room1")
+        server._apply_global_var_set("room1", 1, "a", "1")
+        assert "room1" in server.nv_write_seq
+
+        # Room has been empty long enough to be reclaimed by the real cleanup.
+        server.room_empty_since["room1"] = 0.0
+        server._cleanup_clients(server.EMPTY_ROOM_EXPIRY_TIME + 100.0)
+
+        assert "room1" not in server.rooms
+        assert "room1" not in server.nv_write_seq

{styly_netsync_server-0.13.0 → styly_netsync_server-0.14.0}/tests/test_object_sync.py

@@ -262,6 +262,7 @@ class TestServerObjectOwnership:
         srv.device_id_last_seen = {}
         srv.global_variables = {}
         srv.client_variables = {}
+        srv.nv_write_seq = {}
         srv.pending_global_nv = {}
         srv.pending_client_nv = {}
         srv.room_last_nv_flush = {}