fix: decode Q10 virtual walls (DP 57) with their own frame

Virtual walls (dpVirtualWallUp 57) use a different on-wire frame from the
restricted-zone DPs: a bare [count] byte (no version, no per-record
type/pad) then 8-byte (y, x) int16-BE records. Feeding such a blob to
parse_zone_blob mis-frames it (leading 0x01 read as a version, the next
coordinate byte as a record count), so virtual_walls silently came back
empty and the wall overlay never rendered.

Add parse_virtual_wall_blob (axes un-swapped to (x, y) so walls share the
restricted-zone coordinate order), point load_overlays at it for DP 57,
and correct the overlay module's docs that wrongly claimed parse_zone_blob
handled DP 57. Tested against a real ss07 read-back from the PR #850 thread.

Author: tubededentifrice

roborock/devices/traits/b01/q10/map.py

@@ -43,7 +43,13 @@
     parse_map_packet,
     parse_trace_packet,
 )
-from roborock.map.b01_q10_overlays import ZONE_TYPE_NO_GO, ZONE_TYPE_NO_MOP, Q10Zone, parse_zone_blob
+from roborock.map.b01_q10_overlays import (
+    ZONE_TYPE_NO_GO,
+    ZONE_TYPE_NO_MOP,
+    Q10Zone,
+    parse_virtual_wall_blob,
+    parse_zone_blob,
+)
 from roborock.roborock_message import RoborockMessage, RoborockMessageProtocol
 
 _LOGGER = logging.getLogger(__name__)
@@ -264,7 +270,7 @@ def load_overlays(
         if restricted_zone_up is not None:
             self.zones = parse_zone_blob(restricted_zone_up)
         if virtual_wall_up is not None:
-            self.virtual_walls = parse_zone_blob(virtual_wall_up)
+            self.virtual_walls = parse_virtual_wall_blob(virtual_wall_up)
         if self.calibration is not None:
             self._place_zones_on_map_data(self.calibration)
 

roborock/map/b01_q10_overlays.py

@@ -4,13 +4,20 @@
 the map raster; the device reports them as base64-encoded blobs in separate data
 points (``dpRestrictedZoneUp`` 55, ``dpVirtualWallUp`` 57, ``dpZonedUp`` 59).
 
-The blob format was reverse-engineered from a live ss07 (confirmed against 7
-real no-go zones):
+The restricted-zone / zoned blob format (DP 55 and DP 59) was reverse-engineered
+from a live ss07 (confirmed against 7 real no-go zones):
 
     [version: u8][count: u8] then ``count`` fixed-size records, each:
         [type: u8][vertex_count: u8] then vertex_count (x, y) int16-BE pairs,
         zero-padded to the record size.
 
+Use :func:`parse_zone_blob` for those.  Virtual walls (DP 57) use a *different*
+frame -- a bare ``[count]`` and 8-byte ``(y, x)`` records, no version/type/pad --
+so they have their own :func:`parse_virtual_wall_blob`; feeding DP 57 to
+:func:`parse_zone_blob` mis-frames it (the leading byte is read as a version and
+the next, a coordinate, as a record count).  Provenance and the byte-level
+breakdown are in PR #850's review thread.
+
 Coordinates are in the device's world units (the same space as the cleaning
 path), so a :class:`~roborock.map.b01_grid_layers.GridCalibration` maps them to
 map pixels. ``type`` distinguishes the restriction kind (2 = no-mop, 3 = door
@@ -83,12 +90,61 @@ def parse_zone_blob(data: bytes | str | None) -> list[Q10Zone]:
     return zones
 
 
+_WALL_RECORD_SIZE = 8  # two int16-BE endpoints, stored (y, x) on the wire
+
+
+def parse_virtual_wall_blob(data: bytes | str | None) -> list[Q10Zone]:
+    """Decode a Q10 virtual-wall overlay blob (``dpVirtualWallUp`` 57).
+
+    Virtual walls use a *different* frame from the restricted-zone DPs handled by
+    :func:`parse_zone_blob`: a single ``[count: u8]`` byte (no version, no
+    per-record type/pad) followed by ``count`` 8-byte records, each two
+    ``(y, x)`` int16-BE endpoints -- note the swapped axis order.
+
+    Each wall is returned as a :class:`Q10Zone` of type
+    :data:`ZONE_TYPE_VIRTUAL_WALL` with its two endpoints as ``(x, y)`` vertices
+    (axes un-swapped to match the restricted-zone order), so callers can place
+    them onto the map through the same
+    :class:`~roborock.map.b01_grid_layers.GridCalibration`.
+
+    Accepts raw bytes or the base64 string straight from the data point. Returns
+    ``[]`` for empty/absent/unparsable blobs (the device sends a single ``0x00``
+    byte -- base64 ``AA==`` -- when there are none).
+    """
+    raw = _as_bytes(data)
+    if len(raw) < 1:
+        return []
+    count = raw[0]
+    if count <= 0:
+        return []
+
+    body = raw[1:]
+    walls: list[Q10Zone] = []
+    for index in range(count):
+        record = body[index * _WALL_RECORD_SIZE : (index + 1) * _WALL_RECORD_SIZE]
+        if len(record) < _WALL_RECORD_SIZE:
+            break  # truncated trailing record; stop rather than misread
+        vertices = [
+            (
+                # records are (y, x) on the wire; swap to (x, y) for the caller
+                int.from_bytes(record[2 + p * 4 : 4 + p * 4], "big", signed=True),
+                int.from_bytes(record[p * 4 : 2 + p * 4], "big", signed=True),
+            )
+            for p in range(2)
+        ]
+        walls.append(Q10Zone(type=ZONE_TYPE_VIRTUAL_WALL, vertices=vertices))
+    return walls
+
+
 # Observed ``type`` values, confirmed against an ss07 Q10 (firmware 03.11.24) and
 # cross-checked with the ioBroker roborock adapter: 2 = no-mop, 3 = door
-# threshold, 1 = virtual wall. Any other value (including 0) is a no-go zone.
-# In practice virtual walls arrive on a separate DP (VIRTUAL_WALL_UP 57), so this
-# restricted-zone DP normally only carries 0 / 2 / 3. The raw value is also kept
-# on ``Q10Zone.type`` for callers that recognise it.
+# threshold. Any other value (including 0) is a no-go zone. The raw value is also
+# kept on ``Q10Zone.type`` for callers that recognise it.
+#
+# Virtual walls arrive on a separate DP (VIRTUAL_WALL_UP 57) with their own frame
+# (see :func:`parse_virtual_wall_blob`), so this restricted-zone DP only carries
+# 0 / 2 / 3 -- never a 1.  ``ZONE_TYPE_VIRTUAL_WALL`` is kept here only to tag the
+# walls that :func:`parse_virtual_wall_blob` produces.
 #
 # Corrected from an earlier reading that treated type 3 as no-mop -- 3 is the
 # door-threshold rectangle; the no-mop area reads back as type 2. Reported and

tests/map/test_b01_q10_overlays.py

@@ -7,6 +7,7 @@
     ZONE_TYPE_NO_MOP,
     ZONE_TYPE_THRESHOLD,
     ZONE_TYPE_VIRTUAL_WALL,
+    parse_virtual_wall_blob,
     parse_zone_blob,
 )
 
