Skip to content

One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.

50.6 KB
Raw Blame
"""Synthetic crossing rows and registers; no desktop imports or real settings."""

import copy
import random
import unittest

from core import protocol, settings_sync, ways

A, B, C, P = [protocol.id_text(bytes([n]) * 16) for n in (1, 2, 3, 4)]


def raw():
    return dict(schema=6, machine_id=A, peers=[dict(id=B, port=24820, send=True,
        allow_drive=True, linked=True, side="right", ways=dict(edge=False, thirds=["start"],
        edges=["left"], corner=False, notch=False))], zones=[],
        layout={A: dict(x=0, y=0, w=160, h=100), B: dict(x=160, y=0, w=160, h=100)})


class ProfilesTests(unittest.TestCase):
    def api(self):
        from core import profiles
        return profiles

    def upgraded(self):
        p = self.api()
        saved, notes = p.before_load(raw(), now=100)
        self.assertIn("upgraded", notes)
        return p.after_load(saved, platform="mac", now=100)[0]

    def test_upgrade_and_normalisation_do_not_lose_raw_ways(self):
        p = self.api()
        original = raw()
        saved, _ = p.before_load(original, now=100)
        self.assertEqual(saved["crossing_own"]["saved"][0]["row"], p.live_row(original))
        saved["peers"][0]["ways"]["notch"] = True
        saved, _ = p.after_load(saved, platform="mac", now=100)
        self.assertEqual(saved["crossing_own"]["row"], p.live_row(saved))
        self.assertNotIn("crossing_own", original)

    def test_reconcile_captures_local_edit_once_and_applied_is_actual(self):
        p = self.api()
        saved = self.upgraded()
        previous = copy.deepcopy(saved["crossing_own"]["row"])
        saved["peers"][0]["ways"]["edge"] = True
        saved, paths = p.reconcile(saved, platform="mac", now=101)
        self.assertTrue(saved["crossing_own"]["row"][B]["ways"]["edge"])
        self.assertEqual(saved["crossing_own"]["applied"], p.live_row(saved))
        self.assertIn(previous, [x["row"] for x in saved["crossing_own"]["saved"]])
        count = len(saved["crossing_own"]["saved"])
        saved["peers"][0]["ways"]["thirds"] = ["end"]
        saved, _ = p.reconcile(saved, platform="mac", now=102)
        self.assertEqual(count, len(saved["crossing_own"]["saved"]))

    def test_edit_while_sending_is_off_is_kept_when_it_is_turned_back_on(self):
        # Review of ccce011e, finding 1: the edit was never captured and was projected over.
        p = self.api()
        saved = self.upgraded()
        saved["peers"].append(dict(id=C, port=24820, send=True, ways={"edge": False}))
        saved["peers"][0]["send"] = False
        saved, _ = p.reconcile(saved, platform="mac", now=101)
        saved["peers"][0]["ways"]["thirds"] = ["end"]
        saved["peers"][0]["notch_return"] = True
        saved, _ = p.reconcile(saved, platform="mac", now=102)
        self.assertEqual(saved["crossing_own"]["row"][B]["ways"]["thirds"], ["end"])
        self.assertTrue(saved["crossing_own"]["row"][B]["notch_return"])
        self.assertFalse(saved["crossing_own"]["row"][C]["ways"]["edge"])
        saved["peers"][0]["send"] = True
        saved, _ = p.reconcile(saved, platform="mac", now=103)
        self.assertEqual(saved["peers"][0]["ways"]["thirds"], ["end"])
        self.assertTrue(saved["peers"][0]["notch_return"])

    def test_edit_while_sending_is_off_in_an_older_beamer_is_kept(self):
        p = self.api()
        saved = self.upgraded()
        saved["peers"][0]["send"] = False
        saved, _ = p.reconcile(saved, platform="mac", now=101)
        saved["peers"][0]["ways"]["thirds"] = ["end"]
        saved, notes = p.before_load(saved, now=102)
        self.assertIn("older_version", notes)
        saved["peers"][0]["send"] = True
        saved, _ = p.after_load(saved, platform="mac", now=102)
        self.assertEqual(saved["peers"][0]["ways"]["thirds"], ["end"])

    def test_a_left_out_machine_never_takes_the_notch_from_one_in_use(self):
        # Review finding 4: row order gave the notch to a left-out machine and cleared the active one's.
        from core import crossing_state
        p = self.api()
        saved = self.upgraded()
        saved["peers"].insert(0, dict(id=C, port=24820, send=True, left_out=True,
                                      ways=dict(edge=False, notch=False)))
        saved, _ = p.reconcile(saved, platform="mac", now=101)
        saved = crossing_state.set_same_ways(saved, True, platform="mac", now=102)["settings"]
        desk = saved["crossing_desk"]
        row = copy.deepcopy(desk["profiles"][p.DESK_ID]["rows"][A]["value"])
        row = {C: row[C], B: row[B]}
        row[C]["ways"]["notch"] = row[B]["ways"]["notch"] = True
        desk["profiles"][p.DESK_ID]["rows"][A] = dict(value=row, set_at=200, by=B)
        saved, _ = p.reconcile(saved, platform="mac", now=201)
        live = {entry["id"]: entry["ways"]["notch"] for entry in saved["peers"]}
        self.assertEqual(live, {C: False, B: True})
        self.assertEqual([zone["peer"] for zone in saved["zones"] if zone.get("kind") == "notch"], [B])
        again, _ = p.reconcile(saved, platform="mac", now=202)
        self.assertEqual(again["peers"], saved["peers"])

    def test_profiles_made_apart_still_merge(self):
        # Review finding 2: two machines each making an eighth profile rejected each other's desk.
        from core import crossing_state
        p = self.api()
        base = self.upgraded()
        base["peers"][0].update(linked=True, allow_drive=True)
        for n in range(6):
            base = crossing_state.new_profile(base, f"P{n}", platform="mac", now=110 + n)["settings"]
        one = crossing_state.new_profile(base, "Mine", platform="mac", now=120)["settings"]
        two = crossing_state.new_profile(base, "Theirs", platform="mac", now=121)["settings"]
        self.assertEqual(len(p.profile_list(one)), 8)
        for frame in p.frames(p.desk_message(two)):
            merged = crossing_state.desk_arrived(one, frame, source=B, platform="mac", now=130)
            self.assertTrue(merged["accepted"], merged["reason"])
            one = merged["settings"]
        self.assertEqual(len(p.profile_list(one)), 9)
        self.assertTrue(all(len(p._json(f)) <= p.MAX_DESK_BYTES for f in p.frames(p.desk_message(one))))

    def test_a_profile_grown_on_two_machines_apart_still_travels_and_merges(self):
        # Re-review, finding 2: whole-profile frames could outgrow the frame bound once merged.
        p = self.api()
        peers = [protocol.id_text(bytes([n]) * 15 + b"\x01") for n in range(10, 42)]
        row = {peer: {"ways": {"edge": True, "thirds": ["start", "middle", "end"], "edges": ["left", "top"],
                               "corner": True, "corner_at": "top_left", "corners": ["top_left", "bottom_right"],
                               "notch": False}, "notch_return": False} for peer in peers}
        machines = [protocol.id_text(bytes([n]) * 15 + b"\x02") for n in range(50, 82)]
        saved = self.upgraded()
        saved["peers"][0].update(linked=True, allow_drive=True)
        rows = {m: dict(value=copy.deepcopy(row), set_at=300 + i, by=B) for i, m in enumerate(machines)}
        desk = {"profiles": {p.DESK_ID: {"rows": rows}}}
        sent = p.frames(desk)
        self.assertGreater(len(sent), 1)
        self.assertTrue(all(len(p._json(frame)) <= p.MAX_DESK_BYTES for frame in sent))
        for frame in sent:
            saved, *_rest, accepted, reason = p.merge_desk(saved, frame, source=B, now=400)
            self.assertTrue(accepted, reason)
        self.assertEqual(set(saved["crossing_desk"]["profiles"][p.DESK_ID]["rows"]) & set(machines), set(machines))
        self.assertLess(p.desk_size(saved), p.MAX_DESK_BYTES)

    def test_making_profiles_prunes_removed_profiles_at_receiver_limit(self):
        from core import crossing_state
        p = self.api()
        saved = self.upgraded()
        for n in range(p.MAX_HELD - 1):
            out = crossing_state.new_profile(saved, f"P{n}", platform="mac", now=500 + 2 * n)
            self.assertTrue(out["accepted"], out["reason"])
            saved = out["settings"]
            pid = next(pid for pid, profile in saved["crossing_desk"]["profiles"].items()
                       if profile.get("name", {}).get("value") == f"P{n}")
            saved = crossing_state.remove_profile(saved, pid, platform="mac", now=501 + 2 * n)["settings"]
        desk = saved["crossing_desk"]
        self.assertEqual(len(desk["profiles"]), p.MAX_HELD)
        self.assertEqual([pid for pid in desk["profiles"] if not p.removed(desk, pid)], [p.DESK_ID])

        out = crossing_state.new_profile(saved, "After cleanup", platform="mac", now=700)
        self.assertTrue(out["accepted"], out["reason"])
        self.assertLessEqual(len(out["settings"]["crossing_desk"]["profiles"]), p.MAX_HELD)

    def test_merging_oversize_tombstone_unions_is_order_independent(self):
        from core import crossing_state
        p = self.api()

        def tombstones(start, count):
            return {protocol.id_text(bytes([n]) * 16): {"removed": {"set_at": n % 10 + 10, "by": B}}
                    for n in range(start, start + count)}

        left = {"profiles": tombstones(10, 40)}
        right = {"profiles": tombstones(60, 40)}
        results = []
        for order in ((left, right), (right, left)):
            saved = self.upgraded()
            saved["peers"][0].update(linked=True, allow_drive=True)
            for state in order:
                saved, *_rest, accepted, reason = p.merge_desk(saved, state, source=B, now=200)
                self.assertTrue(accepted, reason)
            results.append(saved["crossing_desk"]["profiles"])

        self.assertEqual(set(results[0]), set(results[1]))
        self.assertEqual(len(results[0]), p.MAX_HELD)
        self.assertIn(p.DESK_ID, results[0])
        all_tombstones = left["profiles"] | right["profiles"]
        retained = sorted(all_tombstones, key=lambda pid: (
            all_tombstones[pid]["removed"]["set_at"], pid))[-(p.MAX_HELD - 1):]
        self.assertEqual(set(results[0]) - {p.DESK_ID}, set(retained))

    def test_pruning_never_drops_the_active_profile(self):
        p = self.api()
        settings = {"crossing_own": {}, "crossing_desk": {"active": {"value": P}, "profiles": {
            P: {"removed": {"set_at": 0, "by": B}},
            A: {"removed": {"set_at": 1, "by": B}},
            B: {"removed": {"set_at": 2, "by": B}},
        }}}

        p.prune_removed(settings, 2)

        profiles = settings["crossing_desk"]["profiles"]
        self.assertIn(P, profiles)
        self.assertNotIn(A, profiles)
        self.assertIn(B, profiles)
        self.assertEqual(p.pruned(settings), [A])

    def test_a_late_delta_for_a_pruned_profile_does_not_bring_it_back(self):
        # Sol review: Q prunes the oldest tombstone, then that profile's own name arrives late.
        p = self.api()
        ids = [protocol.id_text(bytes([n]) * 16) for n in range(1, 66)]
        oldest, others, q = ids[0], ids[1:63], ids[63]
        tombs = {"profiles": {pid: {"removed": {"set_at": 10 + n, "by": B}}
                              for n, pid in enumerate([oldest, *others])}}
        name = {"profiles": {oldest: {"name": {"value": "Old", "set_at": 5, "by": B}}}}
        new = {"profiles": {q: {"name": {"value": "Q", "set_at": 150, "by": B}}}}
        results = []
        for order in ((tombs, new, name), (tombs, name, new)):
            saved = self.upgraded()
            saved["peers"][0].update(linked=True, allow_drive=True)
            for state in order:
                saved, *_rest, accepted, reason = p.merge_desk(saved, state, source=B, now=200)
                self.assertTrue(accepted, reason)
            results.append(saved["crossing_desk"]["profiles"])
        self.assertEqual(set(results[0]), set(results[1]))
        self.assertNotIn(oldest, results[0])
        self.assertIn(q, results[0])

    def test_a_late_active_register_for_a_pruned_profile_is_rejected(self):
        from core import crossing_state
        p = self.api()
        saved = self.upgraded()
        saved["peers"][0].update(linked=True, allow_drive=True)
        saved["crossing_desk"]["profiles"][p.DESK_ID]["home"]["shake"] = dict(
            value=False, set_at=100, by=A)
        saved = crossing_state.set_same_ways(saved, True, platform="mac", now=100)["settings"]
        made = crossing_state.new_profile(saved, "Q", platform="mac", now=101)
        self.assertTrue(made["accepted"], made["reason"])
        saved = made["settings"]
        q = saved["crossing_desk"]["profiles"].keys() - {p.DESK_ID}
        self.assertEqual(len(q), 1)
        q = q.pop()
        selected = crossing_state.switch_profile(saved, q, platform="mac", now=102)
        self.assertTrue(selected["accepted"], selected["reason"])
        saved = selected["settings"]
        previous = p.DESK_ID
        returned = crossing_state.switch_profile(saved, previous, platform="mac", now=103)
        self.assertTrue(returned["accepted"], returned["reason"])
        saved = crossing_state.remove_profile(returned["settings"], q, platform="mac", now=104)["settings"]

        tombstones = {protocol.id_text(bytes([n]) * 16): {
            "removed": {"set_at": 200 + n, "by": B}}
            for n in range(1, p.MAX_HELD)}
        saved, _, _, _, accepted, reason = p.merge_desk(
            saved, {"profiles": tombstones}, source=B, now=400)
        self.assertTrue(accepted, reason)
        self.assertIn(q, p.pruned(saved))
        self.assertNotIn(q, saved["crossing_desk"]["profiles"])
        before_active = copy.deepcopy(saved["crossing_desk"]["active"])
        before_shake = p.shake_on(saved)

        newer = {"active": {"value": q, "set_at": before_active["set_at"] + 50, "by": B},
                 "profiles": {q: {"name": {"value": "Q", "set_at": 900, "by": B},
                                  "home": {"shake": {"value": False, "set_at": 900, "by": B}}}}}
        merged, _, forward, answer, accepted, reason = p.merge_desk(
            saved, newer, source=B, now=1000)
        self.assertTrue(accepted, reason)
        self.assertEqual(merged["crossing_desk"]["active"]["value"], previous)
        self.assertGreater(merged["crossing_desk"]["active"]["set_at"], newer["active"]["set_at"])
        self.assertNotIn(q, merged["crossing_desk"]["profiles"])
        self.assertEqual(forward["active"]["value"], previous)
        self.assertGreater(forward["active"]["set_at"], newer["active"]["set_at"])
        self.assertEqual(answer["active"]["value"], previous)
        self.assertGreater(answer["active"]["set_at"], newer["active"]["set_at"])
        self.assertEqual(p.shake_on(merged), before_shake)

        older = {"active": {"value": q, "set_at": before_active["set_at"] - 1, "by": B}}
        unchanged, _, _, older_reply, accepted, reason = p.merge_desk(
            saved, older, source=B, now=1001)
        self.assertTrue(accepted, reason)
        self.assertEqual(unchanged["crossing_desk"]["active"], before_active)
        self.assertEqual(older_reply["active"], before_active)

    def test_merge_still_refuses_live_profile_overflow(self):
        p = self.api()
        saved = self.upgraded()
        saved["peers"][0].update(linked=True, allow_drive=True)
        live = {protocol.id_text(bytes([n]) * 16): {
            "name": {"value": f"P{n}", "set_at": n, "by": B}}
            for n in range(1, p.MAX_HELD + 1)}

        result = p.merge_desk(saved, {"profiles": live}, source=B, now=200)

        self.assertFalse(result[4])
        self.assertEqual(result[5], "desk_full")

    def test_notch_from_a_received_row_is_stable_through_events(self):
        # reconcile and _initial must agree, or each event's untick reads as a page edit and is sent.
        from core import crossing_state
        p = self.api()
        saved = self.upgraded()
        saved["peers"].append(dict(id=C, port=24820, send=True, ways=dict(edge=False, notch=False)))
        saved, _ = p.reconcile(saved, platform="mac", now=101)
        saved = crossing_state.set_same_ways(saved, True, platform="mac", now=102)["settings"]
        desk = saved["crossing_desk"]
        row = copy.deepcopy(desk["profiles"][p.DESK_ID]["rows"][A]["value"])
        row[B]["ways"]["notch"] = row[C]["ways"]["notch"] = True
        desk["profiles"][p.DESK_ID]["rows"][A] = dict(value=row, set_at=200, by=B)
        saved, _ = p.reconcile(saved, platform="mac", now=201)
        held = copy.deepcopy(desk["profiles"][p.DESK_ID]["rows"][A])
        for now in (202, 203):
            out = crossing_state.link_up(saved, B, platform="mac", own_displays={}, now=now)
            self.assertEqual(out["settings"]["crossing_desk"]["profiles"][p.DESK_ID]["rows"][A], held)
            self.assertNotIn(("row", p.DESK_ID, A), [tuple(x) for x in out["send_desk"]])
            saved = out["settings"]

    def test_another_machines_row_draws_through_the_same_ledger_reach(self):
        from core import crossing_state
        p = self.api()
        saved = self.upgraded()
        saved["peers"][0].update(linked=True, allow_drive=True, name="PC")
        saved = crossing_state.set_same_ways(saved, True, platform="mac", now=101)["settings"]
        row = {A: {"ways": {"edge": True, "thirds": ["middle"], "edges": [], "corner": False,
                            "corner_at": "top_left", "corners": [], "notch": False}, "notch_return": False}}
        saved["crossing_desk"]["profiles"][p.DESK_ID]["rows"][B] = dict(value=row, set_at=200, by=B)
        view = p.view_settings(saved, B)
        self.assertEqual(view["machine_id"], B)
        self.assertNotIn("token", view["peers"][0])
        self.assertEqual(view["peers"][0]["side"], "left")
        held = ways.ways(view, A)
        self.assertEqual((held["side"], held["parts"]), ("left", ["middle"]))
        sides = ways.reach(view, A, platform=p.view_platform(saved, B))["sides"]
        self.assertEqual(sides["left"]["state"], "contact")
        self.assertEqual(p.tile_word(saved, A, linked=True, caps=()), "Desk")
        self.assertEqual(p.tile_word(saved, B, linked=True, caps=("profiles",)), "Desk")
        self.assertEqual(p.tile_word(saved, B, linked=False, caps=("profiles",)), "Offline")
        self.assertEqual(p.tile_word(saved, B, linked=True, caps=()), "Older")

    def test_same_ways_views_shelf_a_left_out_peer_with_its_stale_tile(self):
        from core import crossing_state
        p = self.api()
        saved = self.upgraded()
        saved["peers"][0].update(linked=True, allow_drive=True, name="Rig", side="left")
        saved["peers"].append(dict(id=C, port=24821, send=True, allow_drive=True, linked=True,
                                   left_out=True, ways=dict(edge=True, thirds=list(ways.PARTS),
                                   edges=[], corner=False, notch=False)))
        saved["layout"] = {
            A: dict(x=-640, y=-50, w=160, h=100),
            B: dict(x=-820, y=-50, w=180, h=112),
            C: dict(x=-800, y=-50, w=160, h=100),
        }
        saved["zones"] = [{"peer": B, "kind": "edge", "side": "left"}]
        own_zones = copy.deepcopy(saved["zones"])
        saved = crossing_state.set_same_ways(saved, True, platform="mac", now=102)["settings"]

        self.assertTrue(next(peer for peer in saved["peers"] if peer["id"] == C)["left_out"])
        self.assertEqual(saved["zones"], own_zones)
        viewed = p.view_settings(saved, B)
        states = ways.compile_layout(viewed, viewed["layout"], platform="mac", now=103)["tiles"]
        self.assertNotEqual(states.get(A, {}).get("state"), "overlap")
        self.assertNotEqual(states.get(B, {}).get("state"), "overlap")
        self.assertEqual(states[C]["state"], "dormant")
        self.assertNotIn(C, p.machines_on_desk(saved))
        self.assertIn(B, p.machines_on_desk(saved))

    def test_received_desk_view_shelves_a_peer_left_out_here(self):
        from core import crossing_state
        p = self.api()
        sender = self.upgraded()
        sender["peers"][0].update(linked=True, allow_drive=True, name="Rig", side="left")
        sender["peers"].append(dict(id=C, port=24821, send=True, allow_drive=True, linked=True,
                                    left_out=True, ways=dict(edge=True, thirds=list(ways.PARTS),
                                    edges=[], corner=False, notch=False)))
        sender["layout"] = {
            A: dict(x=-640, y=-50, w=160, h=100),
            B: dict(x=-820, y=-50, w=180, h=112),
            C: dict(x=-800, y=-50, w=160, h=100),
        }
        sender = crossing_state.set_same_ways(sender, True, platform="mac", now=102)["settings"]
        receiver_raw = copy.deepcopy(raw())
        receiver_raw["machine_id"] = B
        receiver_raw["peers"] = [
            dict(id=A, port=24820, send=True, allow_drive=True, linked=True, side="right",
                 ways=dict(edge=True, thirds=list(ways.PARTS), edges=[], corner=False, notch=False)),
            dict(id=C, port=24821, send=True, allow_drive=True, linked=True, left_out=True,
                 ways=dict(edge=True, thirds=list(ways.PARTS), edges=[], corner=False, notch=False)),
        ]
        receiver_raw["layout"] = {
            B: dict(x=-820, y=-50, w=180, h=112),
            A: dict(x=-640, y=-50, w=160, h=100),
            C: dict(x=-800, y=-50, w=160, h=100),
        }
        receiver, _ = p.before_load(receiver_raw, now=100)
        receiver = p.after_load(receiver, platform="pc", now=101)[0]
        receiver_zones = copy.deepcopy(receiver["zones"])
        received = crossing_state.desk_arrived(
            receiver, p.desk_message(sender), source=A, platform="pc", now=103)["settings"]

        self.assertEqual(received["zones"], receiver_zones)
        viewed = p.view_settings(received, A)
        states = ways.compile_layout(viewed, viewed["layout"], platform="pc", now=104)["tiles"]
        self.assertNotEqual(states.get(A, {}).get("state"), "overlap")
        self.assertNotEqual(states.get(B, {}).get("state"), "overlap")
        self.assertEqual(states[C]["state"], "dormant")
        self.assertTrue(next(peer for peer in received["peers"] if peer["id"] == C)["left_out"])
        self.assertIn(A, p.machines_on_desk(received))
        self.assertNotIn(C, p.machines_on_desk(received))

    def test_no_way_back_ignores_a_shelved_peers_stale_tile(self):
        p = self.api()
        saved = self.upgraded()
        saved["peers"][0].update(linked=True, allow_drive=True, side="left")
        saved["peers"].append(dict(id=C, port=24821, send=True, left_out=True,
                                   ways=dict(edge=True, thirds=list(ways.PARTS), edges=[], corner=False, notch=False)))
        saved["crossing_own"]["row"][B]["ways"].update(edge=True, thirds=list(ways.PARTS))
        from core import crossing_state
        saved = crossing_state.set_same_ways(saved, True, platform="mac", now=102)["settings"]
        remote_row = dict(
            value=p.canonical_row({
                A: {"ways": {"edge": True, "thirds": list(ways.PARTS), "edges": [],
                             "corner": False, "notch": False}},
                C: {"ways": {"edge": True, "thirds": list(ways.PARTS), "edges": [],
                             "corner": False, "notch": False}},
            }),
            set_at=200, by=B)
        saved["crossing_desk"]["profiles"][p.DESK_ID]["rows"][B] = remote_row
        saved["crossing_desk"]["status"][B] = dict(set_at=201, by=B, value={
            "platform": "pc", "app": "1.5.5", "in_force": "desk", "profile": p.DESK_ID,
            "row": [200, B], "waiting": [],
        })
        saved["layout"] = {
            A: dict(x=-640, y=-50, w=160, h=100),
            B: dict(x=-820, y=-50, w=180, h=112),
            C: dict(x=-640, y=-50, w=160, h=100),
        }

        self.assertEqual(p.no_way_back(saved, A), [])

    def test_removal_and_switch_in_either_order_leave_the_same_desk(self):
        # Review finding 3: a removal arriving before the switch away from it was erased.
        p = self.api()
        desk = {"on": dict(value=True, set_at=100, by=B), "active": dict(value=P, set_at=101, by=B),
                "profiles": {p.DESK_ID: {"removed": dict(set_at=102, by=B)},
                             P: {"name": dict(value="Sofa", set_at=99, by=B), "rows": {}, "home": {}}}}
        switch = {"active": desk["active"], "profiles": {P: desk["profiles"][P]}}
        removal = {"profiles": {p.DESK_ID: desk["profiles"][p.DESK_ID]}}
        results = []
        for order in ((switch, removal), (removal, switch)):
            saved = self.upgraded()
            saved["peers"][0].update(linked=True, allow_drive=True)
            for part in order:
                saved, *_rest, accepted, reason = p.merge_desk(saved, part, source=B, now=200)
                self.assertTrue(accepted, reason)
            results.append(saved["crossing_desk"]["profiles"])
        self.assertEqual(results[0], results[1])
        self.assertEqual(results[0][p.DESK_ID]["removed"], dict(set_at=102, by=B))

    def test_old_version_edits_override_without_writing_desk(self):
        p = self.api()
        saved = self.upgraded()
        desk = copy.deepcopy(saved["crossing_desk"])
        saved["peers"][0]["ways"]["edge"] = True
        saved, notes = p.before_load(saved, now=101)
        self.assertIn("older_version", notes)
        self.assertTrue(saved["crossing_own"]["use_own"])
        self.assertEqual(saved["crossing_desk"], desk)

    def test_wire_invalid_row_drops_alone_and_ahead_bound(self):
        p = self.api()
        row = p.live_row(raw())
        invalid = copy.deepcopy(row)
        invalid[B]["ways"]["thirds"] = []
        data = dict(on=False, set_at=0, by="", desk=dict(on=dict(value=True, set_at=700, by=A),
            profiles={p.DESK_ID: dict(rows={A: dict(value=invalid, set_at=1, by=A),
                B: dict(value=row, set_at=2, by=B)})}, status={}))
        parsed = p.read_desk_state(data, now=100)
        self.assertNotIn(A, parsed["profiles"][p.DESK_ID]["rows"])
        self.assertIn(B, parsed["profiles"][p.DESK_ID]["rows"])
        self.assertIn("on", parsed)
        data["desk"]["on"]["set_at"] += 1
        self.assertNotIn("on", p.read_desk_state(data, now=100))

    def test_wire_size_and_capability_and_separate_envelope(self):
        p = self.api()
        data = dict(on=False, set_at=0, by="", layout={"large": "picture"}, design_sync={},
                    desk={"padding": "x" * p.MAX_DESK_BYTES})
        self.assertIsNone(p.read_desk_state(data, now=100))
        self.assertNotIn("desk", settings_sync.for_capabilities(data, ()))
        packet = settings_sync.desk_message_data(data, {"on": {"value": True}})
        self.assertEqual(set(packet), {"on", "set_at", "by", "desk"})

    def test_unreadable_objects_are_kept_aside(self):
        p = self.api()
        saved = raw()
        saved.update(crossing_own=[1], crossing_desk="bad")
        saved, notes = p.before_load(saved, now=100)
        self.assertEqual(saved["crossing_own_unreadable"], [1])
        self.assertEqual(saved["crossing_desk_unreadable"], "bad")
        self.assertIn("upgraded", notes)

    def test_partial_profile_delta_survives_reload(self):
        p = self.api()
        saved = self.upgraded()
        state = {"profiles": {P: {"rows": {C: dict(value={}, set_at=101, by=B)}}}}
        saved, _, _, _, accepted, _ = p.merge_desk(saved, state, source=B, now=101)
        self.assertTrue(accepted)
        loaded, notes = p.before_load(saved, now=102)
        self.assertEqual(notes, [])
        self.assertIn(P, loaded["crossing_desk"]["profiles"])

    def test_bad_nested_register_is_preserved_not_executed(self):
        p = self.api()
        for path in ("on", "status", "row", "active"):
            with self.subTest(path=path):
                saved = self.upgraded()
                desk = saved["crossing_desk"]
                if path in ("on", "active"):
                    desk[path]["set_at"] = "bad"
                elif path == "status":
                    desk["status"][A]["set_at"] = "bad"
                else:
                    desk["profiles"][p.DESK_ID]["rows"][A] = dict(value={}, set_at="bad", by=A)
                loaded, notes = p.before_load(saved, now=102)
                self.assertIn("upgraded", notes)
                self.assertIn("crossing_desk_unreadable", loaded)
                p.after_load(loaded, platform="pc", now=102)

    def test_gap_fill_does_not_consume_first_edit_archive(self):
        p = self.api()
        saved = self.upgraded()
        saved["peers"].append(dict(id=C, port=24820, send=True, ways={"edge": False}))
        saved, _ = p.reconcile(saved, platform="mac", now=101)
        before_edit = copy.deepcopy(saved["crossing_own"]["row"])
        saved["peers"][0]["ways"]["edge"] = True
        saved, _ = p.reconcile(saved, platform="mac", now=102)
        self.assertIn(before_edit, [item["row"] for item in saved["crossing_own"]["saved"]])

    def test_register_merge_forward_answer_tie_and_no_echo(self):
        p = self.api()
        saved = self.upgraded()
        pid = p.DESK_ID
        state = {"profiles": {pid: {"rows": {A: dict(value=p.live_row(saved), set_at=101, by=B)}}}}
        saved, _, forward, answer, accepted, _ = p.merge_desk(saved, state, source=B, now=101)
        self.assertTrue(accepted)
        self.assertEqual(forward, state)
        self.assertEqual(answer, {})
        same, paths, forward, answer, _, _ = p.merge_desk(saved, state, source=B, now=101)
        self.assertEqual((paths, forward, answer), ([], {}, {}))
        older = copy.deepcopy(state)
        older["profiles"][pid]["rows"][A]["by"] = A
        _, _, forward, answer, _, _ = p.merge_desk(saved, older, source=B, now=101)
        self.assertEqual(forward, {})
        self.assertEqual(answer, state)
        newer = copy.deepcopy(state)
        newer["profiles"][pid]["rows"][A]["by"] = C
        newer["profiles"][pid]["rows"][A]["value"][B]["ways"]["edge"] = True
        saved, _, forward, _, _, _ = p.merge_desk(saved, newer, source=B, now=101)
        self.assertEqual(forward, newer)
        self.assertEqual(saved["crossing_own"]["saved"][-1]["why"], "replaced_by")

    def test_duplicate_delivery_keeps_a_pending_local_edit_and_does_not_echo_again(self):
        from core import crossing_state as events
        from unittest import mock
        p = self.api()
        saved = events.set_same_ways(self.upgraded(), True, platform="mac", now=101)["settings"]
        incoming = p.desk_message(saved)
        saved["peers"][0]["ways"]["thirds"] = ["end"]
        before = copy.deepcopy(saved)

        out = events.desk_arrived(saved, incoming, source=B, platform="mac", now=102)
        self.assertEqual(saved, before, "receiving must not mutate the caller's settings")
        self.assertEqual(p.in_force(out["settings"])[0][B]["ways"]["thirds"], ["end"])
        self.assertIn(("row", p.DESK_ID, A), out["send_desk"])
        self.assertEqual(out["answer"]["profiles"][p.DESK_ID]["rows"][A]["value"][B]["ways"]["thirds"],
                         ["end"])
        settled = out["settings"]
        with mock.patch.object(p, "reconcile", wraps=p.reconcile) as reconcile:
            again = events.desk_arrived(settled, p.desk_message(settled), source=B, platform="mac", now=103)
        self.assertLessEqual(reconcile.call_count, 1, "a duplicate must not repeat the full projection")
        self.assertFalse(again["changed"])
        self.assertEqual((again["send_desk"], again["forward"], again["answer"]), ([], {}, {}))
        again["settings"]["peers"][0]["ways"]["thirds"].append("start")
        self.assertEqual(p.live_row(settled)[B]["ways"]["thirds"], ["end"])

    def test_reconciled_holds_exactly_where_reconcile_would_change_nothing(self):
        from core import crossing_state as events
        p = self.api()
        settled = events.set_same_ways(self.upgraded(), True, platform="mac", now=101)["settings"]

        def variant(change):
            changed = copy.deepcopy(settled)
            change(changed)
            return changed

        cases = {
            "settled": settled,
            "a pending local edit": variant(lambda s: s["peers"][0]["ways"].update(thirds=["end"])),
            "notch_return missing": variant(lambda s: s["peers"][0].pop("notch_return")),
            "applied missing": variant(lambda s: s["crossing_own"].pop("applied")),
            "a new machine": variant(lambda s: s["peers"].append(
                dict(id=C, port=24820, send=True, ways={"edge": False}))),
            "own row missing": variant(lambda s: s["crossing_desk"]["profiles"][p.DESK_ID]["rows"].pop(A)),
            "an older app in status": variant(
                lambda s: s["crossing_desk"]["status"][A]["value"].update(app="1.5.4")),
            "own ways in force": variant(lambda s: s["crossing_own"].update(use_own=True)),
            "sync off": variant(lambda s: s["crossing_desk"]["on"].update(value=False)),
        }
        for platform in ("mac", "pc"):
            for name, settings in cases.items():
                with self.subTest(name, platform=platform):
                    before = copy.deepcopy(settings)
                    again, paths = p.reconcile(settings, platform=platform, now=102)
                    self.assertEqual(p.reconciled(settings, platform=platform),
                                     again == settings and paths == [])
                    self.assertEqual(settings, before)
        self.assertTrue(p.reconciled(settled, platform="mac"))

    def test_a_merge_that_takes_nothing_lends_the_settings_back(self):
        from core import crossing_state as events
        p = self.api()
        settled = events.set_same_ways(self.upgraded(), True, platform="mac", now=101)["settings"]
        held = p.desk_message(settled)
        stale, newer = copy.deepcopy(held), copy.deepcopy(held)
        stale["profiles"][p.DESK_ID]["rows"][A]["set_at"] -= 1
        newer["profiles"][p.DESK_ID]["rows"][A].update(set_at=held["profiles"][p.DESK_ID]["rows"][A]["set_at"] + 1,
                                                      by=B)
        for name, state in (("duplicate", held), ("stale", stale), ("newer", newer)):
            with self.subTest(name):
                before = copy.deepcopy(settled)
                lent = p.merge_desk(settled, state, source=B, now=102, borrow=True)
                copied = p.merge_desk(settled, state, source=B, now=102)
                self.assertEqual(settled, before, "merging must not mutate the caller's settings")
                self.assertEqual(lent, copied)
                self.assertIsNot(copied[0], settled)
                self.assertEqual(lent[0] is settled, name != "newer")
        self.assertTrue(lent[2], "the newer row is forwarded")
        self.assertTrue(p.merge_desk(settled, stale, source=B, now=102, borrow=True)[3], "the stale row is answered")

    def test_active_removal_is_void_and_other_tombstones_survive(self):
        p = self.api()
        saved = self.upgraded()
        saved["crossing_desk"]["profiles"][P] = copy.deepcopy(saved["crossing_desk"]["profiles"][p.DESK_ID])
        state = {"profiles": {pid: {"removed": dict(set_at=101, by=B)} for pid in (P, p.DESK_ID)}}
        saved, _, forward, _, _, _ = p.merge_desk(saved, state, source=B, now=101)
        # The active profile's tombstone is kept, so every machine holds the same desk, but is void.
        self.assertEqual(saved["crossing_desk"]["profiles"][p.DESK_ID]["removed"]["set_at"], 101)
        self.assertFalse(p.removed(saved["crossing_desk"], p.DESK_ID))
        self.assertTrue(p.removed(saved["crossing_desk"], P))
        self.assertIn(p.DESK_ID, forward["profiles"])

    def test_stale_switch_on_never_reseeds_a_live_desk(self):
        from core import crossing_state as events
        p = self.api()
        saved = events.set_same_ways(self.upgraded(), True, platform="mac", now=101)["settings"]
        saved = events.edit_ways(saved, B, edge=True, platform="mac", now=102, live=None, gone=None)["settings"]
        held = copy.deepcopy(saved["crossing_desk"]["profiles"][p.DESK_ID]["rows"][A])
        state = {"on": dict(value=True, set_at=200, by=B)}
        out = events.desk_arrived(saved, state, source=B, platform="mac", now=200)
        self.assertEqual(out["settings"]["crossing_desk"]["profiles"][p.DESK_ID]["rows"][A], held)

    def test_sync_off_keeps_live_and_then_on_keeps_it_again(self):
        from core import crossing_state as events
        p = self.api()
        saved = events.set_same_ways(self.upgraded(), True, platform="mac", now=101)["settings"]
        saved = events.edit_ways(saved, B, edge=True, platform="mac", now=102, live=None, gone=None)["settings"]
        before = p.live_row(saved)
        for enabled in (False, True):
            saved = events.set_same_ways(saved, enabled, platform="mac", now=103)["settings"]
            self.assertEqual(p.live_row(saved), before)
        self.assertTrue(any(item["why"] == "sync_off" for item in saved["crossing_own"]["saved"]))

    def test_notch_resolution_uses_peer_order_and_nonmac_ignores_it(self):
        p = self.api()
        saved = self.upgraded()
        saved["peers"].append(dict(id=C, port=24820, send=True, ways={"edge": False}))
        row = p.live_row(saved)
        row[B]["ways"]["notch"] = row[C]["ways"]["notch"] = True
        saved["crossing_own"]["row"] = {C: row[C], B: row[B]}
        saved["crossing_own"]["applied"] = p.live_row(saved)
        saved, _ = p.reconcile(saved, platform="mac", now=101)
        # The receiving machine's peer order decides, as for corners (spec section 4), not row order.
        self.assertTrue(p.live_row(saved)[B]["ways"]["notch"])
        self.assertFalse(p.live_row(saved)[C]["ways"]["notch"])
        self.assertEqual([zone["peer"] for zone in saved["zones"] if zone.get("kind") == "notch"], [B])
        saved, _ = p.reconcile(saved, platform="pc", now=102)
        self.assertFalse(any(entry["ways"]["notch"] for entry in p.live_row(saved).values()))
        self.assertEqual(saved["crossing_own"]["applied"], p.live_row(saved))

    def test_invalid_status_missing_field_is_dropped_alone(self):
        p = self.api()
        saved = self.upgraded()
        status = copy.deepcopy(saved["crossing_desk"]["status"][A])
        status["value"].pop("row")
        parsed = p.read_desk_state(dict(on=False, set_at=0, by="", desk={"status": {A: status}}), 101)
        self.assertEqual(parsed, {})

    def test_no_way_back_checks_actual_contacts_and_permissions(self):
        p = self.api()
        saved = self.upgraded()
        saved["crossing_own"]["row"][B]["ways"].update(edge=True, edges=[])
        # The target has a return edge enabled, but its chosen third misses the contact.
        back = p.canonical_row({A: {"ways": {"edge": True, "thirds": ["end"]}}})
        saved["crossing_desk"]["profiles"][p.DESK_ID]["rows"][B] = dict(value=back, set_at=1, by=B)
        saved["layout"][B] = dict(x=160, y=0, w=160, h=300)
        self.assertEqual(p.no_way_back(saved, A), [B])
        saved["layout"][B]["x"] = 400
        self.assertEqual(p.no_way_back(saved, A), [])
        saved["layout"][B]["x"] = 160
        saved["peers"][0]["send"] = False
        self.assertEqual(p.no_way_back(saved, A), [])

    def test_no_way_back_does_not_warn_about_machines_it_knows_nothing_of(self):
        # Critique: with Same ways off, and for an older Beamer, every peer was listed.
        p = self.api()
        saved = self.upgraded()
        saved["crossing_own"]["row"][B]["ways"].update(edge=True, edges=[])
        saved["layout"][B] = dict(x=160, y=0, w=160, h=100)
        self.assertEqual(p.no_way_back(saved, A), [])

    def test_active_delta_before_profile_name_converges_after_metadata_arrives(self):
        p = self.api()
        saved = self.upgraded()
        active = {"active": dict(value=P, set_at=101, by=B)}
        saved, _, _, _, _, _ = p.merge_desk(saved, active, source=B, now=101)
        metadata = {"profiles": {P: dict(name=dict(value="Sofa", set_at=100, by=B),
                                         home={"shake": dict(value=True, set_at=100, by=B)}, rows={})}}
        saved, _, _, _, _, _ = p.merge_desk(saved, metadata, source=B, now=102)
        self.assertEqual(saved["crossing_desk"]["active"]["value"], P)
        saved, notes = p.before_load(saved, now=103)
        self.assertEqual(notes, [])

    def test_rows_never_copy_credentials_permissions_or_addresses(self):
        p = self.api()
        saved = raw()
        saved["peers"][0].update(token="synthetic", host="192.0.2.1", send=True, allow_drive=True)
        self.assertEqual(set(p.row_entry(saved, B)), {"ways", "notch_return"})
        row = p.canonical_row({B: {**saved["peers"][0], "notch_return": True}})
        self.assertEqual(set(row[B]), {"ways", "notch_return"})

    def test_status_stamps_only_change_with_value_and_edits_floor_above_on(self):
        from core import crossing_state as events
        p = self.api()
        saved = self.upgraded()
        twice, paths = p.reconcile(saved, platform="mac", now=200)
        self.assertEqual(twice, saved)
        self.assertEqual(paths, [])
        saved = events.set_same_ways(saved, True, platform="mac", now=200)["settings"]
        saved = events.edit_ways(saved, B, edge=True, platform="mac", now=150, live=None, gone=None)["settings"]
        desk = saved["crossing_desk"]
        self.assertGreater(desk["profiles"][p.DESK_ID]["rows"][A]["set_at"], desk["on"]["set_at"])

    def test_caller_version_survives_event_reconciliation(self):
        from core import crossing_state as events
        p = self.api()
        saved, _ = p.reconcile(self.upgraded(), platform="mac", now=101, app="1.5.4-test")
        saved = events.set_same_ways(saved, True, platform="mac", now=102)["settings"]
        self.assertEqual(saved["crossing_desk"]["status"][A]["value"]["app"], "1.5.4-test")

    def test_archive_deduplicates_content_keeping_latest_attribution(self):
        p = self.api()
        saved = self.upgraded()
        row = saved["crossing_own"]["row"]
        p.archive(saved, row, "restored", 200, by=B)
        self.assertEqual(len(saved["crossing_own"]["saved"]), 1)
        self.assertEqual(saved["crossing_own"]["saved"][0]["at"], 200)
        self.assertEqual(saved["crossing_own"]["saved"][0]["by"], B)

    def test_profile_limit_and_whole_oversize_receipt(self):
        from core import crossing_state as events
        p = self.api()
        saved = self.upgraded()
        for n in range(7):
            out = events.new_profile(saved, f"Place {n}", platform="mac", now=101 + n)
            self.assertTrue(out["accepted"])
            saved = out["settings"]
        out = events.new_profile(saved, "Ninth", platform="mac", now=110)
        self.assertFalse(out["accepted"])
        self.assertEqual(out["reason"], "desk_full")
        self.assertEqual(out["settings"], saved)
        state = {"padding": "x" * p.MAX_DESK_BYTES, "on": dict(value=True, set_at=110, by=B)}
        out = events.desk_arrived(saved, state, source=B, platform="mac", now=110)
        self.assertFalse(out["accepted"])
        self.assertEqual(out["settings"], saved)

    def test_removed_peer_repair_uses_kept_ways_without_permissions(self):
        p = self.api()
        saved = self.upgraded()
        wanted = copy.deepcopy(saved["crossing_own"]["row"][B])
        saved["peers"] = []
        saved, _ = p.reconcile(saved, platform="mac", now=101)
        self.assertEqual(saved["crossing_own"]["row"][B], wanted)
        saved["peers"] = [dict(id=B, port=24820, send=True, allow_drive=False, ways={"edge": True})]
        saved, _ = p.reconcile(saved, platform="mac", now=102)
        self.assertEqual(p.row_entry(saved, B), wanted)
        self.assertFalse(saved["peers"][0]["allow_drive"])

    def test_return_warning_uses_the_profile_reported_in_force(self):
        p = self.api()
        saved = self.upgraded()
        saved["crossing_own"]["row"][B]["ways"].update(edge=True, edges=[])
        desk = saved["crossing_desk"]
        back = p.canonical_row({A: {"ways": {"edge": True}}})
        desk["profiles"][p.DESK_ID]["rows"][B] = dict(value=back, set_at=10, by=B)
        desk["profiles"][P] = dict(rows={B: dict(value={}, set_at=11, by=B)}, home={})
        desk["status"][B] = dict(set_at=12, by=B, value=dict(platform="pc", in_force="desk", profile=P, row=[11, B]))
        self.assertEqual(p.no_way_back(saved, A), [B])
        desk["status"][B]["value"]["in_force"] = "own"
        self.assertEqual(p.no_way_back(saved, A), [])

    def test_two_machines_seed_different_ways_and_converge(self):
        from core import crossing_state as events
        p = self.api()
        a = self.upgraded()
        b = raw()
        b["machine_id"], b["peers"][0]["id"] = B, A
        b["peers"][0]["ways"].update(edge=True, thirds=["end"], edges=[])
        b, _ = p.before_load(b, now=100)
        b, _ = p.after_load(b, platform="pc", now=100)
        a_live, b_live = p.live_row(a), p.live_row(b)
        a = events.set_same_ways(a, True, platform="mac", now=101)["settings"]
        arrival = events.desk_arrived(b, p.desk_message(a), source=A, platform="pc", now=102)
        b = arrival["settings"]
        a = events.desk_arrived(a, p.desk_message(b), source=B, platform="mac", now=103)["settings"]
        self.assertEqual(p.live_row(a), a_live)
        self.assertEqual(p.live_row(b), b_live)
        self.assertEqual(a["crossing_desk"]["profiles"], b["crossing_desk"]["profiles"])
        for own, state in ((A, a), (B, b)):
            self.assertIn(own, state["crossing_desk"]["profiles"][p.DESK_ID]["rows"])

    def test_offline_row_edit_wins_seed_but_waits_for_local_override(self):
        from core import crossing_state as events
        p = self.api()
        saved = self.upgraded()
        own = copy.deepcopy(saved["crossing_own"]["row"])
        wanted = copy.deepcopy(own)
        wanted[B]["ways"]["edge"] = True
        state = {"on": dict(value=True, set_at=101, by=B), "profiles": {p.DESK_ID: {
            "rows": {A: dict(value=wanted, set_at=102, by=B)}}}}
        saved = events.set_own_ways(saved, True, platform="mac", now=100)["settings"]
        saved = events.desk_arrived(saved, state, source=B, platform="mac", now=604900)["settings"]
        self.assertEqual(p.live_row(saved), own)
        self.assertEqual(saved["crossing_desk"]["profiles"][p.DESK_ID]["rows"][A]["value"], wanted)
        saved = events.set_own_ways(saved, False, platform="mac", now=604901)["settings"]
        self.assertEqual(p.live_row(saved), wanted)
        self.assertEqual(saved["crossing_own"]["row"], own)

    def test_offline_profile_switch_and_recreated_identity_do_not_reuse_old_row(self):
        from core import crossing_state as events
        p = self.api()
        saved = events.set_same_ways(self.upgraded(), True, platform="mac", now=101)["settings"]
        old = copy.deepcopy(p.in_force(saved)[0])
        wanted = copy.deepcopy(old)
        wanted[B]["ways"]["thirds"] = ["end"]
        profile = dict(name=dict(value="Sofa", set_at=102, by=B), removed=None,
                       home={"shake": dict(value=True, set_at=102, by=B)},
                       rows={A: dict(value=wanted, set_at=103, by=B)})
        state = {"active": dict(value=P, set_at=104, by=B), "profiles": {P: profile}}
        saved = events.desk_arrived(saved, state, source=B, platform="mac", now=604900)["settings"]
        self.assertEqual(p.live_row(saved), wanted)
        self.assertIn(old, [item["row"] for item in saved["crossing_own"]["saved"]])
        fresh = raw()
        fresh["machine_id"] = C
        fresh, _ = p.before_load(fresh, now=604900)
        fresh, _ = p.after_load(fresh, platform="mac", now=604900)
        new_live = p.live_row(fresh)
        fresh = events.desk_arrived(fresh, p.desk_message(saved), source=B, platform="mac", now=604901)["settings"]
        self.assertEqual(p.live_row(fresh), new_live)
        self.assertEqual(fresh["crossing_desk"]["profiles"][P]["rows"][A]["value"], wanted)

    def test_seeded_state_transitions_preserve_replaced_rows_and_projection(self):
        """Archive boundaries, rather than intermediate edits in one editing session."""
        from core import crossing_state as events
        p = self.api()
        rng = random.Random(154)
        saved = self.upgraded()
        protected = []
        choices = ("remote", "same", "own", "profile", "switch", "remove", "older", "pair", "edit")
        peer = copy.deepcopy(saved["peers"][0])
        for step in range(160):
            now = 1000 + step * 65 + rng.randint(-30, 30)
            operation = rng.choice(choices)
            before = copy.deepcopy(p.in_force(saved)[0])
            if operation == "edit" and saved["peers"]:
                key = saved["crossing_desk"]["active"]["value"] if p.in_force(saved)[1] else "own"
                if not saved["crossing_own"].get("editing", {}).get(key):
                    protected.append(before)
                saved = events.edit_ways(saved, B, edge=bool(rng.randrange(2)), thirds=[rng.choice(ways.PARTS)],
                    platform="mac", live=None, gone=None, now=now)["settings"]
            elif operation == "remote" and saved["peers"]:
                pid = saved["crossing_desk"]["active"]["value"]
                held = saved["crossing_desk"]["profiles"][pid]["rows"].get(A)
                if held:
                    protected.append(copy.deepcopy(held["value"]))
                row = p.live_row(raw())
                row[B]["ways"]["thirds"] = [rng.choice(ways.PARTS)]
                state = {"profiles": {pid: {"rows": {A: dict(value=row, set_at=now, by=B)}}}}
                saved = events.desk_arrived(saved, state, source=B, platform="mac", now=now)["settings"]
            elif operation == "same":
                protected.append(copy.deepcopy(saved["crossing_own"]["row"]))
                saved = events.set_same_ways(saved, not p.same_ways_on(saved), platform="mac", now=now)["settings"]
            elif operation == "own":
                saved = events.set_own_ways(saved, not saved["crossing_own"]["use_own"], platform="mac", now=now)["settings"]
            elif operation == "profile":
                saved = events.new_profile(saved, "Place", platform="mac", now=now)["settings"]
            elif operation in ("switch", "remove"):
                ids = [item["id"] for item in p.profile_list(saved)]
                method = events.switch_profile if operation == "switch" else events.remove_profile
                saved = method(saved, rng.choice(ids), platform="mac", now=now)["settings"]
            elif operation == "older" and saved["peers"]:
                protected.append(copy.deepcopy(saved["crossing_own"]["row"]))
                saved["peers"][0]["ways"]["edge"] = not saved["peers"][0]["ways"]["edge"]
                saved, _ = p.before_load(saved, now=now)
                saved, _ = p.after_load(saved, platform="mac", now=now)
            elif operation == "pair":
                saved["peers"] = [] if saved["peers"] else [copy.deepcopy(peer)]
                saved, _ = p.reconcile(saved, platform="mac", now=now)
            available = [saved["crossing_own"]["row"], p.live_row(saved)]
            available += [item["row"] for item in saved["crossing_own"]["saved"]]
            available += [profile["rows"][A]["value"] for profile in saved["crossing_desk"]["profiles"].values()
                          if A in profile.get("rows", {})]
            for row in protected:
                self.assertIn(row, available, (step, operation))
            self.assertEqual(saved["crossing_own"]["applied"], p.live_row(saved), (step, operation))


if __name__ == "__main__":
    unittest.main()