@@ -71,3 +72,51 @@ def test_parse_zone_blob_real_record_size_inferred() -> None:
     rect = _rect(ZONE_TYPE_NO_GO, [(100, 200), (300, 200), (300, 50), (100, 50)])
     zones = parse_zone_blob(_blob(1, [rect], record_size=38))
     assert len(zones) == 1 and zones[0].vertices[0] == (100, 200)
+
+
+def test_parse_virtual_wall_blob_real_capture() -> None:
+    """Real DP-57 read-back from an ss07 (one wall drawn in the app).
+
+    Frame is ``[count]`` + 8-byte ``(y, x)`` records -- no version byte. The
+    decoder swaps axes to ``(x, y)`` so walls share the restricted-zone order.
+    Provenance: PR #850 review thread.
+    """
+    walls = parse_virtual_wall_blob("Aflu+cX87PoO")
+    assert len(walls) == 1
+    assert walls[0].type == ZONE_TYPE_VIRTUAL_WALL
+    assert walls[0].vertices == [(-1595, -1682), (-1522, -788)]
+
+
+def test_parse_virtual_wall_blob_empty_variants() -> None:
+    assert parse_virtual_wall_blob(None) == []
+    assert parse_virtual_wall_blob(b"\x00") == []  # device's "no walls" sentinel
+    assert parse_virtual_wall_blob("AA==") == []  # base64 of 0x00
+
+
+def test_parse_virtual_wall_blob_multiple_walls() -> None:
+    """Two walls back-to-back; each is a separate 8-byte (y, x) record."""
+    blob = bytes([2]) + bytes(
+        [
+            0x00, 0x0A, 0x00, 0x14, 0x00, 0x1E, 0x00, 0x28,  # (y,x)=(10,20)->(30,40)
+            0xFF, 0xFB, 0x00, 0x05, 0xFF, 0xF6, 0x00, 0x0A,  # (y,x)=(-5,5)->(-10,10)
+        ]
+    )
+    walls = parse_virtual_wall_blob(blob)
+    assert [w.vertices for w in walls] == [[(20, 10), (40, 30)], [(5, -5), (10, -10)]]
+
+
+def test_parse_virtual_wall_blob_truncated_record_dropped() -> None:
+    """A trailing record shorter than 8 bytes is dropped, not misread."""
+    blob = bytes([2]) + bytes([0x00, 0x0A, 0x00, 0x14, 0x00, 0x1E, 0x00, 0x28]) + b"\x00\x00"
+    walls = parse_virtual_wall_blob(blob)
+    assert [w.vertices for w in walls] == [[(20, 10), (40, 30)]]
+
+
+def test_zone_parser_misframes_virtual_wall_blob() -> None:
+    """The restricted-zone parser must NOT be used on DP 57 -- it mis-frames it.
+
+    Regression guard for the original bug: a DP-57 blob fed to parse_zone_blob
+    reads the leading 0x01 as a version and the next coordinate byte as a record
+    count, yielding garbage (here: nothing), so DP 57 needs its own decoder.
+    """
+    assert parse_zone_blob("Aflu+cX87PoO") != parse_virtual_wall_blob("Aflu+cX87PoO")