Subject: [PATCH 02/24] wip: unify tiled scan and allocator ownership

From: Justin Youens <[email-masked]>
Date: Sat, 15 Aug 2026 06:39:04 -0500

---
 CMakeLists.txt                         |   3 +
 src/backend/drm/DRMIncarnations.cpp    | 143 +++++
 src/backend/drm/DRMIncarnations.hpp    | 130 +++++
 src/backend/drm/TiledBackendState.cpp  | 750 +++++++++++++++++++++++++
 src/backend/drm/TiledBackendState.hpp  | 507 +++++++++++++++++
 src/backend/drm/TiledCrtcAllocator.cpp | 426 +++++++++-----
 src/backend/drm/TiledCrtcAllocator.hpp | 192 ++++---
 tests/TiledBackendState.cpp            | 643 +++++++++++++++++++++
 tests/TiledCrtcAllocator.cpp           | 736 +++++++++++++++---------
 tests/TiledVisibility.cmake            |   2 +-
 10 files changed, 3043 insertions(+), 489 deletions(-)
 create mode 100644 src/backend/drm/DRMIncarnations.cpp
 create mode 100644 src/backend/drm/DRMIncarnations.hpp
 create mode 100644 src/backend/drm/TiledBackendState.cpp
 create mode 100644 src/backend/drm/TiledBackendState.hpp
 create mode 100644 tests/TiledBackendState.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 51aa9f871d3d260de8e32fde5032d2c8bfe8ad20..cc5cce4b61fc93494e736db88c82df01448e1376 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -61,10 +61,12 @@ file(GLOB_RECURSE SRCFILES CONFIGURE_DEPENDS "src/*.cpp" "include/*.hpp")
 file(GLOB_RECURSE PUBLIC_HEADERS CONFIGURE_DEPENDS "include/*.hpp")
 
 set(AQUAMARINE_TILED_PRIVATE_SOURCES
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/backend/drm/DRMIncarnations.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/backend/drm/PlaneFormats.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/backend/drm/PlaneViewport.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/backend/drm/Tile.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/backend/drm/TileModes.cpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/backend/drm/TiledBackendState.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/backend/drm/TiledCrtcAllocator.cpp")
 list(REMOVE_ITEM SRCFILES ${AQUAMARINE_TILED_PRIVATE_SOURCES})
 
@@ -199,6 +201,7 @@ endfunction()
 addTiledPrivateTest(connectorScan "tests/ConnectorScan.cpp")
 addTiledPrivateTest(tileTopology "tests/TileTopology.cpp")
 addTiledPrivateTest(tileModes "tests/TileModes.cpp")
+addTiledPrivateTest(tiledBackendState "tests/TiledBackendState.cpp")
 addTiledPrivateTest(planeFormats "tests/PlaneFormats.cpp")
 addTiledPrivateTest(planeViewport "tests/PlaneViewport.cpp")
 addTiledPrivateTest(tiledCrtcAllocator "tests/TiledCrtcAllocator.cpp")
diff --git a/src/backend/drm/DRMIncarnations.cpp b/src/backend/drm/DRMIncarnations.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fad06e28c178b4fc75bfba257c3b7e8f2b04cb1f
--- /dev/null
+++ b/src/backend/drm/DRMIncarnations.cpp
@@ -0,0 +1,143 @@
+#include "DRMIncarnations.hpp"
+
+#include <aquamarine/backend/DRM.hpp>
+
+#include <utility>
+
+namespace Aquamarine::NDRM::NTiledIncarnations { // NOLINT(readability-identifier-naming): established Aquamarine DRM namespace
+    CBackendLifetime::CBackendLifetime(uint64_t serial, eBackendBinding binding, CWeakPointer<CDRMBackend> backend) :
+        m_serial(serial), m_binding(binding), m_backend(std::move(backend)) {}
+
+    PBackendLifetime CBackendLifetime::createTestToken(uint64_t serial) {
+        if (serial == 0)
+            return {};
+        return PBackendLifetime{new CBackendLifetime{serial, eBackendBinding::TEST_TOKEN, {}}};
+    }
+
+    PBackendLifetime CBackendLifetime::createProduction(uint64_t serial, const CSharedPointer<CDRMBackend>& backend) {
+        if (serial == 0 || !backend)
+            return {};
+        return PBackendLifetime{new CBackendLifetime{serial, eBackendBinding::PRODUCTION_BACKEND, CWeakPointer<CDRMBackend>{backend}}};
+    }
+
+    uint64_t CBackendLifetime::serial() const {
+        return m_serial;
+    }
+
+    eBackendBinding CBackendLifetime::binding() const {
+        return m_binding;
+    }
+
+    const CWeakPointer<CDRMBackend>& CBackendLifetime::drmBackend() const {
+        return m_backend;
+    }
+
+    bool CBackendLifetime::structurallyValid() const {
+        if (m_serial == 0)
+            return false;
+
+        switch (m_binding) {
+            case eBackendBinding::TEST_TOKEN: return m_backend.impl_ == nullptr;
+            case eBackendBinding::PRODUCTION_BACKEND: return m_backend.impl_ != nullptr;
+        }
+
+        return false;
+    }
+
+    bool CBackendLifetime::valid() const {
+        return structurallyValid() && (m_binding == eBackendBinding::TEST_TOKEN || !m_backend.expired());
+    }
+
+    bool CBackendLifetime::matchesResourceBackend(const CWeakPointer<CDRMBackend>& backend) const {
+        if (!valid())
+            return false;
+
+        switch (m_binding) {
+            case eBackendBinding::TEST_TOKEN: return backend.impl_ == nullptr;
+            case eBackendBinding::PRODUCTION_BACKEND: return !backend.expired() && backend == m_backend;
+        }
+
+        return false;
+    }
+
+    CDeviceIncarnation::CDeviceIncarnation(PBackendLifetime backend, uint64_t deviceId, uint64_t deviceEpoch, uint64_t fdEpoch, uint64_t serial) :
+        m_backend(backend), m_deviceId(deviceId), m_deviceEpoch(deviceEpoch), m_fdEpoch(fdEpoch), m_serial(serial) {}
+
+    PDeviceIncarnation CDeviceIncarnation::create(PBackendLifetime backend, uint64_t deviceId, uint64_t deviceEpoch, uint64_t fdEpoch, uint64_t serial) {
+        return PDeviceIncarnation{new CDeviceIncarnation{std::move(backend), deviceId, deviceEpoch, fdEpoch, serial}};
+    }
+
+    const WBackendLifetime& CDeviceIncarnation::backend() const {
+        return m_backend;
+    }
+
+    uint64_t CDeviceIncarnation::deviceId() const {
+        return m_deviceId;
+    }
+
+    uint64_t CDeviceIncarnation::deviceEpoch() const {
+        return m_deviceEpoch;
+    }
+
+    uint64_t CDeviceIncarnation::fdEpoch() const {
+        return m_fdEpoch;
+    }
+
+    uint64_t CDeviceIncarnation::serial() const {
+        return m_serial;
+    }
+
+    bool CDeviceIncarnation::structurallyValid() const {
+        const auto BACKEND = m_backend.lock();
+        return BACKEND && BACKEND->structurallyValid() && m_deviceId != 0 && m_deviceEpoch != 0 && m_fdEpoch != 0 && m_serial != 0;
+    }
+
+    bool CDeviceIncarnation::valid() const {
+        const auto BACKEND = m_backend.lock();
+        return structurallyValid() && BACKEND->valid();
+    }
+
+    CSessionIncarnation::CSessionIncarnation(PBackendLifetime backend, PDeviceIncarnation device, std::thread::id eventThread, uint64_t sessionEpoch, uint64_t eventThreadEpoch,
+                                             uint64_t serial) :
+        m_backend(backend), m_device(std::move(device)), m_eventThread(eventThread), m_sessionEpoch(sessionEpoch), m_eventThreadEpoch(eventThreadEpoch), m_serial(serial) {}
+
+    PSessionIncarnation CSessionIncarnation::create(PBackendLifetime backend, PDeviceIncarnation device, std::thread::id eventThread, uint64_t sessionEpoch,
+                                                    uint64_t eventThreadEpoch, uint64_t serial) {
+        return PSessionIncarnation{new CSessionIncarnation{std::move(backend), std::move(device), eventThread, sessionEpoch, eventThreadEpoch, serial}};
+    }
+
+    const WBackendLifetime& CSessionIncarnation::backend() const {
+        return m_backend;
+    }
+
+    const PDeviceIncarnation& CSessionIncarnation::device() const {
+        return m_device;
+    }
+
+    const std::thread::id& CSessionIncarnation::eventThread() const {
+        return m_eventThread;
+    }
+
+    uint64_t CSessionIncarnation::sessionEpoch() const {
+        return m_sessionEpoch;
+    }
+
+    uint64_t CSessionIncarnation::eventThreadEpoch() const {
+        return m_eventThreadEpoch;
+    }
+
+    uint64_t CSessionIncarnation::serial() const {
+        return m_serial;
+    }
+
+    bool CSessionIncarnation::structurallyValid() const {
+        const auto BACKEND = m_backend.lock();
+        return BACKEND && BACKEND->structurallyValid() && m_device && m_device->structurallyValid() && m_device->backend() == m_backend && m_eventThread != std::thread::id{} &&
+            m_sessionEpoch != 0 && m_eventThreadEpoch != 0 && m_serial != 0;
+    }
+
+    bool CSessionIncarnation::valid() const {
+        const auto BACKEND = m_backend.lock();
+        return structurallyValid() && BACKEND->valid() && m_device->valid();
+    }
+}
diff --git a/src/backend/drm/DRMIncarnations.hpp b/src/backend/drm/DRMIncarnations.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..a9c79995bc9e1ae93a956c5903a4d9803b087061
--- /dev/null
+++ b/src/backend/drm/DRMIncarnations.hpp
@@ -0,0 +1,130 @@
+#pragma once
+
+#include <cstdint>
+#include <thread>
+
+#include <hyprutils/memory/SharedPtr.hpp>
+#include <hyprutils/memory/WeakPtr.hpp>
+
+namespace Aquamarine {
+    class CDRMBackend;
+}
+
+namespace Aquamarine::NDRM::NTiledScan {
+    class CScanFixtureAuthority;
+}
+
+namespace Aquamarine::NDRM::NTiledIncarnations { // NOLINT(readability-identifier-naming): established Aquamarine DRM namespace
+    using Hyprutils::Memory::CSharedPointer;
+    using Hyprutils::Memory::CWeakPointer;
+
+    enum class eBackendBinding : uint8_t {
+        // Unit tests have no CDRMBackend. Resources captured against this
+        // lifetime must have empty backend weak owners.
+        TEST_TOKEN,
+        // Production resources must carry the exact CDRMBackend weak owner
+        // retained by this lifetime.
+        PRODUCTION_BACKEND,
+    };
+
+    class CBackendLifetime;
+    class CDeviceIncarnation;
+    class CSessionIncarnation;
+
+    using PBackendLifetime    = CSharedPointer<CBackendLifetime>;
+    using WBackendLifetime    = CWeakPointer<CBackendLifetime>;
+    using PDeviceIncarnation  = CSharedPointer<CDeviceIncarnation>;
+    using PSessionIncarnation = CSharedPointer<CSessionIncarnation>;
+
+    class CBackendLifetime final {
+      public:
+        CBackendLifetime(const CBackendLifetime&)                                         = delete;
+        CBackendLifetime(CBackendLifetime&&)                                              = delete;
+        CBackendLifetime&                              operator=(const CBackendLifetime&) = delete;
+        CBackendLifetime&                              operator=(CBackendLifetime&&)      = delete;
+
+        [[nodiscard]] static PBackendLifetime          createTestToken(uint64_t serial);
+
+        [[nodiscard]] uint64_t                         serial() const;
+        [[nodiscard]] eBackendBinding                  binding() const;
+        [[nodiscard]] const CWeakPointer<CDRMBackend>& drmBackend() const;
+        [[nodiscard]] bool                             structurallyValid() const;
+        // Live/current validity. Teardown deliberately uses only structural
+        // validity because the CDRMBackend weak owner expires before its
+        // destructor body runs.
+        [[nodiscard]] bool valid() const;
+        [[nodiscard]] bool matchesResourceBackend(const CWeakPointer<CDRMBackend>& backend) const;
+
+      private:
+        [[nodiscard]] static PBackendLifetime createProduction(uint64_t serial, const CSharedPointer<CDRMBackend>& backend);
+        CBackendLifetime(uint64_t serial, eBackendBinding binding, CWeakPointer<CDRMBackend> backend);
+
+        uint64_t                  m_serial  = 0;
+        eBackendBinding           m_binding = eBackendBinding::TEST_TOKEN;
+        CWeakPointer<CDRMBackend> m_backend;
+
+        friend class ::Aquamarine::CDRMBackend;
+        friend class ::Aquamarine::NDRM::NTiledScan::CScanFixtureAuthority;
+    };
+
+    class CDeviceIncarnation final {
+      public:
+        CDeviceIncarnation(const CDeviceIncarnation&)            = delete;
+        CDeviceIncarnation(CDeviceIncarnation&&)                 = delete;
+        CDeviceIncarnation& operator=(const CDeviceIncarnation&) = delete;
+        CDeviceIncarnation& operator=(CDeviceIncarnation&&)      = delete;
+
+        // Trusted source-private adapter input. This cannot mint a production
+        // backend authority, and exact downstream owner gates reject twins.
+        [[nodiscard]] static PDeviceIncarnation create(PBackendLifetime backend, uint64_t deviceId, uint64_t deviceEpoch, uint64_t fdEpoch, uint64_t serial);
+
+        [[nodiscard]] const WBackendLifetime&   backend() const;
+        [[nodiscard]] uint64_t                  deviceId() const;
+        [[nodiscard]] uint64_t                  deviceEpoch() const;
+        [[nodiscard]] uint64_t                  fdEpoch() const;
+        [[nodiscard]] uint64_t                  serial() const;
+        [[nodiscard]] bool                      structurallyValid() const;
+        [[nodiscard]] bool                      valid() const;
+
+      private:
+        CDeviceIncarnation(PBackendLifetime backend, uint64_t deviceId, uint64_t deviceEpoch, uint64_t fdEpoch, uint64_t serial);
+
+        WBackendLifetime m_backend;
+        uint64_t         m_deviceId    = 0;
+        uint64_t         m_deviceEpoch = 0;
+        uint64_t         m_fdEpoch     = 0;
+        uint64_t         m_serial      = 0;
+    };
+
+    class CSessionIncarnation final {
+      public:
+        CSessionIncarnation(const CSessionIncarnation&)            = delete;
+        CSessionIncarnation(CSessionIncarnation&&)                 = delete;
+        CSessionIncarnation& operator=(const CSessionIncarnation&) = delete;
+        CSessionIncarnation& operator=(CSessionIncarnation&&)      = delete;
+
+        // Trusted source-private adapter input. Scan observations and commits
+        // remain state-minted exact authorities.
+        [[nodiscard]] static PSessionIncarnation create(PBackendLifetime backend, PDeviceIncarnation device, std::thread::id eventThread, uint64_t sessionEpoch,
+                                                        uint64_t eventThreadEpoch, uint64_t serial);
+
+        [[nodiscard]] const WBackendLifetime&    backend() const;
+        [[nodiscard]] const PDeviceIncarnation&  device() const;
+        [[nodiscard]] const std::thread::id&     eventThread() const;
+        [[nodiscard]] uint64_t                   sessionEpoch() const;
+        [[nodiscard]] uint64_t                   eventThreadEpoch() const;
+        [[nodiscard]] uint64_t                   serial() const;
+        [[nodiscard]] bool                       structurallyValid() const;
+        [[nodiscard]] bool                       valid() const;
+
+      private:
+        CSessionIncarnation(PBackendLifetime backend, PDeviceIncarnation device, std::thread::id eventThread, uint64_t sessionEpoch, uint64_t eventThreadEpoch, uint64_t serial);
+
+        WBackendLifetime   m_backend;
+        PDeviceIncarnation m_device;
+        std::thread::id    m_eventThread;
+        uint64_t           m_sessionEpoch     = 0;
+        uint64_t           m_eventThreadEpoch = 0;
+        uint64_t           m_serial           = 0;
+    };
+}
diff --git a/src/backend/drm/TiledBackendState.cpp b/src/backend/drm/TiledBackendState.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..77d4e24d8259e911b8d1ba3e48794706214a3167
--- /dev/null
+++ b/src/backend/drm/TiledBackendState.cpp
@@ -0,0 +1,750 @@
+#include "TiledBackendState.hpp"
+
+#include "ConnectorScan.hpp"
+
+#include <algorithm>
+#include <exception>
+#include <limits>
+#include <optional>
+#include <ranges>
+#include <string_view>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+using namespace Aquamarine::NDRM::NTiledScan;
+namespace NTiling = Aquamarine::NTiling;
+
+static_assert(std::is_nothrow_copy_constructible_v<PScanAttemptTicket>);
+static_assert(std::is_nothrow_copy_constructible_v<PScanObservation>);
+static_assert(std::is_nothrow_copy_constructible_v<PScanAttempt>);
+static_assert(std::is_nothrow_copy_constructible_v<PCommittedScan>);
+static_assert(std::is_nothrow_copy_constructible_v<SScanOutcome>);
+static_assert(std::is_nothrow_move_assignable_v<SScanOutcome>);
+
+namespace {
+    auto modeFields(const drmModeModeInfo& mode) {
+        return std::tie(mode.clock, mode.hdisplay, mode.hsync_start, mode.hsync_end, mode.htotal, mode.hskew, mode.vdisplay, mode.vsync_start, mode.vsync_end, mode.vtotal,
+                        mode.vscan, mode.vrefresh, mode.flags, mode.type);
+    }
+
+    std::string_view modeName(const drmModeModeInfo& mode) {
+        return {mode.name, sizeof(mode.name)};
+    }
+
+    bool modeLess(const drmModeModeInfo& lhs, const drmModeModeInfo& rhs) {
+        if (modeFields(lhs) != modeFields(rhs))
+            return modeFields(lhs) < modeFields(rhs);
+        return modeName(lhs) < modeName(rhs);
+    }
+
+    bool modeDefinitionMatches(const PScanModeDefinition& existing, const PScanGroupDefinition& definition, const NTiling::STileModeSynthesisResult& synthesis) {
+        if (existing->definition() != definition)
+            return false;
+
+        return std::ranges::equal(existing->logicalModes(), synthesis.modes, {}, &SLogicalModeProjection::logical) &&
+            std::ranges::equal(existing->physicalMappings(), synthesis.mappings);
+    }
+
+    PScanGroupDefinition reusableDefinition(const PCommittedScan& current, const PDeviceIncarnation& device, const NTiling::STileGroup& group) {
+        if (!current || current->device() != device)
+            return {};
+
+        for (const auto& DEFINITION : current->definitions()) {
+            if (DEFINITION->group() == group)
+                return DEFINITION;
+        }
+
+        return {};
+    }
+
+    PScanModeDefinition reusableModes(const PCommittedScan& current, const PScanGroupDefinition& definition, const NTiling::STileModeSynthesisResult& synthesis) {
+        if (!current)
+            return {};
+
+        for (const auto& MODES : current->modeDefinitions()) {
+            if (modeDefinitionMatches(MODES, definition, synthesis))
+                return MODES;
+        }
+
+        return {};
+    }
+
+    SCommittedConnector* findPreparedConnector(std::vector<SCommittedConnector>& connectors, uint32_t connectorId) {
+        const auto ITERATOR = std::ranges::lower_bound(connectors, connectorId, {}, [](const SCommittedConnector& connector) { return connector.view.connectorId; });
+        if (ITERATOR == connectors.end() || ITERATOR->view.connectorId != connectorId)
+            return nullptr;
+        return &*ITERATOR;
+    }
+
+    eScanOutcome outcomeForFailure(eAttemptFailure failure) {
+        switch (failure) {
+            case eAttemptFailure::ACQUISITION_FAILED: return eScanOutcome::ACQUISITION_FAILED;
+            case eAttemptFailure::PREPARATION_FAILED: return eScanOutcome::PREPARATION_FAILED;
+            case eAttemptFailure::VALIDATION_FAILED: return eScanOutcome::VALIDATION_FAILED;
+        }
+
+        return eScanOutcome::PREPARATION_FAILED;
+    }
+}
+
+CScanObservation::CScanObservation(PSessionIncarnation session, uint64_t serial, uint64_t resourceEpoch) :
+    m_session(std::move(session)), m_serial(serial), m_resourceEpoch(resourceEpoch) {}
+
+const PSessionIncarnation& CScanObservation::session() const {
+    return m_session;
+}
+
+const PDeviceIncarnation& CScanObservation::device() const {
+    return m_session->device();
+}
+
+uint64_t CScanObservation::serial() const {
+    return m_serial;
+}
+
+uint64_t CScanObservation::resourceEpoch() const {
+    return m_resourceEpoch;
+}
+
+CScanAttemptTicket::CScanAttemptTicket(PStateAuthority state, WBackendLifetime backend, PDeviceIncarnation device, PSessionIncarnation session, PScanObservation observation,
+                                       uint64_t lifecycleEpoch) :
+    m_state(std::move(state)), m_backend(std::move(backend)), m_device(std::move(device)), m_session(std::move(session)), m_observation(std::move(observation)),
+    m_lifecycleEpoch(lifecycleEpoch) {}
+
+uint64_t CScanAttemptTicket::serial() const {
+    return m_observation->serial();
+}
+
+uint64_t CScanAttemptTicket::resourceEpoch() const {
+    return m_observation->resourceEpoch();
+}
+
+CScanAttempt::CScanAttempt(PScanAttemptTicket ticket, eScanCompleteness completeness, std::vector<SConnectorView> connectors) :
+    m_ticket(std::move(ticket)), m_completeness(completeness), m_connectors(std::move(connectors)) {}
+
+const PScanAttemptTicket& CScanAttempt::ticket() const {
+    return m_ticket;
+}
+
+const PScanObservation& CScanAttempt::observation() const {
+    return m_ticket->m_observation;
+}
+
+const PDeviceIncarnation& CScanAttempt::device() const {
+    return m_ticket->m_device;
+}
+
+eScanCompleteness CScanAttempt::completeness() const {
+    return m_completeness;
+}
+
+std::span<const SConnectorView> CScanAttempt::connectors() const {
+    return m_connectors;
+}
+
+CScanGroupDefinition::CScanGroupDefinition(PDeviceIncarnation device, PSessionIncarnation session, NTiling::STileGroup group) :
+    m_device(std::move(device)), m_session(std::move(session)), m_group(std::move(group)) {}
+
+const PDeviceIncarnation& CScanGroupDefinition::device() const {
+    return m_device;
+}
+
+const PSessionIncarnation& CScanGroupDefinition::session() const {
+    return m_session;
+}
+
+const NTiling::STileGroup& CScanGroupDefinition::group() const {
+    return m_group;
+}
+
+CScanModeDefinition::CScanModeDefinition(PScanGroupDefinition definition, NTiling::STileModeSynthesisResult synthesis) :
+    m_definition(std::move(definition)), m_synthesis(std::move(synthesis)) {
+    m_logicalModes.reserve(m_synthesis.modes.size());
+    for (const auto& MODE : m_synthesis.modes) {
+        m_logicalModes.emplace_back(SLogicalModeProjection{.logical = MODE});
+    }
+}
+
+const PScanGroupDefinition& CScanModeDefinition::definition() const {
+    return m_definition;
+}
+
+std::span<const SLogicalModeProjection> CScanModeDefinition::logicalModes() const {
+    return m_logicalModes;
+}
+
+std::span<const NTiling::STileModeMap> CScanModeDefinition::physicalMappings() const {
+    return m_synthesis.mappings;
+}
+
+CCommittedScan::CCommittedScan(PScanAttempt attempt, std::vector<SCommittedConnector> connectors, std::vector<PScanGroupDefinition> definitions,
+                               std::vector<PScanModeDefinition> modeDefinitions) :
+    m_attempt(std::move(attempt)), m_connectors(std::move(connectors)), m_definitions(std::move(definitions)), m_modeDefinitions(std::move(modeDefinitions)) {}
+
+const PScanAttempt& CCommittedScan::attempt() const {
+    return m_attempt;
+}
+
+const PDeviceIncarnation& CCommittedScan::device() const {
+    return m_attempt->device();
+}
+
+const PScanObservation& CCommittedScan::observation() const {
+    return m_attempt->observation();
+}
+
+std::span<const SCommittedConnector> CCommittedScan::connectors() const {
+    return m_connectors;
+}
+
+std::span<const PScanGroupDefinition> CCommittedScan::definitions() const {
+    return m_definitions;
+}
+
+std::span<const PScanModeDefinition> CCommittedScan::modeDefinitions() const {
+    return m_modeDefinitions;
+}
+
+const SCommittedConnector* CCommittedScan::findConnector(uint32_t connectorId) const {
+    const auto ITERATOR = std::ranges::lower_bound(m_connectors, connectorId, {}, [](const SCommittedConnector& connector) { return connector.view.connectorId; });
+    if (ITERATOR == m_connectors.end() || ITERATOR->view.connectorId != connectorId)
+        return nullptr;
+    return &*ITERATOR;
+}
+
+CPreparedScan::CPreparedScan(PStateAuthority state, WBackendLifetime backend, PDeviceIncarnation device, PSessionIncarnation session, PScanAttempt attempt, PCommittedScan base,
+                             PCommittedScan candidate, uint64_t lifecycleEpoch) :
+    m_state(std::move(state)), m_backend(std::move(backend)), m_device(std::move(device)), m_session(std::move(session)), m_attempt(std::move(attempt)), m_base(std::move(base)),
+    m_candidate(std::move(candidate)), m_lifecycleEpoch(lifecycleEpoch) {}
+
+const PScanAttempt& CPreparedScan::attempt() const {
+    return m_attempt;
+}
+
+const PCommittedScan& CPreparedScan::candidate() const {
+    return m_candidate;
+}
+
+SBeginAttemptResult::operator bool() const {
+    return ticket && result == eBeginAttemptResult::STARTED;
+}
+
+SPrepareScanResult::operator bool() const {
+    return result == ePrepareScanResult::PREPARED && attempt && prepared;
+}
+
+CTiledBackendState::CTiledBackendState(WBackendLifetime backend, PDeviceIncarnation device, PSessionIncarnation session, std::thread::id eventThread) :
+    m_backend(std::move(backend)), m_device(std::move(device)), m_session(std::move(session)), m_stateAuthority(PStateAuthority{new CStateAuthority{}}), m_eventThread(eventThread),
+    m_lastObservationSerial(m_session->serial()), m_lifecycleEpoch(m_session->serial()) {}
+
+CTiledBackendState::~CTiledBackendState() noexcept {
+    if (!readyForDestruction())
+        std::terminate();
+}
+
+bool CTiledBackendState::onEventThread() const {
+    return std::this_thread::get_id() == m_eventThread;
+}
+
+bool CTiledBackendState::backendCurrent() const {
+    const auto BACKEND = m_backend.lock();
+    return BACKEND && BACKEND->valid() && m_device && m_device->valid() && m_device->backend() == BACKEND && m_session && m_session->valid() && m_session->backend() == BACKEND &&
+        m_session->device() == m_device && m_session->eventThread() == m_eventThread;
+}
+
+bool CTiledBackendState::ownsTicket(const PScanAttemptTicket& ticket) const {
+    return ticket && ticket->m_state == m_stateAuthority && ticket->m_backend == m_backend && ticket->m_device == m_device;
+}
+
+bool CTiledBackendState::ownsPrepared(const PPreparedScan& prepared) const {
+    return prepared && prepared->m_state == m_stateAuthority;
+}
+
+void CTiledBackendState::setOutcome(eScanOutcome result, uint64_t serial, PScanAttemptTicket ticket, PScanObservation observation, PScanAttempt attempt) noexcept {
+    m_outcome = SScanOutcome{
+        .result      = result,
+        .serial      = serial,
+        .ticket      = std::move(ticket),
+        .observation = std::move(observation),
+        .attempt     = std::move(attempt),
+    };
+}
+
+void CTiledBackendState::clearActiveTicket() noexcept {
+    m_activeTicket = PScanAttemptTicket{};
+}
+
+void CTiledBackendState::clearActivePrepared() noexcept {
+    m_activePrepared = PPreparedScan{};
+}
+
+SBeginAttemptResult CTiledBackendState::beginAttempt(uint64_t resourceEpoch) noexcept {
+    if (!onEventThread())
+        return {.result = eBeginAttemptResult::WRONG_THREAD};
+    if (m_teardownBegun)
+        return {.result = eBeginAttemptResult::TEARING_DOWN};
+    if (!backendCurrent()) {
+        setOutcome(eScanOutcome::BACKEND_EXPIRED, m_lastObservationSerial);
+        return {.result = eBeginAttemptResult::BACKEND_EXPIRED};
+    }
+    if (m_activeTicket || m_activePrepared)
+        return {.result = eBeginAttemptResult::BUSY};
+    if (resourceEpoch == 0) {
+        setOutcome(eScanOutcome::INVALID_OBSERVATION, m_lastObservationSerial);
+        return {.result = eBeginAttemptResult::INVALID_RESOURCE_EPOCH};
+    }
+    if (m_lastResourceEpoch == std::numeric_limits<uint64_t>::max()) {
+        setOutcome(eScanOutcome::RESOURCE_EPOCH_EXHAUSTED, m_lastObservationSerial);
+        return {.result = eBeginAttemptResult::RESOURCE_EPOCH_EXHAUSTED};
+    }
+    if (resourceEpoch <= m_lastResourceEpoch) {
+        setOutcome(eScanOutcome::STALE_RESOURCE_EPOCH, m_lastObservationSerial);
+        return {.result = eBeginAttemptResult::STALE_RESOURCE_EPOCH};
+    }
+    if (m_lastObservationSerial == std::numeric_limits<uint64_t>::max() || m_lifecycleEpoch == std::numeric_limits<uint64_t>::max()) {
+        setOutcome(eScanOutcome::SERIAL_EXHAUSTED, m_lastObservationSerial);
+        return {.result = eBeginAttemptResult::SERIAL_EXHAUSTED};
+    }
+
+    ++m_lastObservationSerial;
+    m_lastResourceEpoch = resourceEpoch;
+    ++m_lifecycleEpoch;
+    setOutcome(eScanOutcome::PREPARING, m_lastObservationSerial);
+
+    PScanObservation observation;
+    try {
+        observation    = PScanObservation{new CScanObservation{m_session, m_lastObservationSerial, resourceEpoch}};
+        auto ticket    = PScanAttemptTicket{new CScanAttemptTicket{m_stateAuthority, m_backend, m_device, m_session, observation, m_lifecycleEpoch}};
+        m_activeTicket = ticket;
+        setOutcome(eScanOutcome::PREPARING, m_lastObservationSerial, ticket, observation);
+        return {.ticket = std::move(ticket)};
+    } catch (...) {
+        clearActiveTicket();
+        setOutcome(eScanOutcome::PREPARATION_FAILED, m_lastObservationSerial, {}, std::move(observation));
+        return {.result = eBeginAttemptResult::PREPARATION_FAILED};
+    }
+}
+
+PCommittedScan CTiledBackendState::buildComplete(const PScanAttempt& attempt) const {
+    std::vector<NTiling::STileConnector>      topologyConnectors;
+    std::vector<NTiling::STileConnectorModes> connectorModes;
+    topologyConnectors.reserve(attempt->connectors().size());
+    connectorModes.reserve(attempt->connectors().size());
+
+    std::vector<SCommittedConnector> preparedConnectors;
+    preparedConnectors.reserve(attempt->connectors().size());
+
+    for (const auto& CONNECTOR : attempt->connectors()) {
+        preparedConnectors.emplace_back(SCommittedConnector{
+            .view = CONNECTOR,
+            .projection =
+                {
+                    .connectorId = CONNECTOR.connectorId,
+                },
+        });
+
+        if (!CONNECTOR.connected || !CONNECTOR.isMonitor || CONNECTOR.nonDesktop || !CONNECTOR.tileProperty)
+            continue;
+
+        const auto TILE = NTiling::parseTileInfo(*CONNECTOR.tileProperty);
+        if (!TILE.tile || !TILE.tile.value().isSingleMonitor)
+            continue;
+        const auto&                     TILE_INFO = TILE.tile.value();
+
+        std::vector<NTiling::STileMode> dimensions;
+        dimensions.reserve(CONNECTOR.modes.size());
+        for (const auto& MODE : CONNECTOR.modes) {
+            dimensions.emplace_back(NTiling::STileMode{.width = MODE.hdisplay, .height = MODE.vdisplay});
+        }
+
+        topologyConnectors.emplace_back(NTiling::STileConnector{
+            .deviceId    = m_device->deviceId(),
+            .connectorId = CONNECTOR.connectorId,
+            .tile        = TILE_INFO,
+            .modes       = std::move(dimensions),
+        });
+        connectorModes.emplace_back(NTiling::STileConnectorModes{
+            .deviceId    = m_device->deviceId(),
+            .connectorId = CONNECTOR.connectorId,
+            .modes       = CONNECTOR.modes,
+        });
+    }
+
+    const auto                        TOPOLOGY = NTiling::buildTileTopology(topologyConnectors);
+    std::vector<PScanGroupDefinition> definitions;
+    std::vector<PScanModeDefinition>  modeDefinitions;
+
+    for (const auto& GROUP : TOPOLOGY.groups) {
+        std::optional<NTiling::STileModeSynthesisResult> synthesized;
+        if (GROUP.kind == NTiling::eTileGroupKind::MULTI_STREAM) {
+            auto RESULT = NTiling::synthesizeTileModes(GROUP, connectorModes);
+            if (!RESULT)
+                continue;
+            synthesized.emplace(std::move(RESULT));
+        }
+
+        auto DEFINITION = reusableDefinition(m_committed, m_device, GROUP);
+        if (!DEFINITION || DEFINITION->session() != m_session)
+            DEFINITION = PScanGroupDefinition{new CScanGroupDefinition{m_device, m_session, GROUP}};
+
+        PScanModeDefinition modes;
+        if (synthesized) {
+            modes = reusableModes(m_committed, DEFINITION, *synthesized);
+            if (!modes)
+                modes = PScanModeDefinition{new CScanModeDefinition{DEFINITION, std::move(*synthesized)}};
+            modeDefinitions.emplace_back(modes);
+        }
+
+        definitions.emplace_back(DEFINITION);
+
+        for (const auto& MEMBER : GROUP.members) {
+            auto* const CONNECTOR = findPreparedConnector(preparedConnectors, MEMBER.connectorId);
+            if (!CONNECTOR)
+                continue;
+
+            CONNECTOR->projection.definition = DEFINITION;
+            CONNECTOR->projection.modes      = modes;
+            if (GROUP.kind == NTiling::eTileGroupKind::MULTI_STREAM) {
+                CONNECTOR->projection.role = MEMBER.connectorId == GROUP.primaryConnector ? eConnectorRole::MULTI_STREAM_PRIMARY : eConnectorRole::MULTI_STREAM_MEMBER;
+            } else if (MEMBER.connectorId == GROUP.primaryConnector) {
+                CONNECTOR->projection.role = eConnectorRole::DRIVER_UNIFIED_PRIMARY;
+            } else {
+                CONNECTOR->projection.role        = eConnectorRole::DRIVER_UNIFIED_REDUNDANT;
+                CONNECTOR->projection.disposition = eConnectorDisposition::SUPPRESS_REDUNDANT;
+            }
+        }
+    }
+
+    return PCommittedScan{new CCommittedScan{attempt, std::move(preparedConnectors), std::move(definitions), std::move(modeDefinitions)}};
+}
+
+SPrepareScanResult CTiledBackendState::prepare(const PScanAttemptTicket& ticket, eScanCompleteness completeness, std::vector<SConnectorView> connectors) noexcept {
+    if (!onEventThread())
+        return {.result = ePrepareScanResult::WRONG_THREAD};
+    if (m_activePrepared)
+        return {.result = ePrepareScanResult::BUSY};
+    if (!ownsTicket(ticket))
+        return {.result = ePrepareScanResult::FOREIGN_TICKET};
+    if (m_teardownBegun)
+        return {.result = ePrepareScanResult::TEARING_DOWN};
+    if (!m_activeTicket) {
+        setOutcome(eScanOutcome::STALE_OBSERVATION, ticket->serial(), ticket, ticket->m_observation);
+        return {.result = ePrepareScanResult::STALE_TICKET};
+    }
+    if (m_activeTicket != ticket)
+        return {.result = ePrepareScanResult::BUSY};
+    if (!backendCurrent()) {
+        clearActiveTicket();
+        setOutcome(eScanOutcome::BACKEND_EXPIRED, ticket->serial(), ticket, ticket->m_observation);
+        return {.result = ePrepareScanResult::BACKEND_EXPIRED};
+    }
+    if (ticket->serial() != m_lastObservationSerial || ticket->m_lifecycleEpoch != m_lifecycleEpoch) {
+        clearActiveTicket();
+        setOutcome(eScanOutcome::STALE_OBSERVATION, ticket->serial(), ticket, ticket->m_observation);
+        return {.result = ePrepareScanResult::STALE_TICKET};
+    }
+
+    PScanAttempt attempt;
+    try {
+        std::vector<uint32_t> connectorIds;
+        connectorIds.reserve(connectors.size());
+        for (const auto& CONNECTOR : connectors) {
+            if (CONNECTOR.connectorId == 0) {
+                clearActiveTicket();
+                setOutcome(eScanOutcome::PREPARATION_FAILED, ticket->serial(), ticket, ticket->m_observation);
+                return {.result = ePrepareScanResult::PREPARATION_FAILED};
+            }
+            connectorIds.emplace_back(CONNECTOR.connectorId);
+        }
+
+        size_t                      next = 0;
+        std::vector<SConnectorView> staged;
+        const auto                  RESULT = connectorScanTransaction<SConnectorView>(
+            connectorIds,
+            [&connectors, &next](uint32_t connectorId) -> std::optional<SConnectorView> {
+                if (next >= connectors.size() || connectors.at(next).connectorId != connectorId)
+                    return std::nullopt;
+                return std::move(connectors.at(next++));
+            },
+            [&staged](std::span<SConnectorView> complete) {
+                staged.reserve(complete.size());
+                for (auto& CONNECTOR : complete) {
+                    staged.emplace_back(std::move(CONNECTOR));
+                }
+            });
+
+        if (RESULT != eConnectorScanResult::COMMITTED) {
+            clearActiveTicket();
+            setOutcome(eScanOutcome::PREPARATION_FAILED, ticket->serial(), ticket, ticket->m_observation);
+            return {.result = ePrepareScanResult::PREPARATION_FAILED};
+        }
+
+        for (auto& CONNECTOR : staged) {
+            std::ranges::sort(CONNECTOR.modes, modeLess);
+        }
+        std::ranges::sort(staged, {}, &SConnectorView::connectorId);
+
+        attempt = PScanAttempt{new CScanAttempt{ticket, completeness, std::move(staged)}};
+        if (completeness == eScanCompleteness::INCOMPLETE) {
+            clearActiveTicket();
+            setOutcome(eScanOutcome::INCOMPLETE, ticket->serial(), ticket, ticket->m_observation, attempt);
+            return {.attempt = std::move(attempt), .result = ePrepareScanResult::INCOMPLETE};
+        }
+
+        auto candidate   = buildComplete(attempt);
+        auto prepared    = PPreparedScan{new CPreparedScan{m_stateAuthority, m_backend, m_device, m_session, attempt, m_committed, std::move(candidate), m_lifecycleEpoch}};
+        m_activePrepared = prepared;
+        clearActiveTicket();
+        setOutcome(eScanOutcome::AWAITING_VALIDATION, ticket->serial(), ticket, ticket->m_observation, attempt);
+        return {.attempt = std::move(attempt), .prepared = std::move(prepared)};
+    } catch (...) {
+        clearActiveTicket();
+        clearActivePrepared();
+        setOutcome(eScanOutcome::PREPARATION_FAILED, ticket->serial(), ticket, ticket->m_observation, std::move(attempt));
+        return {.result = ePrepareScanResult::PREPARATION_FAILED};
+    }
+}
+
+eScanInstallResult CTiledBackendState::install(const PPreparedScan& prepared, eValidationDecision decision) noexcept {
+    if (!onEventThread())
+        return eScanInstallResult::WRONG_THREAD;
+    if (!ownsPrepared(prepared))
+        return eScanInstallResult::FOREIGN_PREPARED;
+    if (m_activePrepared && m_activePrepared != prepared)
+        return eScanInstallResult::BUSY;
+    if (m_teardownBegun)
+        return eScanInstallResult::TEARING_DOWN;
+    if (!m_activePrepared) {
+        setOutcome(eScanOutcome::STALE_PREPARED, prepared->m_attempt->observation()->serial(), prepared->m_attempt->ticket(), prepared->m_attempt->observation(),
+                   prepared->m_attempt);
+        return eScanInstallResult::STALE_PREPARED;
+    }
+    if (!backendCurrent()) {
+        clearActivePrepared();
+        setOutcome(eScanOutcome::BACKEND_EXPIRED, prepared->m_attempt->observation()->serial(), prepared->m_attempt->ticket(), prepared->m_attempt->observation(),
+                   prepared->m_attempt);
+        return eScanInstallResult::BACKEND_EXPIRED;
+    }
+    if (prepared->m_backend != m_backend)
+        return eScanInstallResult::FOREIGN_PREPARED;
+    if (prepared->m_device != m_device)
+        return eScanInstallResult::WRONG_DEVICE;
+    if (prepared->m_session != m_session)
+        return eScanInstallResult::STALE_PREPARED;
+    if (prepared->m_lifecycleEpoch != m_lifecycleEpoch || prepared->m_attempt->observation()->serial() != m_lastObservationSerial ||
+        prepared->m_attempt->ticket()->m_state != m_stateAuthority) {
+        clearActivePrepared();
+        setOutcome(eScanOutcome::STALE_PREPARED, prepared->m_attempt->observation()->serial(), prepared->m_attempt->ticket(), prepared->m_attempt->observation(),
+                   prepared->m_attempt);
+        return eScanInstallResult::STALE_PREPARED;
+    }
+    if (prepared->m_base != m_committed) {
+        clearActivePrepared();
+        setOutcome(eScanOutcome::STALE_PREPARED, prepared->m_attempt->observation()->serial(), prepared->m_attempt->ticket(), prepared->m_attempt->observation(),
+                   prepared->m_attempt);
+        return eScanInstallResult::BASE_CHANGED;
+    }
+
+    auto       attempt     = prepared->m_attempt;
+    auto       ticket      = attempt->ticket();
+    auto       observation = attempt->observation();
+    const auto SERIAL      = observation->serial();
+
+    if (decision == eValidationDecision::ACCEPTED) {
+        auto candidate = prepared->m_candidate;
+        clearActivePrepared();
+        m_committed = std::move(candidate);
+        setOutcome(eScanOutcome::COMMITTED, SERIAL, std::move(ticket), std::move(observation), std::move(attempt));
+        return eScanInstallResult::COMMITTED;
+    }
+
+    clearActivePrepared();
+    if (decision == eValidationDecision::REJECTED) {
+        setOutcome(eScanOutcome::VALIDATION_REJECTED, SERIAL, std::move(ticket), std::move(observation), std::move(attempt));
+        return eScanInstallResult::VALIDATION_REJECTED;
+    }
+
+    setOutcome(eScanOutcome::VALIDATION_FAILED, SERIAL, std::move(ticket), std::move(observation), std::move(attempt));
+    return eScanInstallResult::VALIDATION_FAILED;
+}
+
+eResolveAttemptResult CTiledBackendState::fail(const PScanAttemptTicket& ticket, eAttemptFailure failure) noexcept {
+    if (!onEventThread())
+        return eResolveAttemptResult::WRONG_THREAD;
+    if (!ownsTicket(ticket))
+        return eResolveAttemptResult::FOREIGN_TICKET;
+    if (m_teardownBegun)
+        return eResolveAttemptResult::STALE_TICKET;
+
+    if (m_activeTicket) {
+        if (m_activeTicket != ticket)
+            return eResolveAttemptResult::STALE_TICKET;
+        clearActiveTicket();
+        setOutcome(outcomeForFailure(failure), ticket->serial(), ticket, ticket->m_observation);
+        return eResolveAttemptResult::RESOLVED;
+    }
+
+    if (m_activePrepared) {
+        if (m_activePrepared->m_attempt->ticket() != ticket)
+            return eResolveAttemptResult::STALE_TICKET;
+        auto attempt = m_activePrepared->m_attempt;
+        clearActivePrepared();
+        setOutcome(outcomeForFailure(failure), ticket->serial(), ticket, ticket->m_observation, std::move(attempt));
+        return eResolveAttemptResult::RESOLVED;
+    }
+
+    setOutcome(eScanOutcome::STALE_OBSERVATION, ticket->serial(), ticket, ticket->m_observation);
+    return eResolveAttemptResult::STALE_TICKET;
+}
+
+eSessionRotationResult CTiledBackendState::rotateSession(const PSessionIncarnation& session) noexcept {
+    if (!onEventThread())
+        return eSessionRotationResult::WRONG_THREAD;
+    if (m_teardownBegun)
+        return eSessionRotationResult::TEARING_DOWN;
+    if (!session || !session->valid() || session->backend() != m_backend || session->device() != m_device || session->eventThread() != m_eventThread)
+        return eSessionRotationResult::INVALID_IDENTITY;
+    if (session == m_session)
+        return eSessionRotationResult::UNCHANGED;
+    if (session->sessionEpoch() <= m_session->sessionEpoch() || session->eventThreadEpoch() <= m_session->eventThreadEpoch() || session->serial() <= m_lastObservationSerial)
+        return eSessionRotationResult::STALE_IDENTITY;
+    if (m_activeTicket || m_activePrepared)
+        return eSessionRotationResult::BUSY;
+
+    m_session               = session;
+    m_lastObservationSerial = session->serial();
+    if (m_lifecycleEpoch != std::numeric_limits<uint64_t>::max())
+        ++m_lifecycleEpoch;
+    setOutcome(eScanOutcome::SESSION_ROTATED, m_lastObservationSerial);
+    return eSessionRotationResult::ROTATED;
+}
+
+PCommittedScan CTiledBackendState::committed() const {
+    if (!onEventThread())
+        return {};
+    return m_committed;
+}
+
+PCommittedScan CTiledBackendState::currentComplete() const {
+    if (!onEventThread() || !backendCurrent() || m_outcome.result != eScanOutcome::COMMITTED || !m_committed || m_outcome.attempt != m_committed->attempt())
+        return {};
+    return m_committed;
+}
+
+SScanOutcome CTiledBackendState::outcome() const noexcept {
+    if (!onEventThread())
+        return {};
+    return m_outcome;
+}
+
+eTeardownResult CTiledBackendState::beginTeardown() noexcept {
+    if (!onEventThread())
+        return eTeardownResult::WRONG_THREAD;
+    if (m_teardownBegun)
+        return eTeardownResult::ALREADY_BEGUN;
+    if (m_activeTicket || m_activePrepared)
+        return eTeardownResult::BUSY;
+    const auto BACKEND = m_backend.lock();
+    if (!BACKEND || !BACKEND->structurallyValid() || !m_device || !m_device->structurallyValid() || m_device->backend() != BACKEND || !m_session ||
+        !m_session->structurallyValid() || m_session->backend() != BACKEND || m_session->device() != m_device || m_session->eventThread() != m_eventThread)
+        return eTeardownResult::BACKEND_EXPIRED;
+
+    m_teardownBegun = true;
+    setOutcome(eScanOutcome::TEARING_DOWN, m_lastObservationSerial);
+    return eTeardownResult::BEGUN;
+}
+
+bool CTiledBackendState::readyForDestruction() const noexcept {
+    return m_teardownBegun;
+}
+
+SRegistryCreateResult::operator bool() const {
+    return state && result == eRegistryResult::OK;
+}
+
+CTiledBackendStateRegistry::CTiledBackendStateRegistry(std::thread::id eventThread) : m_eventThread(eventThread) {}
+
+CTiledBackendStateRegistry::~CTiledBackendStateRegistry() noexcept {
+    if (!readyForDestruction())
+        std::terminate();
+}
+
+bool CTiledBackendStateRegistry::onEventThread() const {
+    return std::this_thread::get_id() == m_eventThread;
+}
+
+SRegistryCreateResult CTiledBackendStateRegistry::create(const PBackendLifetime& backend, const PDeviceIncarnation& device, const PSessionIncarnation& session) {
+    if (!onEventThread())
+        return {.result = eRegistryResult::WRONG_THREAD};
+    if (!backend || !backend->valid() || !device || !device->valid() || device->backend() != backend || !session || !session->valid() || session->backend() != backend ||
+        session->device() != device || session->eventThread() != m_eventThread)
+        return {.result = eRegistryResult::INVALID_IDENTITY};
+
+    const auto KEY = WBackendLifetime{backend};
+    if (m_states.contains(KEY))
+        return {.result = eRegistryResult::ALREADY_EXISTS};
+    for (const auto& [EXISTING_KEY, EXISTING_STATE] : m_states) {
+        const auto EXISTING = EXISTING_KEY.lock();
+        if (!EXISTING)
+            continue;
+        if (EXISTING_STATE->m_device == device ||
+            (backend->binding() == eBackendBinding::PRODUCTION_BACKEND && EXISTING->binding() == eBackendBinding::PRODUCTION_BACKEND &&
+             backend->drmBackend() == EXISTING->drmBackend()))
+            return {.result = eRegistryResult::ALREADY_EXISTS};
+    }
+
+    auto        state        = UBackendState{new CTiledBackendState{KEY, device, session, m_eventThread}};
+    auto* const STATE        = state.get();
+    const auto [_, INSERTED] = m_states.emplace(KEY, std::move(state));
+    if (!INSERTED)
+        return {.result = eRegistryResult::ALREADY_EXISTS};
+    return {.state = STATE};
+}
+
+CTiledBackendState* CTiledBackendStateRegistry::find(const PBackendLifetime& backend) {
+    if (!onEventThread() || !backend)
+        return nullptr;
+    const auto ITERATOR = m_states.find(WBackendLifetime{backend});
+    return ITERATOR == m_states.end() ? nullptr : ITERATOR->second.get();
+}
+
+eRegistryResult CTiledBackendStateRegistry::beginTeardown(const PBackendLifetime& backend) noexcept {
+    if (!onEventThread())
+        return eRegistryResult::WRONG_THREAD;
+    if (!backend)
+        return eRegistryResult::INVALID_IDENTITY;
+
+    const auto ITERATOR = m_states.find(WBackendLifetime{backend});
+    if (ITERATOR == m_states.end())
+        return eRegistryResult::NOT_FOUND;
+
+    const auto RESULT = ITERATOR->second->beginTeardown();
+    if (RESULT == eTeardownResult::WRONG_THREAD)
+        return eRegistryResult::WRONG_THREAD;
+    if (RESULT == eTeardownResult::BACKEND_EXPIRED)
+        return eRegistryResult::INVALID_IDENTITY;
+    if (RESULT == eTeardownResult::BUSY)
+        return eRegistryResult::BUSY;
+    return eRegistryResult::OK;
+}
+
+eRegistryResult CTiledBackendStateRegistry::erase(const PBackendLifetime& backend) noexcept {
+    if (!onEventThread())
+        return eRegistryResult::WRONG_THREAD;
+    if (!backend)
+        return eRegistryResult::INVALID_IDENTITY;
+
+    const auto ITERATOR = m_states.find(WBackendLifetime{backend});
+    if (ITERATOR == m_states.end())
+        return eRegistryResult::NOT_FOUND;
+    if (!ITERATOR->second->readyForDestruction())
+        return eRegistryResult::NOT_READY;
+
+    m_states.erase(ITERATOR);
+    return eRegistryResult::OK;
+}
+
+bool CTiledBackendStateRegistry::readyForDestruction() const noexcept {
+    return m_states.empty();
+}
diff --git a/src/backend/drm/TiledBackendState.hpp b/src/backend/drm/TiledBackendState.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..ed89a5b0c088a825837e5a1d4410471fee320dc0
--- /dev/null
+++ b/src/backend/drm/TiledBackendState.hpp
@@ -0,0 +1,507 @@
+#pragma once
+
+#include "DRMIncarnations.hpp"
+#include "Tile.hpp"
+#include "TileModes.hpp"
+
+#include <cstdint>
+#include <map>
+#include <optional>
+#include <span>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include <hyprutils/memory/SharedPtr.hpp>
+#include <hyprutils/memory/UniquePtr.hpp>
+#include <hyprutils/memory/WeakPtr.hpp>
+
+namespace Aquamarine::NDRM::NTiledScan { // NOLINT(readability-identifier-naming): established project namespace
+    using NTiledIncarnations::CBackendLifetime;
+    using NTiledIncarnations::CDeviceIncarnation;
+    using NTiledIncarnations::CSessionIncarnation;
+    using NTiledIncarnations::eBackendBinding;
+    using NTiledIncarnations::PBackendLifetime;
+    using NTiledIncarnations::PDeviceIncarnation;
+    using NTiledIncarnations::PSessionIncarnation;
+    using NTiledIncarnations::WBackendLifetime;
+
+    // Defined only by source-private allocator tests. It may mint coherent
+    // immutable scan graphs without running the transactional scanner in every
+    // exhaustive oracle case; production constructors remain private.
+    class CScanFixtureAuthority;
+
+    class CStateAuthority final {};
+    using PStateAuthority = Hyprutils::Memory::CSharedPointer<CStateAuthority>;
+
+    class CScanObservation final {
+      public:
+        CScanObservation(const CScanObservation&)                                   = delete;
+        CScanObservation(CScanObservation&&)                                        = delete;
+        CScanObservation&                        operator=(const CScanObservation&) = delete;
+        CScanObservation&                        operator=(CScanObservation&&)      = delete;
+
+        [[nodiscard]] const PSessionIncarnation& session() const;
+        [[nodiscard]] const PDeviceIncarnation&  device() const;
+        [[nodiscard]] uint64_t                   serial() const;
+        [[nodiscard]] uint64_t                   resourceEpoch() const;
+
+      private:
+        CScanObservation(PSessionIncarnation session, uint64_t serial, uint64_t resourceEpoch);
+
+        PSessionIncarnation m_session;
+        uint64_t            m_serial        = 0;
+        uint64_t            m_resourceEpoch = 0;
+
+        friend class CTiledBackendState;
+        friend class CScanFixtureAuthority;
+    };
+
+    using PScanObservation = Hyprutils::Memory::CSharedPointer<CScanObservation>;
+
+    class CScanAttemptTicket final {
+      public:
+        CScanAttemptTicket(const CScanAttemptTicket&)               = delete;
+        CScanAttemptTicket(CScanAttemptTicket&&)                    = delete;
+        CScanAttemptTicket&    operator=(const CScanAttemptTicket&) = delete;
+        CScanAttemptTicket&    operator=(CScanAttemptTicket&&)      = delete;
+
+        [[nodiscard]] uint64_t serial() const;
+        [[nodiscard]] uint64_t resourceEpoch() const;
+
+      private:
+        CScanAttemptTicket(PStateAuthority state, WBackendLifetime backend, PDeviceIncarnation device, PSessionIncarnation session, PScanObservation observation,
+                           uint64_t lifecycleEpoch);
+
+        PStateAuthority     m_state;
+        WBackendLifetime    m_backend;
+        PDeviceIncarnation  m_device;
+        PSessionIncarnation m_session;
+        PScanObservation    m_observation;
+        uint64_t            m_lifecycleEpoch = 0;
+
+        friend class CTiledBackendState;
+        friend class CPreparedScan;
+        friend class CScanAttempt;
+        friend class CScanFixtureAuthority;
+    };
+
+    using PScanAttemptTicket = Hyprutils::Memory::CSharedPointer<CScanAttemptTicket>;
+
+    struct SConnectorView {
+        uint32_t                     connectorId = 0;
+        bool                         connected   = true;
+        bool                         isMonitor   = true;
+        bool                         nonDesktop  = false;
+        std::optional<std::string>   tileProperty;
+        std::vector<drmModeModeInfo> modes;
+    };
+
+    enum class eScanCompleteness : uint8_t {
+        COMPLETE = 0,
+        INCOMPLETE,
+    };
+
+    class CScanAttempt final {
+      public:
+        CScanAttempt(const CScanAttempt&)                                            = delete;
+        CScanAttempt(CScanAttempt&&)                                                 = delete;
+        CScanAttempt&                                 operator=(const CScanAttempt&) = delete;
+        CScanAttempt&                                 operator=(CScanAttempt&&)      = delete;
+
+        [[nodiscard]] const PScanAttemptTicket&       ticket() const;
+        [[nodiscard]] const PScanObservation&         observation() const;
+        [[nodiscard]] const PDeviceIncarnation&       device() const;
+        [[nodiscard]] eScanCompleteness               completeness() const;
+        [[nodiscard]] std::span<const SConnectorView> connectors() const;
+
+      private:
+        CScanAttempt(PScanAttemptTicket ticket, eScanCompleteness completeness, std::vector<SConnectorView> connectors);
+
+        PScanAttemptTicket          m_ticket;
+        eScanCompleteness           m_completeness = eScanCompleteness::INCOMPLETE;
+        std::vector<SConnectorView> m_connectors;
+
+        friend class CTiledBackendState;
+        friend class CScanFixtureAuthority;
+    };
+
+    using PScanAttempt = Hyprutils::Memory::CSharedPointer<CScanAttempt>;
+
+    // This owner is the only canonical scan authority for one validated tiled
+    // group. The allocator adapter must retain this exact owner directly in its
+    // immutable definition. A same-value clone is not an equivalent source.
+    class CScanGroupDefinition final {
+      public:
+        CScanGroupDefinition(const CScanGroupDefinition&)                               = delete;
+        CScanGroupDefinition(CScanGroupDefinition&&)                                    = delete;
+        CScanGroupDefinition&                    operator=(const CScanGroupDefinition&) = delete;
+        CScanGroupDefinition&                    operator=(CScanGroupDefinition&&)      = delete;
+
+        [[nodiscard]] const PDeviceIncarnation&  device() const;
+        [[nodiscard]] const PSessionIncarnation& session() const;
+        [[nodiscard]] const NTiling::STileGroup& group() const;
+
+      private:
+        CScanGroupDefinition(PDeviceIncarnation device, PSessionIncarnation session, NTiling::STileGroup group);
+
+        PDeviceIncarnation  m_device;
+        PSessionIncarnation m_session;
+        NTiling::STileGroup m_group;
+
+        friend class CTiledBackendState;
+        friend class CScanFixtureAuthority;
+    };
+
+    using PScanGroupDefinition = Hyprutils::Memory::CSharedPointer<CScanGroupDefinition>;
+
+    struct SLogicalModeProjection {
+        NTiling::STileLogicalMode logical;
+        // This descriptor is deliberately not a stable SP<SOutputMode>. The
+        // production adapter must allocate and retain those owners, and keep
+        // modeInfo empty for logical multi-stream modes. That adapter remains a
+        // blocker before these modes can be published.
+        drmModeModeInfo modeInfo = {};
+    };
+
+    class CScanModeDefinition final {
+      public:
+        CScanModeDefinition(const CScanModeDefinition&)                                             = delete;
+        CScanModeDefinition(CScanModeDefinition&&)                                                  = delete;
+        CScanModeDefinition&                                  operator=(const CScanModeDefinition&) = delete;
+        CScanModeDefinition&                                  operator=(CScanModeDefinition&&)      = delete;
+
+        [[nodiscard]] const PScanGroupDefinition&             definition() const;
+        [[nodiscard]] std::span<const SLogicalModeProjection> logicalModes() const;
+        [[nodiscard]] std::span<const NTiling::STileModeMap>  physicalMappings() const;
+
+      private:
+        CScanModeDefinition(PScanGroupDefinition definition, NTiling::STileModeSynthesisResult synthesis);
+
+        PScanGroupDefinition                m_definition;
+        NTiling::STileModeSynthesisResult   m_synthesis;
+        std::vector<SLogicalModeProjection> m_logicalModes;
+
+        friend class CTiledBackendState;
+        friend class CScanFixtureAuthority;
+    };
+
+    using PScanModeDefinition = Hyprutils::Memory::CSharedPointer<CScanModeDefinition>;
+
+    enum class eConnectorRole : uint8_t {
+        ORDINARY = 0,
+        MULTI_STREAM_PRIMARY,
+        MULTI_STREAM_MEMBER,
+        DRIVER_UNIFIED_PRIMARY,
+        DRIVER_UNIFIED_REDUNDANT,
+    };
+
+    enum class eConnectorDisposition : uint8_t {
+        // Genuine multi-stream members remain ordinary in this phase. A later
+        // adapter may suppress them only for an ALLOCATED aggregate. NO_MATCH
+        // must retain every safely allocated ordinary member output.
+        PUBLISH_ORDINARY = 0,
+        SUPPRESS_REDUNDANT,
+    };
+
+    struct SConnectorProjection {
+        uint32_t              connectorId = 0;
+        eConnectorRole        role        = eConnectorRole::ORDINARY;
+        eConnectorDisposition disposition = eConnectorDisposition::PUBLISH_ORDINARY;
+        PScanGroupDefinition  definition;
+        PScanModeDefinition   modes;
+    };
+
+    struct SCommittedConnector {
+        SConnectorView       view;
+        SConnectorProjection projection;
+    };
+
+    class CCommittedScan final {
+      public:
+        CCommittedScan(const CCommittedScan&)                                                = delete;
+        CCommittedScan(CCommittedScan&&)                                                     = delete;
+        CCommittedScan&                                     operator=(const CCommittedScan&) = delete;
+        CCommittedScan&                                     operator=(CCommittedScan&&)      = delete;
+
+        [[nodiscard]] const PScanAttempt&                   attempt() const;
+        [[nodiscard]] const PDeviceIncarnation&             device() const;
+        [[nodiscard]] const PScanObservation&               observation() const;
+        [[nodiscard]] std::span<const SCommittedConnector>  connectors() const;
+        [[nodiscard]] std::span<const PScanGroupDefinition> definitions() const;
+        [[nodiscard]] std::span<const PScanModeDefinition>  modeDefinitions() const;
+        [[nodiscard]] const SCommittedConnector*            findConnector(uint32_t connectorId) const;
+
+      private:
+        CCommittedScan(PScanAttempt attempt, std::vector<SCommittedConnector> connectors, std::vector<PScanGroupDefinition> definitions,
+                       std::vector<PScanModeDefinition> modeDefinitions);
+
+        PScanAttempt                      m_attempt;
+        std::vector<SCommittedConnector>  m_connectors;
+        std::vector<PScanGroupDefinition> m_definitions;
+        std::vector<PScanModeDefinition>  m_modeDefinitions;
+
+        friend class CTiledBackendState;
+        friend class CScanFixtureAuthority;
+    };
+
+    using PCommittedScan = Hyprutils::Memory::CSharedPointer<CCommittedScan>;
+
+    class CPreparedScan final {
+      public:
+        CPreparedScan(const CPreparedScan&)                                 = delete;
+        CPreparedScan(CPreparedScan&&)                                      = delete;
+        CPreparedScan&                      operator=(const CPreparedScan&) = delete;
+        CPreparedScan&                      operator=(CPreparedScan&&)      = delete;
+
+        [[nodiscard]] const PScanAttempt&   attempt() const;
+        [[nodiscard]] const PCommittedScan& candidate() const;
+
+      private:
+        CPreparedScan(PStateAuthority state, WBackendLifetime backend, PDeviceIncarnation device, PSessionIncarnation session, PScanAttempt attempt, PCommittedScan base,
+                      PCommittedScan candidate, uint64_t lifecycleEpoch);
+
+        PStateAuthority     m_state;
+        WBackendLifetime    m_backend;
+        PDeviceIncarnation  m_device;
+        PSessionIncarnation m_session;
+        PScanAttempt        m_attempt;
+        PCommittedScan      m_base;
+        PCommittedScan      m_candidate;
+        uint64_t            m_lifecycleEpoch = 0;
+
+        friend class CTiledBackendState;
+    };
+
+    using PPreparedScan = Hyprutils::Memory::CSharedPointer<CPreparedScan>;
+
+    enum class eScanOutcome : uint8_t {
+        NONE = 0,
+        PREPARING,
+        AWAITING_VALIDATION,
+        COMMITTED,
+        INCOMPLETE,
+        ACQUISITION_FAILED,
+        PREPARATION_FAILED,
+        VALIDATION_REJECTED,
+        VALIDATION_FAILED,
+        STALE_OBSERVATION,
+        STALE_PREPARED,
+        SERIAL_EXHAUSTED,
+        STALE_RESOURCE_EPOCH,
+        RESOURCE_EPOCH_EXHAUSTED,
+        INVALID_OBSERVATION,
+        BACKEND_EXPIRED,
+        SESSION_ROTATED,
+        TEARING_DOWN,
+    };
+
+    struct SScanOutcome {
+        eScanOutcome       result = eScanOutcome::NONE;
+        uint64_t           serial = 0;
+        PScanAttemptTicket ticket;
+        PScanObservation   observation;
+        PScanAttempt       attempt;
+    };
+
+    enum class eBeginAttemptResult : uint8_t {
+        STARTED = 0,
+        WRONG_THREAD,
+        TEARING_DOWN,
+        BACKEND_EXPIRED,
+        INVALID_RESOURCE_EPOCH,
+        STALE_RESOURCE_EPOCH,
+        BUSY,
+        SERIAL_EXHAUSTED,
+        RESOURCE_EPOCH_EXHAUSTED,
+        PREPARATION_FAILED,
+    };
+
+    struct SBeginAttemptResult {
+        PScanAttemptTicket  ticket;
+        eBeginAttemptResult result = eBeginAttemptResult::STARTED;
+
+        explicit            operator bool() const;
+    };
+
+    enum class ePrepareScanResult : uint8_t {
+        PREPARED = 0,
+        INCOMPLETE,
+        WRONG_THREAD,
+        TEARING_DOWN,
+        BACKEND_EXPIRED,
+        FOREIGN_TICKET,
+        STALE_TICKET,
+        BUSY,
+        PREPARATION_FAILED,
+    };
+
+    struct SPrepareScanResult {
+        PScanAttempt       attempt;
+        PPreparedScan      prepared;
+        ePrepareScanResult result = ePrepareScanResult::PREPARED;
+
+        explicit           operator bool() const;
+    };
+
+    enum class eValidationDecision : uint8_t {
+        ACCEPTED = 0,
+        REJECTED,
+        FAILED,
+    };
+
+    enum class eScanInstallResult : uint8_t {
+        COMMITTED = 0,
+        VALIDATION_REJECTED,
+        VALIDATION_FAILED,
+        WRONG_THREAD,
+        TEARING_DOWN,
+        BACKEND_EXPIRED,
+        FOREIGN_PREPARED,
+        STALE_PREPARED,
+        BUSY,
+        WRONG_DEVICE,
+        BASE_CHANGED,
+    };
+
+    enum class eAttemptFailure : uint8_t {
+        ACQUISITION_FAILED = 0,
+        PREPARATION_FAILED,
+        VALIDATION_FAILED,
+    };
+
+    enum class eResolveAttemptResult : uint8_t {
+        RESOLVED = 0,
+        WRONG_THREAD,
+        FOREIGN_TICKET,
+        STALE_TICKET,
+    };
+
+    enum class eTeardownResult : uint8_t {
+        BEGUN = 0,
+        ALREADY_BEGUN,
+        WRONG_THREAD,
+        BACKEND_EXPIRED,
+        BUSY,
+    };
+
+    enum class eSessionRotationResult : uint8_t {
+        ROTATED = 0,
+        UNCHANGED,
+        WRONG_THREAD,
+        INVALID_IDENTITY,
+        STALE_IDENTITY,
+        TEARING_DOWN,
+        BUSY,
+    };
+
+    class CTiledBackendState final {
+      public:
+        ~CTiledBackendState() noexcept;
+
+        CTiledBackendState(const CTiledBackendState&)            = delete;
+        CTiledBackendState(CTiledBackendState&&)                 = delete;
+        CTiledBackendState& operator=(const CTiledBackendState&) = delete;
+        CTiledBackendState& operator=(CTiledBackendState&&)      = delete;
+
+        // Begin before acquiring connector resources. resourceEpoch is the
+        // adapter-minted ordering authority and must strictly advance; its
+        // exact value is also retained for the adapter's second resource
+        // validation. The state separately mints the observation serial.
+        // UINT64_MAX is a valid final value for either counter and permanently
+        // exhausts that counter.
+        // The adapter must arm a scope guard immediately and resolve this exact
+        // ticket through prepare(), install(), or fail(); BUSY never supersedes
+        // it.
+        [[nodiscard]] SBeginAttemptResult   beginAttempt(uint64_t resourceEpoch) noexcept;
+        [[nodiscard]] SPrepareScanResult    prepare(const PScanAttemptTicket& ticket, eScanCompleteness completeness, std::vector<SConnectorView> connectors) noexcept;
+        [[nodiscard]] eScanInstallResult    install(const PPreparedScan& prepared, eValidationDecision decision) noexcept;
+        [[nodiscard]] eResolveAttemptResult fail(const PScanAttemptTicket& ticket, eAttemptFailure failure) noexcept;
+        // Rotation is an explicit lifecycle boundary. All three successor
+        // counters must strictly advance without wrapping, including beyond
+        // the observation high-water. It is BUSY until the adapter resolves
+        // any active ticket/prepared scan, then makes every owner from the
+        // prior session stale.
+        [[nodiscard]] eSessionRotationResult rotateSession(const PSessionIncarnation& session) noexcept;
+        [[nodiscard]] PCommittedScan         committed() const;
+        [[nodiscard]] PCommittedScan         currentComplete() const;
+        [[nodiscard]] SScanOutcome           outcome() const noexcept;
+        [[nodiscard]] eTeardownResult        beginTeardown() noexcept;
+        [[nodiscard]] bool                   readyForDestruction() const noexcept;
+
+      private:
+        CTiledBackendState(WBackendLifetime backend, PDeviceIncarnation device, PSessionIncarnation session, std::thread::id eventThread);
+
+        [[nodiscard]] bool           onEventThread() const;
+        [[nodiscard]] bool           backendCurrent() const;
+        [[nodiscard]] PCommittedScan buildComplete(const PScanAttempt& attempt) const;
+        [[nodiscard]] bool           ownsTicket(const PScanAttemptTicket& ticket) const;
+        [[nodiscard]] bool           ownsPrepared(const PPreparedScan& prepared) const;
+        void                setOutcome(eScanOutcome result, uint64_t serial, PScanAttemptTicket ticket = {}, PScanObservation observation = {}, PScanAttempt attempt = {}) noexcept;
+        void                clearActiveTicket() noexcept;
+        void                clearActivePrepared() noexcept;
+
+        WBackendLifetime    m_backend;
+        PDeviceIncarnation  m_device;
+        PSessionIncarnation m_session;
+        PStateAuthority     m_stateAuthority;
+        std::thread::id     m_eventThread;
+        PScanAttemptTicket  m_activeTicket;
+        PPreparedScan       m_activePrepared;
+        PCommittedScan      m_committed;
+        SScanOutcome        m_outcome;
+        uint64_t            m_lastObservationSerial = 0;
+        uint64_t            m_lastResourceEpoch     = 0;
+        uint64_t            m_lifecycleEpoch        = 0;
+        bool                m_teardownBegun         = false;
+
+        friend class CTiledBackendStateRegistry;
+    };
+
+    enum class eRegistryResult : uint8_t {
+        OK = 0,
+        WRONG_THREAD,
+        INVALID_IDENTITY,
+        ALREADY_EXISTS,
+        NOT_FOUND,
+        NOT_READY,
+        BUSY,
+    };
+
+    struct SRegistryCreateResult {
+        CTiledBackendState* state  = nullptr;
+        eRegistryResult     result = eRegistryResult::OK;
+
+        explicit            operator bool() const;
+    };
+
+    // The exact backend owner must outlive its entry. Teardown is deliberately
+    // two-step: beginTeardown() then erase(). Destroying either a live state or
+    // a nonempty registry terminates instead of implying lifecycle callbacks.
+    class CTiledBackendStateRegistry final {
+      public:
+        explicit CTiledBackendStateRegistry(std::thread::id eventThread = std::this_thread::get_id());
+        ~CTiledBackendStateRegistry() noexcept;
+
+        CTiledBackendStateRegistry(const CTiledBackendStateRegistry&)                    = delete;
+        CTiledBackendStateRegistry(CTiledBackendStateRegistry&&)                         = delete;
+        CTiledBackendStateRegistry&         operator=(const CTiledBackendStateRegistry&) = delete;
+        CTiledBackendStateRegistry&         operator=(CTiledBackendStateRegistry&&)      = delete;
+
+        [[nodiscard]] SRegistryCreateResult create(const PBackendLifetime& backend, const PDeviceIncarnation& device, const PSessionIncarnation& session);
+        [[nodiscard]] CTiledBackendState*   find(const PBackendLifetime& backend);
+        [[nodiscard]] eRegistryResult       beginTeardown(const PBackendLifetime& backend) noexcept;
+        [[nodiscard]] eRegistryResult       erase(const PBackendLifetime& backend) noexcept;
+        [[nodiscard]] bool                  readyForDestruction() const noexcept;
+
+      private:
+        using UBackendState = Hyprutils::Memory::CUniquePointer<CTiledBackendState>;
+        using SStateMap     = std::map<WBackendLifetime, UBackendState>;
+
+        [[nodiscard]] bool onEventThread() const;
+
+        std::thread::id    m_eventThread;
+        SStateMap          m_states;
+    };
+
+}
diff --git a/src/backend/drm/TiledCrtcAllocator.cpp b/src/backend/drm/TiledCrtcAllocator.cpp
index 359dd942f5caa7f0b910a84a305fe837724ad7d7..62949e2f1d133b458d744d31857086a029cd6a55 100644
--- a/src/backend/drm/TiledCrtcAllocator.cpp
+++ b/src/backend/drm/TiledCrtcAllocator.cpp
@@ -33,38 +33,17 @@ namespace Aquamarine::NDRM::NTiledCrtcAllocator { // NOLINT(readability-identifi
     };
 
     namespace {
-        template <typename T>
-        bool sameOwner(const CSharedPointer<const T>& lhs, const CSharedPointer<const T>& rhs) {
+        template <typename T, typename U>
+        bool sameOwner(const CSharedPointer<T>& lhs, const CSharedPointer<U>& rhs) {
             return lhs.impl_ != nullptr && lhs.impl_ == rhs.impl_;
         }
 
-        template <typename T>
-        bool sameWeakOwner(const CWeakPointer<T>& lhs, const CWeakPointer<T>& rhs) {
-            return lhs.impl_ == rhs.impl_;
-        }
-
         bool validGeneration(const SGeneration& generation) {
             return generation.device != 0 && generation.session != 0 && generation.observation != 0;
         }
 
-        bool validBackendBinding(const SDeviceIncarnation& device) {
-            if (!device.backendLifetime.valid())
-                return false;
-            const auto lifetime = device.backendLifetime.lock();
-            if (!lifetime || lifetime->serial == 0)
-                return false;
-            switch (device.binding) {
-                case eBackendBinding::LIFETIME_TOKEN: return device.backend.impl_ == nullptr;
-                case eBackendBinding::PRODUCTION_BACKEND: return device.backend.valid();
-            }
-            return false;
-        }
-
-        bool matchesBackendLifetime(const SDeviceIncarnation& device, const CSharedPointer<const SBackendIncarnation>& lifetime) {
-            if (!lifetime || lifetime->serial == 0 || !validBackendBinding(device))
-                return false;
-            const auto captured = device.backendLifetime.lock();
-            return sameOwner(captured, lifetime);
+        bool matchesBackendLifetime(const PDeviceIncarnation& device, const PBackendLifetime& lifetime) {
+            return device && device->valid() && lifetime && lifetime->valid() && device->backend() == lifetime;
         }
 
         template <typename T>
@@ -78,10 +57,56 @@ namespace Aquamarine::NDRM::NTiledCrtcAllocator { // NOLINT(readability-identifi
             return std::ranges::binary_search(values, value);
         }
 
-        bool validIncarnation(const CSharedPointer<const SResourceIncarnation>& incarnation, eResourceKind kind, uint32_t id, const SGeneration& generation,
-                              const CSharedPointer<const SDeviceIncarnation>& device, const CSharedPointer<const SObservationIncarnation>& observation) {
-            return incarnation && incarnation->kind == kind && incarnation->resourceID == id && incarnation->serial != 0 && incarnation->generation == generation &&
-                sameOwner(incarnation->device, device) && sameOwner(incarnation->observation, observation);
+        bool validIncarnation(const CSharedPointer<const SResourceIncarnation>& incarnation, eResourceKind kind, uint32_t id, const PScanObservation& observation,
+                              uint64_t allocationEpoch) {
+            return incarnation && incarnation->kind() == kind && incarnation->resourceID() == id && incarnation->serial() != 0 &&
+                sameOwner(incarnation->observation(), observation) && incarnation->allocationEpoch() == allocationEpoch;
+        }
+
+        bool currentScanChain(const PCommittedScan& scan) {
+            if (!scan || !scan->attempt() || scan->attempt()->completeness() != NTiledScan::eScanCompleteness::COMPLETE || !scan->observation() || !scan->device())
+                return false;
+            const auto& observation = scan->observation();
+            const auto& session     = observation->session();
+            const auto& device      = observation->device();
+            if (!session || session->eventThread() != std::this_thread::get_id())
+                return false;
+            const auto backend = device ? device->backend().lock() : PBackendLifetime{};
+            return session && session->valid() && device && device->valid() && backend && backend->valid() && sameOwner(scan->device(), device) &&
+                sameOwner(scan->attempt()->observation(), observation) && sameOwner(session->device(), device) && session->backend() == backend && device->backend() == backend &&
+                session->eventThread() == std::this_thread::get_id();
+        }
+
+        bool snapshotResourcesCurrent(const CSharedPointer<const CSnapshot>& snapshot) {
+            if (!snapshot || !currentScanChain(snapshot->scan()) || !sameOwner(snapshot->scan()->observation(), snapshot->observation()) ||
+                !sameOwner(snapshot->observation()->session(), snapshot->session()) || !sameOwner(snapshot->session()->device(), snapshot->device()) ||
+                snapshot->allocationEpoch() == 0)
+                return false;
+            const auto backend = snapshot->device()->backend().lock();
+            if (!backend || !backend->valid())
+                return false;
+            CSharedPointer<CDRMBackend> liveProductionBackend;
+            if (backend->binding() == NTiledIncarnations::eBackendBinding::PRODUCTION_BACKEND) {
+                liveProductionBackend = backend->drmBackend().lock();
+                if (!liveProductionBackend)
+                    return false;
+            }
+            for (const auto& connector : snapshot->connectors()) {
+                if (!connector.connector || !backend->matchesResourceBackend(connector.connector->backend) ||
+                    !validIncarnation(connector.incarnation, eResourceKind::CONNECTOR, connector.connector->id, snapshot->observation(), snapshot->allocationEpoch()))
+                    return false;
+            }
+            for (const auto& crtc : snapshot->crtcs()) {
+                if (!crtc.crtc || !backend->matchesResourceBackend(crtc.crtc->backend) ||
+                    !validIncarnation(crtc.incarnation, eResourceKind::CRTC, crtc.crtc->id, snapshot->observation(), snapshot->allocationEpoch()))
+                    return false;
+            }
+            for (const auto& plane : snapshot->primaryPlanes()) {
+                if (!plane.plane || !backend->matchesResourceBackend(plane.plane->backend) ||
+                    !validIncarnation(plane.incarnation, eResourceKind::PRIMARY_PLANE, plane.plane->id, snapshot->observation(), snapshot->allocationEpoch()))
+                    return false;
+            }
+            return true;
         }
 
         bool tileMemberLess(const NTiling::STileGroupMember& lhs, const NTiling::STileGroupMember& rhs) {
@@ -563,56 +588,110 @@ namespace Aquamarine::NDRM::NTiledCrtcAllocator { // NOLINT(readability-identifi
         return ids;
     }
 
-    CSnapshot::CSnapshot(SGeneration generation, CSharedPointer<const SDeviceIncarnation> device, CSharedPointer<const SObservationIncarnation> observation,
-                         std::vector<SConnectorResource> connectors, std::vector<SCRTCResource> crtcs, std::vector<SPrimaryPlaneResource> primaryPlanes) :
-        m_generation(generation), m_device(std::move(device)), m_observation(std::move(observation)), m_connectors(std::move(connectors)), m_crtcs(std::move(crtcs)),
-        m_primaryPlanes(std::move(primaryPlanes)) {}
+    SResourceIncarnation::SResourceIncarnation(eResourceKind kind, uint32_t resourceID, uint64_t serial, PScanObservation observation, uint64_t allocationEpoch) :
+        m_kind(kind), m_resourceID(resourceID), m_serial(serial), m_observation(std::move(observation)), m_allocationEpoch(allocationEpoch) {}
 
-    CSharedPointer<const CSnapshot> CSnapshot::create(SGeneration generation, CSharedPointer<const SObservationIncarnation> observation, std::vector<SConnectorResource> connectors,
-                                                      std::vector<SCRTCResource> crtcs, std::vector<SPrimaryPlaneResource> primaryPlanes) {
-        if (crtcs.size() > std::numeric_limits<uint32_t>::digits || !validGeneration(generation) || !observation || observation->serial == 0 ||
-            !(observation->generation == generation) || !observation->device || observation->device->deviceId == 0 || observation->device->deviceEpoch == 0 ||
-            observation->device->fdEpoch == 0 || observation->device->serial == 0 || observation->device->deviceEpoch != generation.device ||
-            !validBackendBinding(*observation->device) || !sameWeakOwner(observation->backendLifetime, observation->device->backendLifetime))
+    eResourceKind SResourceIncarnation::kind() const {
+        return m_kind;
+    }
+
+    uint32_t SResourceIncarnation::resourceID() const {
+        return m_resourceID;
+    }
+
+    uint64_t SResourceIncarnation::serial() const {
+        return m_serial;
+    }
+
+    const PScanObservation& SResourceIncarnation::observation() const {
+        return m_observation;
+    }
+
+    uint64_t SResourceIncarnation::allocationEpoch() const {
+        return m_allocationEpoch;
+    }
+
+    CSnapshot::CSnapshot(SGeneration generation, PCommittedScan scan, PDeviceIncarnation device, PSessionIncarnation session, PScanObservation observation,
+                         uint64_t allocationEpoch, std::vector<SConnectorResource> connectors, std::vector<SCRTCResource> crtcs, std::vector<SPrimaryPlaneResource> primaryPlanes) :
+        m_generation(generation), m_scan(std::move(scan)), m_device(std::move(device)), m_session(std::move(session)), m_observation(std::move(observation)),
+        m_allocationEpoch(allocationEpoch), m_connectors(std::move(connectors)), m_crtcs(std::move(crtcs)), m_primaryPlanes(std::move(primaryPlanes)) {}
+
+    CSharedPointer<const CSnapshot> CSnapshot::create(PCommittedScan scan, uint64_t allocationEpoch, std::vector<SConnectorCapture> connectorCaptures,
+                                                      std::vector<SCRTCCapture> crtcCaptures, std::vector<SPrimaryPlaneCapture> planeCaptures) {
+        if (crtcCaptures.size() > std::numeric_limits<uint32_t>::digits || allocationEpoch == 0 || !currentScanChain(scan))
             return {};
-        const auto device = observation->device;
 
-        const auto connectorLess = [](const SConnectorResource& lhs, const SConnectorResource& rhs) { return lhs.connector->id < rhs.connector->id; };
-        const auto crtcLess      = [](const SCRTCResource& lhs, const SCRTCResource& rhs) { return lhs.crtc->id < rhs.crtc->id; };
-        const auto planeLess     = [](const SPrimaryPlaneResource& lhs, const SPrimaryPlaneResource& rhs) { return lhs.plane->id < rhs.plane->id; };
-
-        for (auto& connector : connectors) {
-            if (!connector.connector || connector.connector->id == 0 || !sameWeakOwner(connector.connector->backend, device->backend) ||
-                !validIncarnation(connector.incarnation, eResourceKind::CONNECTOR, connector.connector->id, generation, device, observation))
-                return {};
-            sortUnique(connector.possibleCRTCIDs);
-        }
-        for (const auto& crtc : crtcs) {
-            if (!crtc.crtc || crtc.crtc->id == 0 || !sameWeakOwner(crtc.crtc->backend, device->backend) ||
-                !validIncarnation(crtc.incarnation, eResourceKind::CRTC, crtc.crtc->id, generation, device, observation))
-                return {};
-        }
-        for (auto& plane : primaryPlanes) {
-            if (!plane.plane || plane.plane->id == 0 || plane.plane->type != DRM_PLANE_TYPE_PRIMARY || !sameWeakOwner(plane.plane->backend, device->backend) ||
-                !validIncarnation(plane.incarnation, eResourceKind::PRIMARY_PLANE, plane.plane->id, generation, device, observation))
-                return {};
-            sortUnique(plane.possibleCRTCIDs);
-        }
-
-        std::ranges::sort(connectors, connectorLess);
-        std::ranges::sort(crtcs, crtcLess);
-        std::ranges::sort(primaryPlanes, planeLess);
-
-        if (std::ranges::adjacent_find(connectors, [](const auto& lhs, const auto& rhs) { return lhs.connector->id == rhs.connector->id; }) != connectors.end() ||
-            std::ranges::adjacent_find(crtcs, [](const auto& lhs, const auto& rhs) { return lhs.crtc->id == rhs.crtc->id; }) != crtcs.end() ||
-            std::ranges::adjacent_find(primaryPlanes, [](const auto& lhs, const auto& rhs) { return lhs.plane->id == rhs.plane->id; }) != primaryPlanes.end())
+        const auto        observation = scan->observation();
+        const auto        session     = observation->session();
+        const auto        device      = observation->device();
+        const auto        backend     = device->backend().lock();
+        const SGeneration generation  = {
+            .device      = device->deviceEpoch(),
+            .session     = session->sessionEpoch(),
+            .observation = observation->serial(),
+        };
+        if (!validGeneration(generation) || observation->resourceEpoch() == 0 || !backend || !backend->valid())
             return {};
+        CSharedPointer<CDRMBackend> liveProductionBackend;
+        if (backend->binding() == NTiledIncarnations::eBackendBinding::PRODUCTION_BACKEND) {
+            liveProductionBackend = backend->drmBackend().lock();
+            if (!liveProductionBackend)
+                return {};
+        }
+
+        std::ranges::sort(connectorCaptures, {}, [](const SConnectorCapture& capture) { return capture.connector ? capture.connector->id : 0; });
+        std::ranges::sort(crtcCaptures, {}, [](const SCRTCCapture& capture) { return capture.crtc ? capture.crtc->id : 0; });
+        std::ranges::sort(planeCaptures, {}, [](const SPrimaryPlaneCapture& capture) { return capture.plane ? capture.plane->id : 0; });
+        if (std::ranges::adjacent_find(connectorCaptures,
+                                       [](const auto& lhs, const auto& rhs) { return lhs.connector && rhs.connector && lhs.connector->id == rhs.connector->id; }) !=
+                connectorCaptures.end() ||
+            std::ranges::adjacent_find(crtcCaptures, [](const auto& lhs, const auto& rhs) { return lhs.crtc && rhs.crtc && lhs.crtc->id == rhs.crtc->id; }) != crtcCaptures.end() ||
+            std::ranges::adjacent_find(planeCaptures, [](const auto& lhs, const auto& rhs) { return lhs.plane && rhs.plane && lhs.plane->id == rhs.plane->id; }) !=
+                planeCaptures.end())
+            return {};
+
+        std::set<uint32_t> scanConnectorIDs;
+        for (const auto& connector : scan->connectors())
+            scanConnectorIDs.insert(connector.view.connectorId);
+        if (scanConnectorIDs.size() != scan->connectors().size() || scanConnectorIDs.size() != connectorCaptures.size())
+            return {};
+
+        std::vector<SConnectorResource>    connectors;
+        std::vector<SCRTCResource>         crtcs;
+        std::vector<SPrimaryPlaneResource> primaryPlanes;
+        connectors.reserve(connectorCaptures.size());
+        crtcs.reserve(crtcCaptures.size());
+        primaryPlanes.reserve(planeCaptures.size());
+        uint64_t nextSerial = 1;
+        for (auto& capture : connectorCaptures) {
+            if (!capture.connector || capture.connector->id == 0 || !scanConnectorIDs.contains(capture.connector->id) ||
+                !backend->matchesResourceBackend(capture.connector->backend))
+                return {};
+            sortUnique(capture.possibleCRTCIDs);
+            CSharedPointer<const SResourceIncarnation> incarnation{
+                new SResourceIncarnation{eResourceKind::CONNECTOR, capture.connector->id, nextSerial++, observation, allocationEpoch}};
+            connectors.push_back({.connector = std::move(capture.connector), .incarnation = std::move(incarnation), .possibleCRTCIDs = std::move(capture.possibleCRTCIDs)});
+        }
+        for (auto& capture : crtcCaptures) {
+            if (!capture.crtc || capture.crtc->id == 0 || !backend->matchesResourceBackend(capture.crtc->backend))
+                return {};
+            CSharedPointer<const SResourceIncarnation> incarnation{new SResourceIncarnation{eResourceKind::CRTC, capture.crtc->id, nextSerial++, observation, allocationEpoch}};
+            crtcs.push_back({.crtc = std::move(capture.crtc), .incarnation = std::move(incarnation)});
+        }
+        for (auto& capture : planeCaptures) {
+            if (!capture.plane || capture.plane->id == 0 || !backend->matchesResourceBackend(capture.plane->backend))
+                return {};
+            sortUnique(capture.possibleCRTCIDs);
+            CSharedPointer<const SResourceIncarnation> incarnation{
+                new SResourceIncarnation{eResourceKind::PRIMARY_PLANE, capture.plane->id, nextSerial++, observation, allocationEpoch}};
+            primaryPlanes.push_back(
+                {.plane = std::move(capture.plane), .incarnation = std::move(incarnation), .possibleCRTCIDs = std::move(capture.possibleCRTCIDs), .usable = capture.usable});
+        }
 
         std::vector<uint32_t> crtcIDs;
         crtcIDs.reserve(crtcs.size());
         for (const auto& crtc : crtcs)
             crtcIDs.push_back(crtc.crtc->id);
-
         const auto referencesUnknownCRTC = [&crtcIDs](const std::vector<uint32_t>& possible) {
             return std::ranges::any_of(possible, [&crtcIDs](uint32_t id) { return !std::ranges::binary_search(crtcIDs, id); });
         };
@@ -620,7 +699,8 @@ namespace Aquamarine::NDRM::NTiledCrtcAllocator { // NOLINT(readability-identifi
             std::ranges::any_of(primaryPlanes, [&](const auto& plane) { return referencesUnknownCRTC(plane.possibleCRTCIDs); }))
             return {};
 
-        CSharedPointer<CSnapshot> snapshot(new CSnapshot(generation, device, std::move(observation), std::move(connectors), std::move(crtcs), std::move(primaryPlanes)));
+        CSharedPointer<CSnapshot> snapshot(
+            new CSnapshot(generation, scan, device, session, observation, allocationEpoch, std::move(connectors), std::move(crtcs), std::move(primaryPlanes)));
         return snapshot;
     }
 
@@ -628,14 +708,26 @@ namespace Aquamarine::NDRM::NTiledCrtcAllocator { // NOLINT(readability-identifi
         return m_generation;
     }
 
-    const CSharedPointer<const SDeviceIncarnation>& CSnapshot::device() const {
+    const PCommittedScan& CSnapshot::scan() const {
+        return m_scan;
+    }
+
+    const PDeviceIncarnation& CSnapshot::device() const {
         return m_device;
     }
 
-    const CSharedPointer<const SObservationIncarnation>& CSnapshot::observation() const {
+    const PSessionIncarnation& CSnapshot::session() const {
+        return m_session;
+    }
+
+    const PScanObservation& CSnapshot::observation() const {
         return m_observation;
     }
 
+    uint64_t CSnapshot::allocationEpoch() const {
+        return m_allocationEpoch;
+    }
+
     const std::vector<SConnectorResource>& CSnapshot::connectors() const {
         return m_connectors;
     }
@@ -648,99 +740,76 @@ namespace Aquamarine::NDRM::NTiledCrtcAllocator { // NOLINT(readability-identifi
         return m_primaryPlanes;
     }
 
-    CGroupDefinition::CGroupDefinition(NTiling::STileGroup group, CSharedPointer<const SDeviceIncarnation> device, uint64_t definitionSerial) :
-        m_group(std::move(group)), m_device(std::move(device)), m_serial(definitionSerial) {}
+    CGroupDefinition::CGroupDefinition(PScanGroupDefinition definition) : m_definition(std::move(definition)) {}
 
-    CSharedPointer<const CGroupDefinition> CGroupDefinition::create(NTiling::STileGroup group, CSharedPointer<const SDeviceIncarnation> device, uint64_t definitionSerial) {
-        if (!device || device->deviceId == 0 || device->deviceEpoch == 0 || device->fdEpoch == 0 || device->serial == 0 || !validBackendBinding(*device) || definitionSerial == 0 ||
-            group.key.deviceId == 0 || group.key.groupId == 0 || group.key.deviceId != device->deviceId || group.kind != NTiling::eTileGroupKind::MULTI_STREAM ||
-            !group.isSingleMonitor || group.members.size() <= 1 || group.numHTile == 0 || group.numVTile == 0 || group.width == 0 || group.height == 0 ||
-            group.primaryConnector == 0)
+    CSharedPointer<const CGroupDefinition> CGroupDefinition::create(PScanGroupDefinition definition) {
+        if (!definition || !definition->session() || definition->session()->eventThread() != std::this_thread::get_id() || !definition->device() ||
+            !definition->device()->valid() || !definition->session()->valid() || !sameOwner(definition->session()->device(), definition->device()) ||
+            definition->group().kind != NTiling::eTileGroupKind::MULTI_STREAM || definition->group().key.deviceId != definition->device()->deviceId())
             return {};
+        CSharedPointer<CGroupDefinition> result(new CGroupDefinition(std::move(definition)));
+        return result;
+    }
 
-        const uint64_t expectedMembers = static_cast<uint64_t>(group.numHTile) * group.numVTile;
-        if (expectedMembers != group.members.size())
-            return {};
-
-        std::ranges::sort(group.members, tileMemberLess);
-        std::set<uint32_t>                      connectorIDs;
-        std::set<std::pair<uint32_t, uint32_t>> coordinates;
-        std::vector<uint32_t>                   columnWidths(group.numHTile);
-        std::vector<uint32_t>                   rowHeights(group.numVTile);
-        for (const auto& member : group.members) {
-            if (member.connectorId == 0 || member.tileHLoc >= group.numHTile || member.tileVLoc >= group.numVTile || member.width == 0 || member.height == 0 ||
-                !connectorIDs.insert(member.connectorId).second || !coordinates.emplace(member.tileVLoc, member.tileHLoc).second)
-                return {};
-
-            auto& columnWidth = columnWidths.at(member.tileHLoc);
-            auto& rowHeight   = rowHeights.at(member.tileVLoc);
-            if ((columnWidth != 0 && columnWidth != member.width) || (rowHeight != 0 && rowHeight != member.height))
-                return {};
-            columnWidth = member.width;
-            rowHeight   = member.height;
-        }
-
-        if (group.primaryConnector != group.members.front().connectorId)
-            return {};
-
-        std::vector<uint32_t> xOffsets(group.numHTile);
-        std::vector<uint32_t> yOffsets(group.numVTile);
-        uint64_t              width  = 0;
-        uint64_t              height = 0;
-        for (size_t index = 0; index < columnWidths.size(); ++index) {
-            xOffsets.at(index) = static_cast<uint32_t>(width);
-            width += columnWidths.at(index);
-            if (width > std::numeric_limits<uint32_t>::max())
-                return {};
-        }
-        for (size_t index = 0; index < rowHeights.size(); ++index) {
-            yOffsets.at(index) = static_cast<uint32_t>(height);
-            height += rowHeights.at(index);
-            if (height > std::numeric_limits<uint32_t>::max())
-                return {};
-        }
-        if (width != group.width || height != group.height)
-            return {};
-        if (std::ranges::any_of(group.members, [&](const auto& member) { return member.x != xOffsets.at(member.tileHLoc) || member.y != yOffsets.at(member.tileVLoc); }))
-            return {};
-
-        CSharedPointer<CGroupDefinition> definition(new CGroupDefinition(std::move(group), std::move(device), definitionSerial));
-        return definition;
+    const PScanGroupDefinition& CGroupDefinition::scanDefinition() const {
+        return m_definition;
     }
 
     const NTiling::STileGroup& CGroupDefinition::group() const {
-        return m_group;
+        return m_definition->group();
     }
 
-    const CSharedPointer<const SDeviceIncarnation>& CGroupDefinition::device() const {
-        return m_device;
+    const PDeviceIncarnation& CGroupDefinition::device() const {
+        return m_definition->device();
     }
 
-    uint64_t CGroupDefinition::serial() const {
-        return m_serial;
+    const PSessionIncarnation& CGroupDefinition::session() const {
+        return m_definition->session();
     }
 
-    CAllocationObservation::CAllocationObservation(SSnapshotExpectation expected, CWeakPointer<const SBackendIncarnation> backendLifetime,
+    CAllocationObservation::CAllocationObservation(SSnapshotExpectation expected, PCommittedScan scan, WBackendLifetime backendLifetime,
                                                    std::vector<CSharedPointer<const CGroupDefinition>> currentGroupDefinitions, std::vector<SHardHold> hardHolds,
                                                    std::vector<SGroupRequest> groups, std::vector<SOrdinaryRequest> ordinary,
                                                    std::vector<SConnectorCRTCPreference> connectorPreferences, std::vector<SCRTCPlanePreference> planePreferences,
                                                    SAllocationEpoch epoch, std::thread::id eventThread) :
-        m_expected(std::move(expected)), m_backendLifetime(std::move(backendLifetime)), m_currentGroupDefinitions(std::move(currentGroupDefinitions)),
+        m_expected(std::move(expected)), m_scan(std::move(scan)), m_backendLifetime(std::move(backendLifetime)), m_currentGroupDefinitions(std::move(currentGroupDefinitions)),
         m_hardHolds(std::move(hardHolds)), m_groups(std::move(groups)), m_ordinary(std::move(ordinary)), m_connectorPreferences(std::move(connectorPreferences)),
         m_planePreferences(std::move(planePreferences)), m_epoch(epoch), m_eventThread(eventThread) {}
 
-    CSharedPointer<const CAllocationObservation> CAllocationObservation::create(CSharedPointer<const CSnapshot>                     snapshot,
-                                                                                CSharedPointer<const SBackendIncarnation>           currentBackendLifetime,
+    CSharedPointer<const CAllocationObservation> CAllocationObservation::create(PCommittedScan currentScan, CSharedPointer<const CSnapshot> snapshot,
                                                                                 std::vector<CSharedPointer<const CGroupDefinition>> currentGroupDefinitions,
                                                                                 std::vector<SHardHold> hardHolds, std::vector<SGroupRequest> groups,
                                                                                 std::vector<SOrdinaryRequest> ordinary, std::vector<SConnectorCRTCPreference> connectorPreferences,
                                                                                 std::vector<SCRTCPlanePreference> planePreferences, SAllocationEpoch epoch) {
-        if (!snapshot || !currentBackendLifetime || !matchesBackendLifetime(*snapshot->device(), currentBackendLifetime) || epoch.session == 0 || epoch.allocation == 0 ||
-            epoch.eventThread == 0 || epoch.session != snapshot->generation().session)
+        if (!currentScanChain(currentScan) || !snapshotResourcesCurrent(snapshot) || !sameOwner(currentScan, snapshot->scan()) ||
+            !sameOwner(currentScan->observation(), snapshot->observation()) || !sameOwner(currentScan->observation()->session(), snapshot->session()) ||
+            !sameOwner(currentScan->device(), snapshot->device()) || epoch.session == 0 || epoch.allocation == 0 || epoch.eventThread == 0 ||
+            epoch.session != snapshot->session()->sessionEpoch() || epoch.allocation != snapshot->allocationEpoch() ||
+            epoch.eventThread != snapshot->session()->eventThreadEpoch() || snapshot->session()->eventThread() != std::this_thread::get_id())
             return {};
-        CSharedPointer<CAllocationObservation> observation(new CAllocationObservation(
-            expectationFor(snapshot), CWeakPointer<const SBackendIncarnation>{currentBackendLifetime}, std::move(currentGroupDefinitions), std::move(hardHolds), std::move(groups),
-            std::move(ordinary), std::move(connectorPreferences), std::move(planePreferences), epoch, std::this_thread::get_id()));
+
+        std::vector<PScanGroupDefinition> authoritative;
+        for (const auto& definition : currentScan->definitions()) {
+            if (definition && definition->group().kind == NTiling::eTileGroupKind::MULTI_STREAM)
+                authoritative.push_back(definition);
+        }
+        if (authoritative.size() != currentGroupDefinitions.size() || !validDefinitionRegistry(currentGroupDefinitions))
+            return {};
+        std::set<const void*> matchedDefinitions;
+        for (const auto& definition : currentGroupDefinitions) {
+            if (!definition || !sameOwner(definition->device(), snapshot->device()) || !sameOwner(definition->session(), snapshot->session()))
+                return {};
+            const auto MATCH = std::ranges::find_if(authoritative, [&](const auto& candidate) { return sameOwner(candidate, definition->scanDefinition()); });
+            if (MATCH == authoritative.end() || !matchedDefinitions.insert(definition->scanDefinition().impl_).second)
+                return {};
+        }
+
+        const auto currentBackendLifetime = snapshot->device()->backend().lock();
+        if (!matchesBackendLifetime(snapshot->device(), currentBackendLifetime))
+            return {};
+        CSharedPointer<CAllocationObservation> observation(
+            new CAllocationObservation(expectationFor(snapshot), currentScan, WBackendLifetime{currentBackendLifetime}, std::move(currentGroupDefinitions), std::move(hardHolds),
+                                       std::move(groups), std::move(ordinary), std::move(connectorPreferences), std::move(planePreferences), epoch, std::this_thread::get_id()));
         return observation;
     }
 
@@ -748,7 +817,11 @@ namespace Aquamarine::NDRM::NTiledCrtcAllocator { // NOLINT(readability-identifi
         return m_expected;
     }
 
-    const CWeakPointer<const SBackendIncarnation>& CAllocationObservation::backendLifetime() const {
+    const PCommittedScan& CAllocationObservation::scan() const {
+        return m_scan;
+    }
+
+    const WBackendLifetime& CAllocationObservation::backendLifetime() const {
         return m_backendLifetime;
     }
 
@@ -878,7 +951,15 @@ namespace Aquamarine::NDRM::NTiledCrtcAllocator { // NOLINT(readability-identifi
     SSnapshotExpectation expectationFor(const CSharedPointer<const CSnapshot>& snapshot) {
         if (!snapshot)
             return {};
-        return {.snapshot = snapshot, .generation = snapshot->generation(), .device = snapshot->device(), .observation = snapshot->observation()};
+        return {
+            .snapshot        = snapshot,
+            .scan            = snapshot->scan(),
+            .device          = snapshot->device(),
+            .session         = snapshot->session(),
+            .observation     = snapshot->observation(),
+            .allocationEpoch = snapshot->allocationEpoch(),
+            .generation      = snapshot->generation(),
+        };
     }
 
     CSharedPointer<const CPlan> solve(const CSharedPointer<const CAllocationObservation>& observation) {
@@ -895,16 +976,28 @@ namespace Aquamarine::NDRM::NTiledCrtcAllocator { // NOLINT(readability-identifi
             return fail(ePlanStatus::INVALID);
 
         const auto& expected = observation->expected();
-        if (!(expected.generation == snapshot->generation()) || !sameOwner(expected.device, snapshot->device()) || !sameOwner(expected.observation, snapshot->observation()))
+        if (!sameOwner(expected.scan, snapshot->scan()) || !sameOwner(observation->scan(), snapshot->scan()) || !sameOwner(expected.device, snapshot->device()) ||
+            !sameOwner(expected.session, snapshot->session()) || !sameOwner(expected.observation, snapshot->observation()) ||
+            expected.allocationEpoch != snapshot->allocationEpoch() || !snapshotResourcesCurrent(snapshot))
             return fail(ePlanStatus::STALE);
         const auto backendLifetime = observation->backendLifetime().lock();
-        if (!matchesBackendLifetime(*snapshot->device(), backendLifetime) || observation->epoch().session != snapshot->generation().session)
+        if (!matchesBackendLifetime(snapshot->device(), backendLifetime) || observation->epoch().session != snapshot->session()->sessionEpoch() ||
+            observation->epoch().allocation != snapshot->allocationEpoch() || observation->epoch().eventThread != snapshot->session()->eventThreadEpoch() ||
+            snapshot->session()->eventThread() != std::this_thread::get_id())
             return fail(ePlanStatus::STALE);
+        CSharedPointer<CDRMBackend> liveProductionBackend;
+        if (backendLifetime->binding() == NTiledIncarnations::eBackendBinding::PRODUCTION_BACKEND) {
+            liveProductionBackend = backendLifetime->drmBackend().lock();
+            if (!liveProductionBackend)
+                return fail(ePlanStatus::STALE);
+        }
 
         auto currentDefinitions = observation->currentGroupDefinitions();
         if (!validDefinitionRegistry(currentDefinitions))
             return fail(ePlanStatus::INVALID);
-        if (std::ranges::any_of(currentDefinitions, [&](const auto& definition) { return !sameOwner(definition->device(), snapshot->device()); }))
+        if (std::ranges::any_of(currentDefinitions, [&](const auto& definition) {
+                return !sameOwner(definition->device(), snapshot->device()) || !sameOwner(definition->session(), snapshot->session());
+            }))
             return fail(ePlanStatus::STALE);
 
         SSolverContext context;
@@ -935,7 +1028,7 @@ namespace Aquamarine::NDRM::NTiledCrtcAllocator { // NOLINT(readability-identifi
         for (const auto& group : observation->groups()) {
             if (!group.definition)
                 return fail(ePlanStatus::INVALID);
-            if (!sameOwner(group.definition->device(), snapshot->device()))
+            if (!sameOwner(group.definition->device(), snapshot->device()) || !sameOwner(group.definition->session(), snapshot->session()))
                 return fail(ePlanStatus::STALE);
             if (std::ranges::any_of(group.connectors, [&](const auto& connector) { return !validConnector(connector); }))
                 return fail(ePlanStatus::STALE);
@@ -985,8 +1078,9 @@ namespace Aquamarine::NDRM::NTiledCrtcAllocator { // NOLINT(readability-identifi
         std::set<uint32_t> requestedConnectors;
         std::set<uint32_t> requestedGroupIDs;
         for (const auto& group : observation->groups()) {
-            const auto registered = std::ranges::find_if(currentDefinitions, [&](const auto& definition) { return definition->group().key == group.definition->group().key; });
-            if (registered == currentDefinitions.end() || !sameOwner(*registered, group.definition))
+            const auto registered =
+                std::ranges::find_if(currentDefinitions, [&](const auto& definition) { return sameOwner(definition->scanDefinition(), group.definition->scanDefinition()); });
+            if (registered == currentDefinitions.end())
                 return fail(ePlanStatus::STALE);
             if (!requestedGroupIDs.insert(group.definition->group().key.groupId).second)
                 return fail(ePlanStatus::INVALID);
@@ -1176,10 +1270,34 @@ namespace Aquamarine::NDRM::NTiledCrtcAllocator { // NOLINT(readability-identifi
     }
 
     bool withCurrentPlan(const CSharedPointer<const CPlan>& plan, const SCurrentState& current, const std::function<void(const CPlan&)>& callback) {
-        if (!plan || plan->status() != ePlanStatus::READY || !callback || !current.snapshot || !current.observation || !sameOwner(plan->snapshot(), current.snapshot) ||
-            !sameOwner(plan->observation(), current.observation) || !(current.epoch == current.observation->epoch()) ||
-            current.observation->eventThread() != std::this_thread::get_id() || !sameOwner(current.observation->expected().snapshot, current.snapshot) ||
-            !matchesBackendLifetime(*current.snapshot->device(), current.backendLifetime))
+        // Hypr owner refcounts are event-thread-only. Reject a wrong-thread
+        // preflight before locking any weak owner or traversing DRM resources.
+        if (!current.session || !current.observation || current.session->eventThread() != std::this_thread::get_id() ||
+            current.observation->eventThread() != std::this_thread::get_id())
+            return false;
+        if (!plan || plan->status() != ePlanStatus::READY || !callback || !current.backendLifetime || !current.device || !current.scan || !current.scanObservation ||
+            !current.snapshot || !sameOwner(plan->snapshot(), current.snapshot) || !sameOwner(plan->observation(), current.observation) ||
+            !sameOwner(current.observation->scan(), current.scan) || !sameOwner(current.snapshot->scan(), current.scan) ||
+            !sameOwner(current.scan->observation(), current.scanObservation) || !sameOwner(current.snapshot->observation(), current.scanObservation) ||
+            !sameOwner(current.scanObservation->session(), current.session) || !sameOwner(current.snapshot->session(), current.session) ||
+            !sameOwner(current.session->device(), current.device) || !sameOwner(current.snapshot->device(), current.device) || !(current.epoch == current.observation->epoch()) ||
+            current.epoch.session != current.session->sessionEpoch() || current.epoch.allocation != current.snapshot->allocationEpoch() ||
+            current.epoch.eventThread != current.session->eventThreadEpoch() || !sameOwner(current.observation->expected().snapshot, current.snapshot) ||
+            !sameOwner(current.observation->expected().scan, current.scan) || !sameOwner(current.observation->expected().observation, current.scanObservation) ||
+            !sameOwner(current.observation->expected().session, current.session) || !sameOwner(current.observation->expected().device, current.device) ||
+            current.observation->expected().allocationEpoch != current.snapshot->allocationEpoch() || current.device->backend() != current.backendLifetime ||
+            current.session->backend() != current.backendLifetime || current.observation->backendLifetime() != current.backendLifetime)
+            return false;
+
+        // In production, keep the exact CDRMBackend alive for the entire
+        // synchronous callback. Plans themselves retain no live backend owner.
+        CSharedPointer<CDRMBackend> liveProductionBackend;
+        if (current.backendLifetime->binding() == NTiledIncarnations::eBackendBinding::PRODUCTION_BACKEND) {
+            liveProductionBackend = current.backendLifetime->drmBackend().lock();
+            if (!liveProductionBackend)
+                return false;
+        }
+        if (!matchesBackendLifetime(current.device, current.backendLifetime) || !snapshotResourcesCurrent(current.snapshot))
             return false;
         callback(*plan);
         return true;
diff --git a/src/backend/drm/TiledCrtcAllocator.hpp b/src/backend/drm/TiledCrtcAllocator.hpp
index 6f81d8681e951c70da7125d58de16087395bafd0..2e85e69f314b26a6e761af1e0caf35860b63969b 100644
--- a/src/backend/drm/TiledCrtcAllocator.hpp
+++ b/src/backend/drm/TiledCrtcAllocator.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "Tile.hpp"
+#include "TiledBackendState.hpp"
 
 #include <aquamarine/backend/DRM.hpp>
 
@@ -20,9 +20,19 @@
 namespace Aquamarine::NDRM::NTiledCrtcAllocator { // NOLINT(readability-identifier-naming): established Aquamarine DRM namespace
     using Hyprutils::Memory::CSharedPointer;
     using Hyprutils::Memory::CWeakPointer;
+    using NTiledIncarnations::CBackendLifetime;
+    using NTiledIncarnations::CDeviceIncarnation;
+    using NTiledIncarnations::CSessionIncarnation;
+    using NTiledIncarnations::PBackendLifetime;
+    using NTiledIncarnations::PDeviceIncarnation;
+    using NTiledIncarnations::PSessionIncarnation;
+    using NTiledIncarnations::WBackendLifetime;
+    using NTiledScan::PCommittedScan;
+    using NTiledScan::PScanGroupDefinition;
+    using NTiledScan::PScanObservation;
 
-    // These counters identify one immutable resource observation. Reusing any
-    // counter across its corresponding lifetime boundary is a caller bug.
+    // Derived diagnostics for logs/tests. Exact scan, session, device, and
+    // observation owner identities are the freshness authority.
     struct AQ_TILED_ALLOCATOR_PRIVATE SGeneration {
         uint64_t device      = 0;
         uint64_t session     = 0;
@@ -31,55 +41,52 @@ namespace Aquamarine::NDRM::NTiledCrtcAllocator { // NOLINT(readability-identifi
         bool     operator==(const SGeneration&) const = default;
     };
 
-    struct AQ_TILED_ALLOCATOR_PRIVATE SBackendIncarnation {
-        uint64_t serial = 0;
-    };
-
-    enum class eBackendBinding : uint8_t {
-        // Pure tests use a live generic token and must leave actual SDRM backend
-        // owners empty. There is deliberately no unbound mode.
-        LIFETIME_TOKEN,
-        // Production additionally requires a live actual CDRMBackend owner and
-        // exact equality with every captured SDRM resource backend.
-        PRODUCTION_BACKEND,
-    };
-
-    // Exact owner for one backend/device/fd lifetime. A production capture must
-    // provide the actual backend weak owner, a stable device ID, and fresh
-    // nonzero device/fd epochs. The generic token makes lifetime expiry and
-    // owner mismatch testable without constructing a DRM backend.
-    struct AQ_TILED_ALLOCATOR_PRIVATE SDeviceIncarnation {
-        uint64_t                                deviceId    = 0;
-        uint64_t                                deviceEpoch = 0;
-        uint64_t                                fdEpoch     = 0;
-        uint64_t                                serial      = 0;
-        eBackendBinding                         binding     = eBackendBinding::LIFETIME_TOKEN;
-        CWeakPointer<const SBackendIncarnation> backendLifetime;
-        CWeakPointer<CDRMBackend>               backend;
-    };
-
-    struct AQ_TILED_ALLOCATOR_PRIVATE SObservationIncarnation {
-        SGeneration                              generation;
-        uint64_t                                 serial = 0;
-        CSharedPointer<const SDeviceIncarnation> device;
-        CWeakPointer<const SBackendIncarnation>  backendLifetime;
-    };
-
     enum class eResourceKind : uint8_t {
         CONNECTOR,
         CRTC,
         PRIMARY_PLANE,
     };
 
-    // Identity is the owner identity of this object, not merely these fields.
-    // The fields make accidental cross-observation construction rejectable.
-    struct AQ_TILED_ALLOCATOR_PRIVATE SResourceIncarnation {
-        eResourceKind                                 kind       = eResourceKind::CONNECTOR;
-        uint32_t                                      resourceID = 0;
-        uint64_t                                      serial     = 0;
-        SGeneration                                   generation;
-        CSharedPointer<const SDeviceIncarnation>      device;
-        CSharedPointer<const SObservationIncarnation> observation;
+    // Minted only by CSnapshot. Identity is the owner identity of this object;
+    // numeric fields are diagnostics and never freshness authority.
+    class AQ_TILED_ALLOCATOR_PRIVATE SResourceIncarnation final {
+      public:
+        SResourceIncarnation(const SResourceIncarnation&)                            = delete;
+        SResourceIncarnation(SResourceIncarnation&&)                                 = delete;
+        SResourceIncarnation&                 operator=(const SResourceIncarnation&) = delete;
+        SResourceIncarnation&                 operator=(SResourceIncarnation&&)      = delete;
+
+        [[nodiscard]] eResourceKind           kind() const;
+        [[nodiscard]] uint32_t                resourceID() const;
+        [[nodiscard]] uint64_t                serial() const;
+        [[nodiscard]] const PScanObservation& observation() const;
+        [[nodiscard]] uint64_t                allocationEpoch() const;
+
+      private:
+        SResourceIncarnation(eResourceKind kind, uint32_t resourceID, uint64_t serial, PScanObservation observation, uint64_t allocationEpoch);
+
+        eResourceKind    m_kind       = eResourceKind::CONNECTOR;
+        uint32_t         m_resourceID = 0;
+        uint64_t         m_serial     = 0;
+        PScanObservation m_observation;
+        uint64_t         m_allocationEpoch = 0;
+
+        friend class CSnapshot;
+    };
+
+    struct AQ_TILED_ALLOCATOR_PRIVATE SConnectorCapture {
+        CSharedPointer<SDRMConnector> connector;
+        std::vector<uint32_t>         possibleCRTCIDs;
+    };
+
+    struct AQ_TILED_ALLOCATOR_PRIVATE SCRTCCapture {
+        CSharedPointer<SDRMCRTC> crtc;
+    };
+
+    struct AQ_TILED_ALLOCATOR_PRIVATE SPrimaryPlaneCapture {
+        CSharedPointer<SDRMPlane> plane;
+        std::vector<uint32_t>     possibleCRTCIDs;
+        bool                      usable = false;
     };
 
     struct AQ_TILED_ALLOCATOR_PRIVATE SConnectorResource {
@@ -107,56 +114,68 @@ namespace Aquamarine::NDRM::NTiledCrtcAllocator { // NOLINT(readability-identifi
 
     class AQ_TILED_ALLOCATOR_PRIVATE CSnapshot {
       public:
-        [[nodiscard]] static CSharedPointer<const CSnapshot>               create(SGeneration generation, CSharedPointer<const SObservationIncarnation> observation,
-                                                                                  std::vector<SConnectorResource> connectors, std::vector<SCRTCResource> crtcs,
-                                                                                  std::vector<SPrimaryPlaneResource> primaryPlanes);
+        CSnapshot(const CSnapshot&)                                                         = delete;
+        CSnapshot(CSnapshot&&)                                                              = delete;
+        CSnapshot&                                              operator=(const CSnapshot&) = delete;
+        CSnapshot&                                              operator=(CSnapshot&&)      = delete;
 
-        [[nodiscard]] const SGeneration&                                   generation() const;
-        [[nodiscard]] const CSharedPointer<const SDeviceIncarnation>&      device() const;
-        [[nodiscard]] const CSharedPointer<const SObservationIncarnation>& observation() const;
-        [[nodiscard]] const std::vector<SConnectorResource>&               connectors() const;
-        [[nodiscard]] const std::vector<SCRTCResource>&                    crtcs() const;
-        [[nodiscard]] const std::vector<SPrimaryPlaneResource>&            primaryPlanes() const;
+        [[nodiscard]] static CSharedPointer<const CSnapshot>    create(PCommittedScan scan, uint64_t allocationEpoch, std::vector<SConnectorCapture> connectors,
+                                                                       std::vector<SCRTCCapture> crtcs, std::vector<SPrimaryPlaneCapture> primaryPlanes);
+
+        [[nodiscard]] const SGeneration&                        generation() const;
+        [[nodiscard]] const PCommittedScan&                     scan() const;
+        [[nodiscard]] const PDeviceIncarnation&                 device() const;
+        [[nodiscard]] const PSessionIncarnation&                session() const;
+        [[nodiscard]] const PScanObservation&                   observation() const;
+        [[nodiscard]] uint64_t                                  allocationEpoch() const;
+        [[nodiscard]] const std::vector<SConnectorResource>&    connectors() const;
+        [[nodiscard]] const std::vector<SCRTCResource>&         crtcs() const;
+        [[nodiscard]] const std::vector<SPrimaryPlaneResource>& primaryPlanes() const;
 
       private:
-        CSnapshot(SGeneration generation, CSharedPointer<const SDeviceIncarnation> device, CSharedPointer<const SObservationIncarnation> observation,
+        CSnapshot(SGeneration generation, PCommittedScan scan, PDeviceIncarnation device, PSessionIncarnation session, PScanObservation observation, uint64_t allocationEpoch,
                   std::vector<SConnectorResource> connectors, std::vector<SCRTCResource> crtcs, std::vector<SPrimaryPlaneResource> primaryPlanes);
 
-        SGeneration                                   m_generation;
-        CSharedPointer<const SDeviceIncarnation>      m_device;
-        CSharedPointer<const SObservationIncarnation> m_observation;
-        std::vector<SConnectorResource>               m_connectors;
-        std::vector<SCRTCResource>                    m_crtcs;
-        std::vector<SPrimaryPlaneResource>            m_primaryPlanes;
+        SGeneration                        m_generation;
+        PCommittedScan                     m_scan;
+        PDeviceIncarnation                 m_device;
+        PSessionIncarnation                m_session;
+        PScanObservation                   m_observation;
+        uint64_t                           m_allocationEpoch = 0;
+        std::vector<SConnectorResource>    m_connectors;
+        std::vector<SCRTCResource>         m_crtcs;
+        std::vector<SPrimaryPlaneResource> m_primaryPlanes;
     };
 
     class AQ_TILED_ALLOCATOR_PRIVATE CGroupDefinition {
       public:
-        CGroupDefinition(const CGroupDefinition&)                                                        = delete;
-        CGroupDefinition(CGroupDefinition&&)                                                             = delete;
-        CGroupDefinition&                                             operator=(const CGroupDefinition&) = delete;
-        CGroupDefinition&                                             operator=(CGroupDefinition&&)      = delete;
+        CGroupDefinition(const CGroupDefinition&)                                                      = delete;
+        CGroupDefinition(CGroupDefinition&&)                                                           = delete;
+        CGroupDefinition&                                           operator=(const CGroupDefinition&) = delete;
+        CGroupDefinition&                                           operator=(CGroupDefinition&&)      = delete;
 
-        [[nodiscard]] static CSharedPointer<const CGroupDefinition>   create(NTiling::STileGroup group, CSharedPointer<const SDeviceIncarnation> device, uint64_t definitionSerial);
+        [[nodiscard]] static CSharedPointer<const CGroupDefinition> create(PScanGroupDefinition definition);
 
-        [[nodiscard]] const NTiling::STileGroup&                      group() const;
-        [[nodiscard]] const CSharedPointer<const SDeviceIncarnation>& device() const;
-        [[nodiscard]] uint64_t                                        serial() const;
+        [[nodiscard]] const PScanGroupDefinition&                   scanDefinition() const;
+        [[nodiscard]] const NTiling::STileGroup&                    group() const;
+        [[nodiscard]] const PDeviceIncarnation&                     device() const;
+        [[nodiscard]] const PSessionIncarnation&                    session() const;
 
       private:
-        CGroupDefinition(NTiling::STileGroup group, CSharedPointer<const SDeviceIncarnation> device, uint64_t definitionSerial);
+        explicit CGroupDefinition(PScanGroupDefinition definition);
 
-        NTiling::STileGroup                      m_group;
-        CSharedPointer<const SDeviceIncarnation> m_device;
-        uint64_t                                 m_serial = 0;
+        PScanGroupDefinition m_definition;
     };
 
     struct AQ_TILED_ALLOCATOR_PRIVATE SSnapshotExpectation {
         // Pointer/control-block identity is the primary freshness boundary.
-        CSharedPointer<const CSnapshot>               snapshot;
-        SGeneration                                   generation;
-        CSharedPointer<const SDeviceIncarnation>      device;
-        CSharedPointer<const SObservationIncarnation> observation;
+        CSharedPointer<const CSnapshot> snapshot;
+        PCommittedScan                  scan;
+        PDeviceIncarnation              device;
+        PSessionIncarnation             session;
+        PScanObservation                observation;
+        uint64_t                        allocationEpoch = 0;
+        SGeneration                     generation;
     };
 
     struct AQ_TILED_ALLOCATOR_PRIVATE SConnectorHandle {
@@ -246,15 +265,15 @@ namespace Aquamarine::NDRM::NTiledCrtcAllocator { // NOLINT(readability-identifi
         CAllocationObservation&                                           operator=(const CAllocationObservation&) = delete;
         CAllocationObservation&                                           operator=(CAllocationObservation&&)      = delete;
 
-        [[nodiscard]] static CSharedPointer<const CAllocationObservation> create(CSharedPointer<const CSnapshot>                     snapshot,
-                                                                                 CSharedPointer<const SBackendIncarnation>           currentBackendLifetime,
+        [[nodiscard]] static CSharedPointer<const CAllocationObservation> create(PCommittedScan currentScan, CSharedPointer<const CSnapshot> snapshot,
                                                                                  std::vector<CSharedPointer<const CGroupDefinition>> currentGroupDefinitions,
                                                                                  std::vector<SHardHold> hardHolds, std::vector<SGroupRequest> groups,
                                                                                  std::vector<SOrdinaryRequest> ordinary, std::vector<SConnectorCRTCPreference> connectorPreferences,
                                                                                  std::vector<SCRTCPlanePreference> planePreferences, SAllocationEpoch epoch);
 
         [[nodiscard]] const SSnapshotExpectation&                         expected() const;
-        [[nodiscard]] const CWeakPointer<const SBackendIncarnation>&      backendLifetime() const;
+        [[nodiscard]] const PCommittedScan&                               scan() const;
+        [[nodiscard]] const WBackendLifetime&                             backendLifetime() const;
         [[nodiscard]] const std::vector<CSharedPointer<const CGroupDefinition>>& currentGroupDefinitions() const;
         [[nodiscard]] const std::vector<SHardHold>&                              hardHolds() const;
         [[nodiscard]] const std::vector<SGroupRequest>&                          groups() const;
@@ -265,13 +284,14 @@ namespace Aquamarine::NDRM::NTiledCrtcAllocator { // NOLINT(readability-identifi
         [[nodiscard]] std::thread::id                                            eventThread() const;
 
       private:
-        CAllocationObservation(SSnapshotExpectation expected, CWeakPointer<const SBackendIncarnation> backendLifetime,
+        CAllocationObservation(SSnapshotExpectation expected, PCommittedScan scan, WBackendLifetime backendLifetime,
                                std::vector<CSharedPointer<const CGroupDefinition>> currentGroupDefinitions, std::vector<SHardHold> hardHolds, std::vector<SGroupRequest> groups,
                                std::vector<SOrdinaryRequest> ordinary, std::vector<SConnectorCRTCPreference> connectorPreferences,
                                std::vector<SCRTCPlanePreference> planePreferences, SAllocationEpoch epoch, std::thread::id eventThread);
 
         SSnapshotExpectation                                m_expected;
-        CWeakPointer<const SBackendIncarnation>             m_backendLifetime;
+        PCommittedScan                                      m_scan;
+        WBackendLifetime                                    m_backendLifetime;
         std::vector<CSharedPointer<const CGroupDefinition>> m_currentGroupDefinitions;
         std::vector<SHardHold>                              m_hardHolds;
         std::vector<SGroupRequest>                          m_groups;
@@ -380,8 +400,12 @@ namespace Aquamarine::NDRM::NTiledCrtcAllocator { // NOLINT(readability-identifi
     };
 
     struct AQ_TILED_ALLOCATOR_PRIVATE SCurrentState {
+        PBackendLifetime                             backendLifetime;
+        PDeviceIncarnation                           device;
+        PSessionIncarnation                          session;
+        PCommittedScan                               scan;
+        PScanObservation                             scanObservation;
         CSharedPointer<const CSnapshot>              snapshot;
-        CSharedPointer<const SBackendIncarnation>    backendLifetime;
         CSharedPointer<const CAllocationObservation> observation;
         SAllocationEpoch                             epoch;
     };
diff --git a/tests/TiledBackendState.cpp b/tests/TiledBackendState.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..363f7572e0904e2281653745dcb5d67c4bf56b10
--- /dev/null
+++ b/tests/TiledBackendState.cpp
@@ -0,0 +1,643 @@
+#include "backend/drm/TiledBackendState.hpp"
+#include "shared.hpp"
+
+#include <algorithm>
+#include <atomic>
+#include <cstdint>
+#include <cstdlib>
+#include <exception>
+#include <limits>
+#include <ranges>
+#include <string_view>
+#include <sys/wait.h>
+#include <thread>
+#include <unistd.h>
+#include <utility>
+#include <vector>
+
+#include <hyprutils/memory/SharedPtr.hpp>
+#include <hyprutils/utils/ScopeGuard.hpp>
+
+using namespace Aquamarine::NDRM::NTiledScan;
+using namespace Hyprutils::Memory;
+using Hyprutils::Utils::CScopeGuard;
+namespace NTiling = Aquamarine::NTiling;
+
+namespace {
+    constexpr uint32_t MODE_FLAGS = DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC;
+
+    struct SPreparedFixture {
+        PScanAttemptTicket ticket;
+        PScanAttempt       attempt;
+        PPreparedScan      prepared;
+    };
+
+    drmModeModeInfo mode(uint16_t width, uint16_t height, uint32_t clock, std::string_view name, uint32_t type = DRM_MODE_TYPE_DRIVER, uint32_t reportedRefresh = 60) {
+        drmModeModeInfo result = {
+            .clock       = clock,
+            .hdisplay    = width,
+            .hsync_start = static_cast<uint16_t>(width + 8),
+            .hsync_end   = static_cast<uint16_t>(width + 40),
+            .htotal      = static_cast<uint16_t>(width + 80),
+            .hskew       = 0,
+            .vdisplay    = height,
+            .vsync_start = static_cast<uint16_t>(height + 1),
+            .vsync_end   = static_cast<uint16_t>(height + 9),
+            .vtotal      = static_cast<uint16_t>(height + 82),
+            .vscan       = 0,
+            .vrefresh    = reportedRefresh,
+            .flags       = MODE_FLAGS,
+            .type        = type,
+        };
+        const size_t COPY_SIZE = std::min(name.size(), sizeof(result.name));
+        std::ranges::copy_n(name.begin(), COPY_SIZE, result.name);
+        return result;
+    }
+
+    SConnectorView connector(uint32_t connectorId, std::string_view tileProperty, std::vector<drmModeModeInfo> modes) {
+        return {
+            .connectorId  = connectorId,
+            .tileProperty = std::string{tileProperty},
+            .modes        = std::move(modes),
+        };
+    }
+
+    SPreparedFixture prepareComplete(CTiledBackendState& state, uint64_t resourceEpoch, std::vector<SConnectorView> connectors) {
+        auto begun = state.beginAttempt(resourceEpoch);
+        if (!begun)
+            std::terminate();
+
+        bool        resolved = false;
+        CScopeGuard guard([&] {
+            if (!resolved)
+                (void)state.fail(begun.ticket, eAttemptFailure::PREPARATION_FAILED);
+        });
+        auto        prepared = state.prepare(begun.ticket, eScanCompleteness::COMPLETE, std::move(connectors));
+        if (!prepared)
+            std::terminate();
+        resolved = true;
+        return {.ticket = std::move(begun.ticket), .attempt = std::move(prepared.attempt), .prepared = std::move(prepared.prepared)};
+    }
+
+    int value(eBeginAttemptResult result) {
+        return static_cast<int>(result);
+    }
+
+    int value(ePrepareScanResult result) {
+        return static_cast<int>(result);
+    }
+
+    int value(eScanInstallResult result) {
+        return static_cast<int>(result);
+    }
+
+    int value(eResolveAttemptResult result) {
+        return static_cast<int>(result);
+    }
+
+    int value(eScanOutcome result) {
+        return static_cast<int>(result);
+    }
+
+    int value(eRegistryResult result) {
+        return static_cast<int>(result);
+    }
+
+    int value(eTeardownResult result) {
+        return static_cast<int>(result);
+    }
+
+    int value(eSessionRotationResult result) {
+        return static_cast<int>(result);
+    }
+
+    bool exactMode(const drmModeModeInfo& lhs, const drmModeModeInfo& rhs) {
+        const NTiling::STilePhysicalMode LEFT  = {.connectorId = 1, .modeInfo = lhs};
+        const NTiling::STilePhysicalMode RIGHT = {.connectorId = 1, .modeInfo = rhs};
+        return LEFT == RIGHT;
+    }
+
+    bool emptyMode(const drmModeModeInfo& modeInfo) {
+        return exactMode(modeInfo, drmModeModeInfo{});
+    }
+
+    bool ordinary(const CCommittedScan& scan, uint32_t connectorId) {
+        const auto* const CONNECTOR = scan.findConnector(connectorId);
+        return CONNECTOR && CONNECTOR->projection.role == eConnectorRole::ORDINARY && CONNECTOR->projection.disposition == eConnectorDisposition::PUBLISH_ORDINARY &&
+            !CONNECTOR->projection.definition && !CONNECTOR->projection.modes;
+    }
+
+    bool unsafeRegistryDestructionTerminates() {
+        const pid_t CHILD = fork();
+        if (CHILD == 0) {
+            std::set_terminate([] { _exit(83); });
+            {
+                const auto                 BACKEND = CBackendLifetime::createTestToken(1);
+                const auto                 DEVICE  = CDeviceIncarnation::create(BACKEND, 1, 1, 1, 1);
+                const auto                 SESSION = CSessionIncarnation::create(BACKEND, DEVICE, std::this_thread::get_id(), 1, 1, 1);
+                CTiledBackendStateRegistry registry;
+                const auto                 CREATED = registry.create(BACKEND, DEVICE, SESSION);
+                if (!CREATED)
+                    _exit(84);
+            }
+            _exit(0);
+        }
+        if (CHILD < 0)
+            return false;
+
+        int status = 0;
+        if (waitpid(CHILD, &status, 0) != CHILD)
+            return false;
+        return WIFEXITED(status) && WEXITSTATUS(status) == 83;
+    }
+}
+
+int main() {
+    int        ret = 0;
+
+    const auto BACKEND       = CBackendLifetime::createTestToken(17);
+    const auto BACKEND_ALIAS = BACKEND; // NOLINT(performance-unnecessary-copy-initialization): exercise exact copied control-block identity
+    const auto BACKEND_TWIN  = CBackendLifetime::createTestToken(17);
+    const auto DEVICE        = CDeviceIncarnation::create(BACKEND, 9, 31, 32, 41);
+    const auto SESSION       = CSessionIncarnation::create(BACKEND, DEVICE, std::this_thread::get_id(), 51, 52, 41);
+
+    const auto WRONG_BACKEND_DEVICE  = CDeviceIncarnation::create(BACKEND_TWIN, 9, 31, 32, 41);
+    const auto WRONG_BACKEND_SESSION = CSessionIncarnation::create(BACKEND_TWIN, WRONG_BACKEND_DEVICE, std::this_thread::get_id(), 51, 52, 41);
+    const auto ZERO_FD_DEVICE        = CDeviceIncarnation::create(BACKEND, 9, 31, 0, 41);
+    const auto ZERO_FD_SESSION       = CSessionIncarnation::create(BACKEND, ZERO_FD_DEVICE, std::this_thread::get_id(), 51, 52, 41);
+    const auto ZERO_DEVICE_ID        = CDeviceIncarnation::create(BACKEND, 0, 31, 32, 41);
+    const auto ZERO_DEVICE_EPOCH     = CDeviceIncarnation::create(BACKEND, 9, 0, 32, 41);
+    const auto ZERO_DEVICE_SERIAL    = CDeviceIncarnation::create(BACKEND, 9, 31, 32, 0);
+    const auto WRONG_THREAD_SESSION  = CSessionIncarnation::create(BACKEND, DEVICE, std::thread::id{}, 51, 52, 41);
+    const auto ZERO_SESSION_EPOCH    = CSessionIncarnation::create(BACKEND, DEVICE, std::this_thread::get_id(), 0, 52, 41);
+    const auto ZERO_THREAD_EPOCH     = CSessionIncarnation::create(BACKEND, DEVICE, std::this_thread::get_id(), 51, 0, 41);
+    const auto ZERO_SESSION_SERIAL   = CSessionIncarnation::create(BACKEND, DEVICE, std::this_thread::get_id(), 51, 52, 0);
+    const auto ZERO_BACKEND          = CBackendLifetime::createTestToken(0);
+    const auto ZERO_BACKEND_DEVICE   = CDeviceIncarnation::create(ZERO_BACKEND, 9, 31, 32, 41);
+    const auto ZERO_BACKEND_SESSION  = CSessionIncarnation::create(ZERO_BACKEND, ZERO_BACKEND_DEVICE, std::this_thread::get_id(), 51, 52, 41);
+    auto       EXPIRED_BACKEND       = CBackendLifetime::createTestToken(18);
+    const auto EXPIRED_DEVICE        = CDeviceIncarnation::create(EXPIRED_BACKEND, 10, 33, 34, 42);
+    const auto EXPIRED_SESSION       = CSessionIncarnation::create(EXPIRED_BACKEND, EXPIRED_DEVICE, std::this_thread::get_id(), 53, 54, 42);
+    EXPIRED_BACKEND                  = PBackendLifetime{};
+
+    CTiledBackendStateRegistry registry;
+    EXPECT(!!registry.create(BACKEND, WRONG_BACKEND_DEVICE, WRONG_BACKEND_SESSION), false);
+    EXPECT(!!registry.create(BACKEND, ZERO_FD_DEVICE, ZERO_FD_SESSION), false);
+    EXPECT(ZERO_DEVICE_ID->valid(), false);
+    EXPECT(ZERO_DEVICE_EPOCH->valid(), false);
+    EXPECT(ZERO_DEVICE_SERIAL->valid(), false);
+    EXPECT(!!registry.create(BACKEND, DEVICE, WRONG_THREAD_SESSION), false);
+    EXPECT(ZERO_SESSION_EPOCH->valid(), false);
+    EXPECT(ZERO_THREAD_EPOCH->valid(), false);
+    EXPECT(ZERO_SESSION_SERIAL->valid(), false);
+    EXPECT(!!registry.create(ZERO_BACKEND, ZERO_BACKEND_DEVICE, ZERO_BACKEND_SESSION), false);
+    EXPECT(EXPIRED_DEVICE->valid(), false);
+    EXPECT(EXPIRED_SESSION->valid(), false);
+    const auto CREATED = registry.create(BACKEND, DEVICE, SESSION);
+    EXPECT(!!CREATED, true);
+    auto* const STATE = CREATED.state;
+    EXPECT(STATE != nullptr, true);
+    EXPECT(registry.find(BACKEND_ALIAS) == STATE, true);
+    EXPECT(registry.find(BACKEND_TWIN) == nullptr, true);
+    EXPECT(value(registry.erase(BACKEND)), value(eRegistryResult::NOT_READY));
+    EXPECT(BACKEND->serial(), 17U);
+    EXPECT(DEVICE->deviceId(), 9U);
+    EXPECT(DEVICE->deviceEpoch(), 31U);
+    EXPECT(DEVICE->fdEpoch(), 32U);
+    EXPECT(DEVICE->serial(), 41U);
+    EXPECT(SESSION->device() == DEVICE, true);
+    EXPECT(SESSION->sessionEpoch(), 51U);
+    EXPECT(SESSION->eventThreadEpoch(), 52U);
+    EXPECT(SESSION->serial(), 41U);
+
+    const auto INVALID_BEGIN = STATE->beginAttempt(0);
+    EXPECT(value(INVALID_BEGIN.result), value(eBeginAttemptResult::INVALID_RESOURCE_EPOCH));
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::INVALID_OBSERVATION));
+    EXPECT(STATE->currentComplete() == nullptr, true);
+
+    PScanAttemptTicket acquisitionTicket;
+    {
+        const auto ACQUISITION = STATE->beginAttempt(100);
+        EXPECT(!!ACQUISITION, true);
+        EXPECT(ACQUISITION.ticket->serial(), 42U);
+        EXPECT(ACQUISITION.ticket->resourceEpoch(), 100U);
+        acquisitionTicket  = ACQUISITION.ticket;
+        const auto OUTCOME = STATE->outcome();
+        EXPECT(value(OUTCOME.result), value(eScanOutcome::PREPARING));
+        EXPECT(OUTCOME.serial, 42U);
+        EXPECT(OUTCOME.ticket == ACQUISITION.ticket, true);
+        EXPECT(OUTCOME.observation->device() == DEVICE, true);
+        EXPECT(OUTCOME.observation->session() == SESSION, true);
+        EXPECT(STATE->currentComplete() == nullptr, true);
+        EXPECT(value(STATE->beginAttempt(101).result), value(eBeginAttemptResult::BUSY));
+        EXPECT(STATE->outcome().ticket == ACQUISITION.ticket, true);
+
+        bool        resolved = false;
+        CScopeGuard guard([&] {
+            if (!resolved)
+                (void)STATE->fail(ACQUISITION.ticket, eAttemptFailure::ACQUISITION_FAILED);
+        });
+        bool        acquisitionExceptionCaught = false;
+        try {
+            throw 7;
+        } catch (...) { acquisitionExceptionCaught = true; }
+        EXPECT(acquisitionExceptionCaught, true);
+    }
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::ACQUISITION_FAILED));
+    EXPECT(STATE->outcome().ticket == acquisitionTicket, true);
+    EXPECT(STATE->currentComplete() == nullptr, true);
+    EXPECT(value(STATE->beginAttempt(100).result), value(eBeginAttemptResult::STALE_RESOURCE_EPOCH));
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::STALE_RESOURCE_EPOCH));
+    EXPECT(value(STATE->beginAttempt(99).result), value(eBeginAttemptResult::STALE_RESOURCE_EPOCH));
+    EXPECT(STATE->outcome().serial, 42U);
+    const auto STALE_ACQUISITION = STATE->prepare(acquisitionTicket, eScanCompleteness::COMPLETE, {});
+    EXPECT(value(STALE_ACQUISITION.result), value(ePrepareScanResult::STALE_TICKET));
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::STALE_OBSERVATION));
+
+    const auto LG_60_LEFT    = mode(2560, 2880, 469180, "left-60", DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED, 60);
+    const auto LG_60_RIGHT   = mode(2560, 2880, 469180, "right-60", DRM_MODE_TYPE_USERDEF | DRM_MODE_TYPE_PREFERRED, 61);
+    const auto LG_5994_LEFT  = mode(2560, 2880, 468711, "left-5994", DRM_MODE_TYPE_DRIVER, 59);
+    const auto LG_5994_RIGHT = mode(2560, 2880, 468711, "right-5994", DRM_MODE_TYPE_USERDEF, 60);
+
+    const auto FIRST = prepareComplete(*STATE, 200,
+                                       {
+                                           connector(202, "1:1:2:1:1:0:2560:2880", {LG_5994_RIGHT, LG_60_RIGHT}),
+                                           connector(101, "1:1:2:1:0:0:2560:2880", {LG_60_LEFT, LG_5994_LEFT}),
+                                       });
+    EXPECT(FIRST.ticket->serial(), 43U);
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::AWAITING_VALIDATION));
+    EXPECT(STATE->outcome().attempt == FIRST.attempt, true);
+    EXPECT(STATE->currentComplete() == nullptr, true);
+    EXPECT(value(STATE->beginAttempt(201).result), value(eBeginAttemptResult::BUSY));
+    EXPECT(value(registry.beginTeardown(BACKEND)), value(eRegistryResult::BUSY));
+
+    const auto SAME_OBSERVATION_DIFFERENT_CONTENT = STATE->prepare(FIRST.ticket, eScanCompleteness::COMPLETE, {connector(999, "", {})});
+    EXPECT(value(SAME_OBSERVATION_DIFFERENT_CONTENT.result), value(ePrepareScanResult::BUSY));
+    EXPECT(STATE->outcome().attempt == FIRST.attempt, true);
+
+    const auto FIRST_CANDIDATE = FIRST.prepared->candidate();
+    EXPECT(FIRST_CANDIDATE->connectors().size(), 2U);
+    EXPECT(FIRST_CANDIDATE->connectors().front().view.connectorId, 101U);
+    EXPECT(FIRST_CANDIDATE->connectors().back().view.connectorId, 202U);
+    EXPECT(FIRST_CANDIDATE->definitions().size(), 1U);
+    EXPECT(FIRST_CANDIDATE->modeDefinitions().size(), 1U);
+    EXPECT(FIRST_CANDIDATE->findConnector(101)->projection.role == eConnectorRole::MULTI_STREAM_PRIMARY, true);
+    EXPECT(FIRST_CANDIDATE->findConnector(202)->projection.role == eConnectorRole::MULTI_STREAM_MEMBER, true);
+    EXPECT(FIRST_CANDIDATE->findConnector(101)->projection.disposition == eConnectorDisposition::PUBLISH_ORDINARY, true);
+    EXPECT(FIRST_CANDIDATE->findConnector(202)->projection.disposition == eConnectorDisposition::PUBLISH_ORDINARY, true);
+
+    EXPECT(value(STATE->install(FIRST.prepared, eValidationDecision::ACCEPTED)), value(eScanInstallResult::COMMITTED));
+    const auto FIRST_COMMITTED = STATE->committed();
+    EXPECT(STATE->currentComplete() == FIRST_COMMITTED, true);
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::COMMITTED));
+    EXPECT(STATE->outcome().attempt == FIRST.attempt, true);
+    EXPECT(FIRST_COMMITTED->attempt() == FIRST.attempt, true);
+    EXPECT(FIRST_COMMITTED->observation() == FIRST.attempt->observation(), true);
+    EXPECT(FIRST_COMMITTED->observation()->serial(), 43U);
+    EXPECT(FIRST_COMMITTED->observation()->resourceEpoch(), 200U);
+    EXPECT(FIRST_COMMITTED->observation()->session() == SESSION, true);
+
+    const auto FIRST_DEFINITION = FIRST_COMMITTED->definitions().front();
+    const auto FIRST_MODES      = FIRST_COMMITTED->modeDefinitions().front();
+    EXPECT(FIRST_DEFINITION->device() == DEVICE, true);
+    EXPECT(FIRST_DEFINITION->session() == SESSION, true);
+    EXPECT(FIRST_DEFINITION->group().width, 5120U);
+    EXPECT(FIRST_DEFINITION->group().height, 2880U);
+    EXPECT(FIRST_MODES->definition() == FIRST_DEFINITION, true);
+    EXPECT(FIRST_MODES->logicalModes().size(), 2U);
+    EXPECT(emptyMode(FIRST_MODES->logicalModes().front().modeInfo), true);
+    EXPECT(exactMode(FIRST_MODES->physicalMappings().front().members.at(0).modeInfo, LG_60_LEFT), true);
+    EXPECT(exactMode(FIRST_MODES->physicalMappings().front().members.at(1).modeInfo, LG_60_RIGHT), true);
+
+    EXPECT(value(STATE->install(FIRST.prepared, eValidationDecision::ACCEPTED)), value(eScanInstallResult::STALE_PREPARED));
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::STALE_PREPARED));
+    EXPECT(STATE->committed() == FIRST_COMMITTED, true);
+    EXPECT(STATE->currentComplete() == nullptr, true);
+
+    const auto EQUIVALENT = prepareComplete(*STATE, 201,
+                                            {
+                                                connector(101, "1:1:2:1:0:0:2560:2880", {LG_5994_LEFT, LG_60_LEFT}),
+                                                connector(202, "1:1:2:1:1:0:2560:2880", {LG_60_RIGHT, LG_5994_RIGHT}),
+                                            });
+    EXPECT(EQUIVALENT.ticket->serial(), 44U);
+    EXPECT(EQUIVALENT.prepared->candidate()->definitions().front() == FIRST_DEFINITION, true);
+    EXPECT(EQUIVALENT.prepared->candidate()->modeDefinitions().front() == FIRST_MODES, true);
+    EXPECT(value(STATE->install(EQUIVALENT.prepared, eValidationDecision::ACCEPTED)), value(eScanInstallResult::COMMITTED));
+    const auto EQUIVALENT_COMMITTED = STATE->currentComplete();
+    EXPECT(EQUIVALENT_COMMITTED != FIRST_COMMITTED, true);
+    EXPECT(EQUIVALENT_COMMITTED->definitions().front() == FIRST_DEFINITION, true);
+    EXPECT(EQUIVALENT_COMMITTED->modeDefinitions().front() == FIRST_MODES, true);
+    EXPECT(EQUIVALENT_COMMITTED->connectors().front().view.modes.front().clock, LG_5994_LEFT.clock);
+
+    CTiledBackendStateRegistry cloneRegistry;
+    const auto                 CLONE_CREATED = cloneRegistry.create(BACKEND, DEVICE, SESSION);
+    EXPECT(!!CLONE_CREATED, true);
+    auto* const CLONE_STATE = CLONE_CREATED.state;
+    const auto  CLONE       = prepareComplete(*CLONE_STATE, 202,
+                                              {
+                                                  connector(101, "1:1:2:1:0:0:2560:2880", {LG_60_LEFT, LG_5994_LEFT}),
+                                                  connector(202, "1:1:2:1:1:0:2560:2880", {LG_60_RIGHT, LG_5994_RIGHT}),
+                                              });
+    EXPECT(value(CLONE_STATE->install(CLONE.prepared, eValidationDecision::ACCEPTED)), value(eScanInstallResult::COMMITTED));
+    const auto CLONE_DEFINITION = CLONE_STATE->committed()->definitions().front();
+    EXPECT(CLONE_DEFINITION->group() == FIRST_DEFINITION->group(), true);
+    EXPECT(CLONE_DEFINITION != FIRST_DEFINITION, true);
+
+    const auto FOREIGN                     = prepareComplete(*CLONE_STATE, 203,
+                                                             {
+                                                                 connector(101, "1:1:2:1:0:0:2560:2880", {LG_60_LEFT}),
+                                                                 connector(202, "1:1:2:1:1:0:2560:2880", {LG_60_RIGHT}),
+                                                             });
+    const auto MAIN_OUTCOME_BEFORE_FOREIGN = STATE->outcome();
+    EXPECT(value(STATE->install(FOREIGN.prepared, eValidationDecision::ACCEPTED)), value(eScanInstallResult::FOREIGN_PREPARED));
+    EXPECT(value(STATE->outcome().result), value(MAIN_OUTCOME_BEFORE_FOREIGN.result));
+    EXPECT(STATE->currentComplete() == EQUIVALENT_COMMITTED, true);
+    EXPECT(value(STATE->beginAttempt(201).result), value(eBeginAttemptResult::STALE_RESOURCE_EPOCH));
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::STALE_RESOURCE_EPOCH));
+    EXPECT(STATE->committed() == EQUIVALENT_COMMITTED, true);
+    EXPECT(STATE->currentComplete() == nullptr, true);
+
+    auto CHANGED_RIGHT         = LG_60_RIGHT;
+    CHANGED_RIGHT.type         = DRM_MODE_TYPE_DRIVER;
+    CHANGED_RIGHT.vrefresh     = 62;
+    CHANGED_RIGHT.name[0]      = 'R';
+    const auto MATERIAL_REJECT = prepareComplete(*STATE, 204,
+                                                 {
+                                                     connector(101, "1:1:2:1:0:0:2560:2880", {LG_60_LEFT, LG_5994_LEFT}),
+                                                     connector(202, "1:1:2:1:1:0:2560:2880", {CHANGED_RIGHT, LG_5994_RIGHT}),
+                                                 });
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::AWAITING_VALIDATION));
+    EXPECT(value(STATE->install(FOREIGN.prepared, eValidationDecision::ACCEPTED)), value(eScanInstallResult::FOREIGN_PREPARED));
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::AWAITING_VALIDATION));
+    EXPECT(STATE->outcome().attempt == MATERIAL_REJECT.attempt, true);
+    EXPECT(value(STATE->install(FIRST.prepared, eValidationDecision::ACCEPTED)), value(eScanInstallResult::BUSY));
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::AWAITING_VALIDATION));
+    EXPECT(STATE->outcome().attempt == MATERIAL_REJECT.attempt, true);
+    EXPECT(MATERIAL_REJECT.prepared->candidate()->definitions().front() == FIRST_DEFINITION, true);
+    EXPECT(MATERIAL_REJECT.prepared->candidate()->modeDefinitions().front() != FIRST_MODES, true);
+    EXPECT(value(STATE->install(MATERIAL_REJECT.prepared, eValidationDecision::REJECTED)), value(eScanInstallResult::VALIDATION_REJECTED));
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::VALIDATION_REJECTED));
+    EXPECT(STATE->outcome().attempt == MATERIAL_REJECT.attempt, true);
+    EXPECT(STATE->committed() == EQUIVALENT_COMMITTED, true);
+    EXPECT(STATE->currentComplete() == nullptr, true);
+    EXPECT(value(CLONE_STATE->install(FOREIGN.prepared, eValidationDecision::REJECTED)), value(eScanInstallResult::VALIDATION_REJECTED));
+
+    const auto INCOMPLETE_BEGIN = STATE->beginAttempt(205);
+    EXPECT(!!INCOMPLETE_BEGIN, true);
+    const auto INCOMPLETE = STATE->prepare(INCOMPLETE_BEGIN.ticket, eScanCompleteness::INCOMPLETE, {connector(101, "1:1:2:1:0:0:2560:2880", {LG_60_LEFT})});
+    EXPECT(value(INCOMPLETE.result), value(ePrepareScanResult::INCOMPLETE));
+    EXPECT(INCOMPLETE.attempt->ticket() == INCOMPLETE_BEGIN.ticket, true);
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::INCOMPLETE));
+    EXPECT(STATE->outcome().attempt == INCOMPLETE.attempt, true);
+    EXPECT(STATE->committed() == EQUIVALENT_COMMITTED, true);
+    EXPECT(STATE->currentComplete() == nullptr, true);
+    EXPECT(value(STATE->prepare(INCOMPLETE_BEGIN.ticket, eScanCompleteness::COMPLETE, {}).result), value(ePrepareScanResult::STALE_TICKET));
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::STALE_OBSERVATION));
+
+    const auto MATERIAL = prepareComplete(*STATE, 206,
+                                          {
+                                              connector(101, "1:1:2:1:0:0:2560:2880", {LG_60_LEFT, LG_5994_LEFT}),
+                                              connector(202, "1:1:2:1:1:0:2560:2880", {CHANGED_RIGHT, LG_5994_RIGHT}),
+                                          });
+    EXPECT(value(STATE->install(MATERIAL.prepared, eValidationDecision::ACCEPTED)), value(eScanInstallResult::COMMITTED));
+    const auto MATERIAL_COMMITTED = STATE->currentComplete();
+    EXPECT(MATERIAL_COMMITTED->definitions().front() == FIRST_DEFINITION, true);
+    EXPECT(MATERIAL_COMMITTED->modeDefinitions().front() != FIRST_MODES, true);
+    const auto MATERIAL_MODES = MATERIAL_COMMITTED->modeDefinitions().front();
+    EXPECT(exactMode(MATERIAL_MODES->physicalMappings().front().members.at(1).modeInfo, CHANGED_RIGHT), true);
+
+    const auto VALIDATION_THROW = prepareComplete(*STATE, 207,
+                                                  {
+                                                      connector(101, "1:1:2:1:0:0:2560:2880", {LG_60_LEFT}),
+                                                      connector(202, "1:1:2:1:1:0:2560:2880", {CHANGED_RIGHT}),
+                                                  });
+    {
+        bool        resolved = false;
+        CScopeGuard guard([&] {
+            if (!resolved)
+                (void)STATE->fail(VALIDATION_THROW.ticket, eAttemptFailure::VALIDATION_FAILED);
+        });
+        bool        validationExceptionCaught = false;
+        try {
+            throw 9;
+        } catch (...) { validationExceptionCaught = true; }
+        EXPECT(validationExceptionCaught, true);
+    }
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::VALIDATION_FAILED));
+    EXPECT(STATE->outcome().attempt == VALIDATION_THROW.attempt, true);
+    EXPECT(STATE->committed() == MATERIAL_COMMITTED, true);
+    EXPECT(STATE->currentComplete() == nullptr, true);
+
+    const auto DUPLICATE_BEGIN = STATE->beginAttempt(208);
+    EXPECT(!!DUPLICATE_BEGIN, true);
+    const auto DUPLICATE = STATE->prepare(DUPLICATE_BEGIN.ticket, eScanCompleteness::COMPLETE,
+                                          {
+                                              connector(77, "", {}),
+                                              connector(77, "", {}),
+                                          });
+    EXPECT(value(DUPLICATE.result), value(ePrepareScanResult::PREPARATION_FAILED));
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::PREPARATION_FAILED));
+    EXPECT(STATE->outcome().serial, DUPLICATE_BEGIN.ticket->serial());
+    EXPECT(STATE->currentComplete() == nullptr, true);
+
+    const auto WITH_ORDINARY = prepareComplete(*STATE, 209,
+                                               {
+                                                   connector(303, "", {mode(1920, 1080, 148500, "ordinary")}),
+                                                   connector(202, "1:1:2:1:1:0:2560:2880", {LG_5994_RIGHT, CHANGED_RIGHT}),
+                                                   connector(101, "1:1:2:1:0:0:2560:2880", {LG_5994_LEFT, LG_60_LEFT}),
+                                               });
+    EXPECT(WITH_ORDINARY.prepared->candidate()->definitions().front() == FIRST_DEFINITION, true);
+    EXPECT(WITH_ORDINARY.prepared->candidate()->modeDefinitions().front() == MATERIAL_MODES, true);
+    EXPECT(value(STATE->install(WITH_ORDINARY.prepared, eValidationDecision::ACCEPTED)), value(eScanInstallResult::COMMITTED));
+    const auto WITH_ORDINARY_COMMITTED = STATE->currentComplete();
+    EXPECT(ordinary(*WITH_ORDINARY_COMMITTED, 303), true);
+
+    const auto CHANGED_TOPOLOGY = prepareComplete(*STATE, 210,
+                                                  {
+                                                      connector(101, "2:1:2:1:0:0:2560:2880", {LG_60_LEFT}),
+                                                      connector(202, "2:1:2:1:1:0:2560:2880", {CHANGED_RIGHT}),
+                                                  });
+    EXPECT(CHANGED_TOPOLOGY.prepared->candidate()->definitions().front() != FIRST_DEFINITION, true);
+    EXPECT(value(STATE->install(CHANGED_TOPOLOGY.prepared, eValidationDecision::ACCEPTED)), value(eScanInstallResult::COMMITTED));
+
+    const auto COMBINED          = mode(5120, 2880, 938360, "driver-unified", DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED);
+    const auto UNIFIED           = prepareComplete(*STATE, 211,
+                                                   {
+                                                       connector(401, "3:1:2:1:0:0:2560:2880", {LG_60_LEFT}),
+                                                       connector(402, "3:1:2:1:1:0:2560:2880", {LG_60_RIGHT, COMBINED}),
+                                                   });
+    const auto UNIFIED_CANDIDATE = UNIFIED.prepared->candidate();
+    EXPECT(UNIFIED_CANDIDATE->definitions().size(), 1U);
+    EXPECT(UNIFIED_CANDIDATE->modeDefinitions().size(), 0U);
+    EXPECT(UNIFIED_CANDIDATE->findConnector(402)->projection.role == eConnectorRole::DRIVER_UNIFIED_PRIMARY, true);
+    EXPECT(UNIFIED_CANDIDATE->findConnector(402)->projection.disposition == eConnectorDisposition::PUBLISH_ORDINARY, true);
+    EXPECT(UNIFIED_CANDIDATE->findConnector(401)->projection.role == eConnectorRole::DRIVER_UNIFIED_REDUNDANT, true);
+    EXPECT(UNIFIED_CANDIDATE->findConnector(401)->projection.disposition == eConnectorDisposition::SUPPRESS_REDUNDANT, true);
+    EXPECT(value(STATE->install(UNIFIED.prepared, eValidationDecision::ACCEPTED)), value(eScanInstallResult::COMMITTED));
+
+    auto NON_DESKTOP              = connector(802, "13:1:2:1:1:0:2560:2880", {LG_60_RIGHT});
+    NON_DESKTOP.nonDesktop        = true;
+    auto NOT_MONITOR              = connector(902, "14:1:2:1:1:0:2560:2880", {LG_60_RIGHT});
+    NOT_MONITOR.isMonitor         = false;
+    const auto FALLBACKS          = prepareComplete(*STATE, 212,
+                                                    {
+                                                        connector(501, "malformed", {LG_60_LEFT}),
+                                                        connector(502, "10:1:2:1:1:0:2560:2880", {LG_60_RIGHT}),
+                                                        connector(601, "11:0:2:1:0:0:2560:2880", {LG_60_LEFT}),
+                                                        connector(602, "11:0:2:1:1:0:2560:2880", {LG_60_RIGHT}),
+                                                        connector(701, "12:1:2:1:0:0:2560:2880", {LG_60_LEFT}),
+                                                        connector(702, "12:1:2:1:1:0:2560:2880", {LG_5994_RIGHT}),
+                                                        connector(801, "13:1:2:1:0:0:2560:2880", {LG_60_LEFT}),
+                                                        std::move(NON_DESKTOP),
+                                                        connector(901, "14:1:2:1:0:0:2560:2880", {LG_60_LEFT}),
+                                                        std::move(NOT_MONITOR),
+                                                    });
+    const auto FALLBACK_CANDIDATE = FALLBACKS.prepared->candidate();
+    EXPECT(FALLBACK_CANDIDATE->definitions().size(), 0U);
+    EXPECT(FALLBACK_CANDIDATE->modeDefinitions().size(), 0U);
+    EXPECT(ordinary(*FALLBACK_CANDIDATE, 501), true);
+    EXPECT(ordinary(*FALLBACK_CANDIDATE, 502), true);
+    EXPECT(ordinary(*FALLBACK_CANDIDATE, 601), true);
+    EXPECT(ordinary(*FALLBACK_CANDIDATE, 602), true);
+    EXPECT(ordinary(*FALLBACK_CANDIDATE, 701), true);
+    EXPECT(ordinary(*FALLBACK_CANDIDATE, 702), true);
+    EXPECT(ordinary(*FALLBACK_CANDIDATE, 801), true);
+    EXPECT(ordinary(*FALLBACK_CANDIDATE, 802), true);
+    EXPECT(ordinary(*FALLBACK_CANDIDATE, 901), true);
+    EXPECT(ordinary(*FALLBACK_CANDIDATE, 902), true);
+    EXPECT(value(STATE->install(FALLBACKS.prepared, eValidationDecision::ACCEPTED)), value(eScanInstallResult::COMMITTED));
+    const auto FALLBACK_COMMITTED = STATE->currentComplete();
+
+    const auto PRE_ROTATION           = prepareComplete(*STATE, 213,
+                                                        {
+                                                            connector(101, "1:1:2:1:0:0:2560:2880", {LG_60_LEFT}),
+                                                            connector(202, "1:1:2:1:1:0:2560:2880", {LG_60_RIGHT}),
+                                                        });
+    const auto WRONG_ROTATION_DEVICE  = CDeviceIncarnation::create(BACKEND, 9, 31, 33, 41);
+    const auto WRONG_ROTATION_SESSION = CSessionIncarnation::create(BACKEND, WRONG_ROTATION_DEVICE, std::this_thread::get_id(), 61, 62, 200);
+    const auto CLONED_DEVICE          = CDeviceIncarnation::create(BACKEND, 9, 31, 32, 41);
+    const auto CLONED_DEVICE_SESSION  = CSessionIncarnation::create(BACKEND, CLONED_DEVICE, std::this_thread::get_id(), 61, 62, 200);
+    const auto SAME_VALUE_SESSION     = CSessionIncarnation::create(BACKEND, DEVICE, std::this_thread::get_id(), 51, 52, 41);
+    const auto LOWER_SESSION          = CSessionIncarnation::create(BACKEND, DEVICE, std::this_thread::get_id(), 50, 51, 40);
+    const auto EQUAL_SERIAL_SESSION   = CSessionIncarnation::create(BACKEND, DEVICE, std::this_thread::get_id(), 60, 61, PRE_ROTATION.ticket->serial());
+    const auto OUT_OF_ORDER_SESSION   = CSessionIncarnation::create(BACKEND, DEVICE, std::this_thread::get_id(), 61, 52, 200);
+    EXPECT(value(registry.create(BACKEND, CLONED_DEVICE, CLONED_DEVICE_SESSION).result), value(eRegistryResult::ALREADY_EXISTS));
+    EXPECT(value(STATE->rotateSession(WRONG_ROTATION_SESSION)), value(eSessionRotationResult::INVALID_IDENTITY));
+    EXPECT(value(STATE->rotateSession(CLONED_DEVICE_SESSION)), value(eSessionRotationResult::INVALID_IDENTITY));
+    EXPECT(value(STATE->rotateSession(SESSION)), value(eSessionRotationResult::UNCHANGED));
+    EXPECT(value(STATE->rotateSession(SAME_VALUE_SESSION)), value(eSessionRotationResult::STALE_IDENTITY));
+    EXPECT(value(STATE->rotateSession(LOWER_SESSION)), value(eSessionRotationResult::STALE_IDENTITY));
+    EXPECT(value(STATE->rotateSession(EQUAL_SERIAL_SESSION)), value(eSessionRotationResult::STALE_IDENTITY));
+    EXPECT(value(STATE->rotateSession(OUT_OF_ORDER_SESSION)), value(eSessionRotationResult::STALE_IDENTITY));
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::AWAITING_VALIDATION));
+    EXPECT(STATE->outcome().attempt == PRE_ROTATION.attempt, true);
+    const auto NEW_SESSION = CSessionIncarnation::create(BACKEND, DEVICE, std::this_thread::get_id(), 61, 62, 200);
+    EXPECT(value(STATE->rotateSession(NEW_SESSION)), value(eSessionRotationResult::BUSY));
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::AWAITING_VALIDATION));
+    EXPECT(STATE->outcome().attempt == PRE_ROTATION.attempt, true);
+    EXPECT(value(STATE->fail(PRE_ROTATION.ticket, eAttemptFailure::VALIDATION_FAILED)), value(eResolveAttemptResult::RESOLVED));
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::VALIDATION_FAILED));
+    EXPECT(value(STATE->rotateSession(NEW_SESSION)), value(eSessionRotationResult::ROTATED));
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::SESSION_ROTATED));
+    EXPECT(STATE->committed() == FALLBACK_COMMITTED, true);
+    EXPECT(STATE->currentComplete() == nullptr, true);
+    EXPECT(value(STATE->install(PRE_ROTATION.prepared, eValidationDecision::ACCEPTED)), value(eScanInstallResult::STALE_PREPARED));
+    EXPECT(value(STATE->fail(PRE_ROTATION.ticket, eAttemptFailure::VALIDATION_FAILED)), value(eResolveAttemptResult::STALE_TICKET));
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::STALE_OBSERVATION));
+    EXPECT(value(STATE->rotateSession(NEW_SESSION)), value(eSessionRotationResult::UNCHANGED));
+    EXPECT(value(STATE->rotateSession(SESSION)), value(eSessionRotationResult::STALE_IDENTITY));
+    const auto NEW_SESSION_CLONE = CSessionIncarnation::create(BACKEND, DEVICE, std::this_thread::get_id(), 61, 62, 200);
+    EXPECT(value(STATE->rotateSession(NEW_SESSION_CLONE)), value(eSessionRotationResult::STALE_IDENTITY));
+
+    const auto POST_ROTATION = prepareComplete(*STATE, 214,
+                                               {
+                                                   connector(101, "1:1:2:1:0:0:2560:2880", {LG_60_LEFT}),
+                                                   connector(202, "1:1:2:1:1:0:2560:2880", {LG_60_RIGHT}),
+                                               });
+    EXPECT(POST_ROTATION.ticket->serial(), 201U);
+    EXPECT(POST_ROTATION.attempt->observation()->session() == NEW_SESSION, true);
+    EXPECT(POST_ROTATION.prepared->candidate()->definitions().front() != FIRST_DEFINITION, true);
+    EXPECT(POST_ROTATION.prepared->candidate()->definitions().front()->session() == NEW_SESSION, true);
+    EXPECT(value(STATE->install(POST_ROTATION.prepared, eValidationDecision::ACCEPTED)), value(eScanInstallResult::COMMITTED));
+    const auto POST_ROTATION_COMMITTED = STATE->currentComplete();
+    EXPECT(POST_ROTATION_COMMITTED->observation()->session() == NEW_SESSION, true);
+
+    const auto                 TERMINAL_BACKEND = CBackendLifetime::createTestToken(71);
+    const auto                 TERMINAL_DEVICE  = CDeviceIncarnation::create(TERMINAL_BACKEND, 72, 73, 74, 75);
+    const auto                 TERMINAL_SESSION = CSessionIncarnation::create(TERMINAL_BACKEND, TERMINAL_DEVICE, std::this_thread::get_id(), std::numeric_limits<uint64_t>::max(),
+                                                                              std::numeric_limits<uint64_t>::max(), std::numeric_limits<uint64_t>::max() - 1);
+    CTiledBackendStateRegistry terminalRegistry;
+    const auto                 TERMINAL_CREATED = terminalRegistry.create(TERMINAL_BACKEND, TERMINAL_DEVICE, TERMINAL_SESSION);
+    EXPECT(!!TERMINAL_CREATED, true);
+    const auto TERMINAL = TERMINAL_CREATED.state->beginAttempt(1);
+    EXPECT(!!TERMINAL, true);
+    EXPECT(TERMINAL.ticket->serial(), std::numeric_limits<uint64_t>::max());
+    EXPECT(value(TERMINAL_CREATED.state->fail(TERMINAL.ticket, eAttemptFailure::ACQUISITION_FAILED)), value(eResolveAttemptResult::RESOLVED));
+    EXPECT(value(TERMINAL_CREATED.state->beginAttempt(2).result), value(eBeginAttemptResult::SERIAL_EXHAUSTED));
+    EXPECT(value(TERMINAL_CREATED.state->outcome().result), value(eScanOutcome::SERIAL_EXHAUSTED));
+    const auto TERMINAL_REPLAY = CSessionIncarnation::create(TERMINAL_BACKEND, TERMINAL_DEVICE, std::this_thread::get_id(), std::numeric_limits<uint64_t>::max(),
+                                                             std::numeric_limits<uint64_t>::max(), std::numeric_limits<uint64_t>::max());
+    EXPECT(value(TERMINAL_CREATED.state->rotateSession(TERMINAL_REPLAY)), value(eSessionRotationResult::STALE_IDENTITY));
+    EXPECT(value(TERMINAL_CREATED.state->outcome().result), value(eScanOutcome::SERIAL_EXHAUSTED));
+    EXPECT(value(terminalRegistry.beginTeardown(TERMINAL_BACKEND)), value(eRegistryResult::OK));
+    EXPECT(value(terminalRegistry.erase(TERMINAL_BACKEND)), value(eRegistryResult::OK));
+
+    const auto                 RESOURCE_BACKEND = CBackendLifetime::createTestToken(81);
+    const auto                 RESOURCE_DEVICE  = CDeviceIncarnation::create(RESOURCE_BACKEND, 82, 83, 84, 85);
+    const auto                 RESOURCE_SESSION = CSessionIncarnation::create(RESOURCE_BACKEND, RESOURCE_DEVICE, std::this_thread::get_id(), 86, 87, 85);
+    CTiledBackendStateRegistry resourceRegistry;
+    const auto                 RESOURCE_CREATED = resourceRegistry.create(RESOURCE_BACKEND, RESOURCE_DEVICE, RESOURCE_SESSION);
+    EXPECT(!!RESOURCE_CREATED, true);
+    const auto FINAL_RESOURCE = RESOURCE_CREATED.state->beginAttempt(std::numeric_limits<uint64_t>::max());
+    EXPECT(!!FINAL_RESOURCE, true);
+    EXPECT(FINAL_RESOURCE.ticket->resourceEpoch(), std::numeric_limits<uint64_t>::max());
+    EXPECT(value(RESOURCE_CREATED.state->fail(FINAL_RESOURCE.ticket, eAttemptFailure::ACQUISITION_FAILED)), value(eResolveAttemptResult::RESOLVED));
+    EXPECT(value(RESOURCE_CREATED.state->beginAttempt(1).result), value(eBeginAttemptResult::RESOURCE_EPOCH_EXHAUSTED));
+    EXPECT(value(RESOURCE_CREATED.state->outcome().result), value(eScanOutcome::RESOURCE_EPOCH_EXHAUSTED));
+    EXPECT(value(resourceRegistry.beginTeardown(RESOURCE_BACKEND)), value(eRegistryResult::OK));
+    EXPECT(value(resourceRegistry.erase(RESOURCE_BACKEND)), value(eRegistryResult::OK));
+
+    const auto        OUTCOME_BEFORE_THREAD = STATE->outcome();
+    std::atomic<int>  wrongThreadBegin{-1};
+    std::atomic<int>  wrongThreadTeardown{-1};
+    std::atomic<int>  wrongThreadRotation{-1};
+    std::atomic<bool> wrongThreadCommitted{true};
+    std::atomic<bool> wrongThreadCurrent{true};
+    std::atomic<bool> wrongThreadFind{true};
+    std::thread       WORKER([&] {
+        wrongThreadBegin     = value(STATE->beginAttempt(215).result);
+        wrongThreadTeardown  = value(STATE->beginTeardown());
+        wrongThreadRotation  = value(STATE->rotateSession(NEW_SESSION));
+        wrongThreadCommitted = STATE->committed() != nullptr;
+        wrongThreadCurrent   = STATE->currentComplete() != nullptr;
+        wrongThreadFind      = registry.find(BACKEND) != nullptr;
+    });
+    WORKER.join();
+    EXPECT(wrongThreadBegin.load(), value(eBeginAttemptResult::WRONG_THREAD));
+    EXPECT(wrongThreadTeardown.load(), value(eTeardownResult::WRONG_THREAD));
+    EXPECT(wrongThreadRotation.load(), value(eSessionRotationResult::WRONG_THREAD));
+    EXPECT(wrongThreadCommitted.load(), false);
+    EXPECT(wrongThreadCurrent.load(), false);
+    EXPECT(wrongThreadFind.load(), false);
+    EXPECT(value(STATE->outcome().result), value(OUTCOME_BEFORE_THREAD.result));
+    EXPECT(STATE->currentComplete() == POST_ROTATION_COMMITTED, true);
+
+    EXPECT(unsafeRegistryDestructionTerminates(), true);
+    EXPECT(value(cloneRegistry.beginTeardown(BACKEND)), value(eRegistryResult::OK));
+    EXPECT(value(cloneRegistry.erase(BACKEND)), value(eRegistryResult::OK));
+    EXPECT(cloneRegistry.readyForDestruction(), true);
+    EXPECT(value(registry.erase(BACKEND)), value(eRegistryResult::NOT_READY));
+    EXPECT(value(registry.beginTeardown(BACKEND)), value(eRegistryResult::OK));
+    EXPECT(STATE->readyForDestruction(), true);
+    EXPECT(registry.find(BACKEND) == STATE, true);
+    EXPECT(STATE->committed() == POST_ROTATION_COMMITTED, true);
+    EXPECT(STATE->currentComplete() == nullptr, true);
+    EXPECT(value(STATE->install(POST_ROTATION.prepared, eValidationDecision::ACCEPTED)), value(eScanInstallResult::TEARING_DOWN));
+    EXPECT(value(STATE->prepare(POST_ROTATION.ticket, eScanCompleteness::COMPLETE, {}).result), value(ePrepareScanResult::TEARING_DOWN));
+    EXPECT(value(STATE->fail(POST_ROTATION.ticket, eAttemptFailure::VALIDATION_FAILED)), value(eResolveAttemptResult::STALE_TICKET));
+    EXPECT(value(STATE->outcome().result), value(eScanOutcome::TEARING_DOWN));
+    EXPECT(value(registry.erase(BACKEND)), value(eRegistryResult::OK));
+    EXPECT(registry.readyForDestruction(), true);
+
+    return ret;
+}
diff --git a/tests/TiledCrtcAllocator.cpp b/tests/TiledCrtcAllocator.cpp
index 25248fa8bcbc8ffd95572f4ed6f7edcce96b664a..d633dbc35f338fb684ab1e3e85d24ef5c1bce342 100644
--- a/tests/TiledCrtcAllocator.cpp
+++ b/tests/TiledCrtcAllocator.cpp
@@ -7,6 +7,7 @@
 #include <functional>
 #include <iostream>
 #include <limits>
+#include <map>
 #include <numeric>
 #include <optional>
 #include <string_view>
@@ -16,8 +17,102 @@
 #include <utility>
 #include <vector>
 
+namespace Aquamarine::NDRM::NTiledScan {
+    // Source-private exhaustive-test seam. Production can mint these owners
+    // only through CTiledBackendState.
+    class CScanFixtureAuthority final {
+      public:
+        static PBackendLifetime productionBackend(uint64_t serial, const Hyprutils::Memory::CSharedPointer<CDRMBackend>& backend) {
+            return CBackendLifetime::createProduction(serial, backend);
+        }
+
+        static PCommittedScan mint(const PSessionIncarnation& session, std::vector<uint32_t> connectorIDs, std::vector<NTiling::STileGroup> groups, uint64_t serial,
+                                   uint64_t resourceEpoch) {
+            if (!session || !session->valid() || session->eventThread() != std::this_thread::get_id() || serial == 0 || resourceEpoch == 0)
+                return {};
+            const auto backend = session->backend().lock();
+            if (!backend)
+                return {};
+
+            std::ranges::sort(connectorIDs);
+            const auto                       state       = PStateAuthority{new CStateAuthority{}};
+            const auto                       observation = PScanObservation{new CScanObservation{session, serial, resourceEpoch}};
+            const auto                       ticket      = PScanAttemptTicket{new CScanAttemptTicket{state, backend, session->device(), session, observation, serial}};
+
+            std::vector<SConnectorView>      views;
+            std::vector<SCommittedConnector> connectors;
+            views.reserve(connectorIDs.size());
+            connectors.reserve(connectorIDs.size());
+            for (const auto id : connectorIDs) {
+                views.push_back({.connectorId = id});
+                connectors.push_back({.view = {.connectorId = id}, .projection = {.connectorId = id}});
+            }
+            const auto                        attempt = PScanAttempt{new CScanAttempt{ticket, eScanCompleteness::COMPLETE, std::move(views)}};
+
+            std::vector<PScanGroupDefinition> definitions;
+            std::vector<PScanModeDefinition>  modeDefinitions;
+            for (auto& group : groups) {
+                std::ranges::sort(group.members, [](const auto& lhs, const auto& rhs) {
+                    return std::tie(lhs.tileVLoc, lhs.tileHLoc, lhs.connectorId) < std::tie(rhs.tileVLoc, rhs.tileHLoc, rhs.connectorId);
+                });
+                const auto definition = PScanGroupDefinition{new CScanGroupDefinition{session->device(), session, std::move(group)}};
+                definitions.push_back(definition);
+
+                PScanModeDefinition modes;
+                if (definition->group().kind == NTiling::eTileGroupKind::MULTI_STREAM) {
+                    NTiling::STileModeSynthesisResult synthesis;
+                    synthesis.modes.push_back({.id          = 1,
+                                               .width       = definition->group().width,
+                                               .height      = definition->group().height,
+                                               .refreshRate = 60000,
+                                               .preferred   = true,
+                                               .refresh     = {.numerator = 60, .denominator = 1}});
+                    NTiling::STileModeMap mapping{.logicalModeId = 1};
+                    for (const auto& member : definition->group().members) {
+                        drmModeModeInfo modeInfo = {
+                            .clock       = 1000,
+                            .hdisplay    = static_cast<uint16_t>(member.width),
+                            .hsync_start = static_cast<uint16_t>(member.width),
+                            .hsync_end   = static_cast<uint16_t>(member.width),
+                            .htotal      = static_cast<uint16_t>(member.width),
+                            .vdisplay    = static_cast<uint16_t>(member.height),
+                            .vsync_start = static_cast<uint16_t>(member.height),
+                            .vsync_end   = static_cast<uint16_t>(member.height),
+                            .vtotal      = static_cast<uint16_t>(member.height),
+                        };
+                        mapping.members.push_back({.connectorId = member.connectorId, .modeInfo = modeInfo});
+                    }
+                    synthesis.mappings.push_back(std::move(mapping));
+                    modes = PScanModeDefinition{new CScanModeDefinition{definition, std::move(synthesis)}};
+                    modeDefinitions.push_back(modes);
+                }
+
+                for (const auto& member : definition->group().members) {
+                    const auto connector = std::ranges::find_if(connectors, [&](const auto& candidate) { return candidate.view.connectorId == member.connectorId; });
+                    if (connector == connectors.end())
+                        return {};
+                    connector->projection.definition = definition;
+                    connector->projection.modes      = modes;
+                    if (definition->group().kind == NTiling::eTileGroupKind::MULTI_STREAM) {
+                        connector->projection.role =
+                            member.connectorId == definition->group().primaryConnector ? eConnectorRole::MULTI_STREAM_PRIMARY : eConnectorRole::MULTI_STREAM_MEMBER;
+                    } else if (member.connectorId == definition->group().primaryConnector) {
+                        connector->projection.role = eConnectorRole::DRIVER_UNIFIED_PRIMARY;
+                    } else {
+                        connector->projection.role        = eConnectorRole::DRIVER_UNIFIED_REDUNDANT;
+                        connector->projection.disposition = eConnectorDisposition::SUPPRESS_REDUNDANT;
+                    }
+                }
+            }
+
+            return PCommittedScan{new CCommittedScan{attempt, std::move(connectors), std::move(definitions), std::move(modeDefinitions)}};
+        }
+    };
+}
+
 using namespace Aquamarine;
 using namespace Aquamarine::NDRM::NTiledCrtcAllocator;
+using namespace Aquamarine::NDRM::NTiledScan;
 using Hyprutils::Memory::CSharedPointer;
 using Hyprutils::Memory::CWeakPointer;
 using Hyprutils::Memory::makeShared;
@@ -29,6 +124,10 @@ namespace {
     static_assert(!std::is_move_constructible_v<CPlan>);
     static_assert(!std::is_default_constructible_v<CBinding>);
     static_assert(!std::is_default_constructible_v<CGroupAllocation>);
+    static_assert(!std::is_copy_constructible_v<SResourceIncarnation>);
+    static_assert(!std::is_move_constructible_v<SResourceIncarnation>);
+    static_assert(!std::is_copy_constructible_v<CSnapshot>);
+    static_assert(!std::is_move_constructible_v<CSnapshot>);
     static_assert(std::is_same_v<decltype(std::declval<const CPlan&>().groups()), const std::vector<CGroupAllocation>&>);
     static_assert(std::is_same_v<decltype(std::declval<const CGroupAllocation&>().bindings()), const std::vector<CBinding>&>);
 
@@ -73,15 +172,14 @@ namespace {
         std::vector<std::vector<uint32_t>> planes;
     };
 
-    uint64_t                                               NEXT_OBSERVATION = 1;
-    uint64_t                                               NEXT_RESOURCE    = 1;
-    uint64_t                                               NEXT_DEFINITION  = 1;
-    uint64_t                                               NEXT_ALLOCATION  = 1;
-    std::vector<CSharedPointer<const SBackendIncarnation>> BACKEND_LIFETIMES;
+    uint64_t                                   NEXT_OBSERVATION = 100;
+    uint64_t                                   NEXT_ALLOCATION  = 1;
+    std::vector<PBackendLifetime>              BACKEND_LIFETIMES;
+    std::map<const void*, PSessionIncarnation> DEVICE_SESSIONS;
 
     struct SRequest {
         CSharedPointer<const CSnapshot>                     snapshot;
-        CSharedPointer<const SBackendIncarnation>           currentBackendLifetime;
+        PCommittedScan                                      currentScan;
         std::vector<CSharedPointer<const CGroupDefinition>> currentGroupDefinitions;
         std::vector<SHardHold>                              hardHolds;
         std::vector<SGroupRequest>                          groups;
@@ -91,44 +189,32 @@ namespace {
         SAllocationEpoch                                    epoch;
     };
 
-    template <typename T>
-    CSharedPointer<const T> asConst(CSharedPointer<T> pointer) {
-        return pointer;
+    PBackendLifetime makeBackendLifetime(uint64_t serial) {
+        return CBackendLifetime::createTestToken(serial);
     }
 
-    CSharedPointer<const SBackendIncarnation> makeBackendLifetime(uint64_t serial) {
-        auto lifetime    = makeShared<SBackendIncarnation>();
-        lifetime->serial = serial;
-        return asConst(std::move(lifetime));
+    CSharedPointer<CDRMBackend> makeOpaqueDRMBackendOwner() {
+        auto marker  = makeShared<uint8_t>(1);
+        auto backend = Hyprutils::Memory::reinterpretPointerCast<CDRMBackend>(marker);
+        marker.reset();
+        return backend;
     }
 
-    CSharedPointer<const SDeviceIncarnation> makeDevice(uint64_t deviceId = 900, uint64_t deviceEpoch = 9, uint64_t fdEpoch = 27, uint64_t serial = 81,
-                                                        CSharedPointer<const SBackendIncarnation> lifetime = {}, eBackendBinding binding = eBackendBinding::LIFETIME_TOKEN) {
+    PDeviceIncarnation makeDevice(uint64_t deviceId = 900, uint64_t deviceEpoch = 9, uint64_t fdEpoch = 27, uint64_t serial = 81, PBackendLifetime lifetime = {}) {
         if (!lifetime) {
             lifetime = makeBackendLifetime(serial + 1000);
             BACKEND_LIFETIMES.push_back(lifetime);
         }
-        auto device             = makeShared<SDeviceIncarnation>();
-        device->deviceId        = deviceId;
-        device->deviceEpoch     = deviceEpoch;
-        device->fdEpoch         = fdEpoch;
-        device->serial          = serial;
-        device->binding         = binding;
-        device->backendLifetime = lifetime;
-        return asConst(std::move(device));
+        auto device  = CDeviceIncarnation::create(lifetime, deviceId, deviceEpoch, fdEpoch, serial);
+        auto session = CSessionIncarnation::create(lifetime, device, std::this_thread::get_id(), 17, 1, serial);
+        DEVICE_SESSIONS.emplace(device.impl_, std::move(session));
+        return device;
     }
 
-    CSharedPointer<const SResourceIncarnation> makeIncarnation(eResourceKind kind, uint32_t id, const SGeneration& generation,
-                                                               const CSharedPointer<const SDeviceIncarnation>&      device,
-                                                               const CSharedPointer<const SObservationIncarnation>& observation) {
-        auto incarnation         = makeShared<SResourceIncarnation>();
-        incarnation->kind        = kind;
-        incarnation->resourceID  = id;
-        incarnation->serial      = NEXT_RESOURCE++;
-        incarnation->generation  = generation;
-        incarnation->device      = device;
-        incarnation->observation = observation;
-        return asConst(std::move(incarnation));
+    PSessionIncarnation sessionFor(const PDeviceIncarnation& device) {
+        const auto found = DEVICE_SESSIONS.find(device.impl_);
+        CHECK(found != DEVICE_SESSIONS.end());
+        return found == DEVICE_SESSIONS.end() ? PSessionIncarnation{} : found->second;
     }
 
     std::vector<size_t> naturalOrder(size_t size) {
@@ -137,78 +223,6 @@ namespace {
         return result;
     }
 
-    CSharedPointer<const CSnapshot> makeSnapshot(const SObjectPool& pool, const SCompatibility& compatibility, std::vector<size_t> connectorOrder = {},
-                                                 std::vector<size_t> crtcOrder = {}, std::vector<size_t> planeOrder = {}, CSharedPointer<const SDeviceIncarnation> device = {}) {
-        CHECK(compatibility.connectors.size() == pool.connectors.size());
-        CHECK(compatibility.planes.size() == pool.planes.size());
-        if (!device)
-            device = makeDevice();
-        if (connectorOrder.empty())
-            connectorOrder = naturalOrder(pool.connectors.size());
-        if (crtcOrder.empty())
-            crtcOrder = naturalOrder(pool.crtcs.size());
-        if (planeOrder.empty())
-            planeOrder = naturalOrder(pool.planes.size());
-
-        const SGeneration generation                   = {.device = device->deviceEpoch, .session = 17, .observation = NEXT_OBSERVATION++};
-        auto              mutableObservation           = makeShared<SObservationIncarnation>();
-        mutableObservation->generation                 = generation;
-        mutableObservation->serial                     = generation.observation;
-        mutableObservation->device                     = device;
-        mutableObservation->backendLifetime            = device->backendLifetime;
-        const auto                         observation = asConst(std::move(mutableObservation));
-
-        std::vector<SConnectorResource>    connectors;
-        std::vector<SCRTCResource>         crtcs;
-        std::vector<SPrimaryPlaneResource> planes;
-        connectors.reserve(connectorOrder.size());
-        crtcs.reserve(crtcOrder.size());
-        planes.reserve(planeOrder.size());
-        for (const auto index : connectorOrder) {
-            connectors.push_back({
-                .connector       = pool.connectors.at(index),
-                .incarnation     = makeIncarnation(eResourceKind::CONNECTOR, pool.connectors.at(index)->id, generation, device, observation),
-                .possibleCRTCIDs = compatibility.connectors.at(index),
-            });
-        }
-        for (const auto index : crtcOrder) {
-            crtcs.push_back({
-                .crtc        = pool.crtcs.at(index),
-                .incarnation = makeIncarnation(eResourceKind::CRTC, pool.crtcs.at(index)->id, generation, device, observation),
-            });
-        }
-        for (const auto index : planeOrder) {
-            planes.push_back({
-                .plane           = pool.planes.at(index),
-                .incarnation     = makeIncarnation(eResourceKind::PRIMARY_PLANE, pool.planes.at(index)->id, generation, device, observation),
-                .possibleCRTCIDs = compatibility.planes.at(index),
-                .usable          = true,
-            });
-        }
-
-        const auto snapshot = CSnapshot::create(generation, observation, std::move(connectors), std::move(crtcs), std::move(planes));
-        CHECK(static_cast<bool>(snapshot));
-        return snapshot;
-    }
-
-    SConnectorHandle connectorHandle(const CSharedPointer<const CSnapshot>& snapshot, uint32_t id) {
-        const auto resource = std::ranges::find_if(snapshot->connectors(), [id](const auto& candidate) { return candidate.connector->id == id; });
-        CHECK(resource != snapshot->connectors().end());
-        return {.id = id, .incarnation = resource->incarnation};
-    }
-
-    SCRTCHandle crtcHandle(const CSharedPointer<const CSnapshot>& snapshot, uint32_t id) {
-        const auto resource = std::ranges::find_if(snapshot->crtcs(), [id](const auto& candidate) { return candidate.crtc->id == id; });
-        CHECK(resource != snapshot->crtcs().end());
-        return {.id = id, .incarnation = resource->incarnation};
-    }
-
-    SPrimaryPlaneHandle planeHandle(const CSharedPointer<const CSnapshot>& snapshot, uint32_t id) {
-        const auto resource = std::ranges::find_if(snapshot->primaryPlanes(), [id](const auto& candidate) { return candidate.plane->id == id; });
-        CHECK(resource != snapshot->primaryPlanes().end());
-        return {.id = id, .incarnation = resource->incarnation};
-    }
-
     NTiling::STileGroup tileGroup(uint64_t deviceId, uint32_t groupId, const std::vector<uint32_t>& connectorIDs, bool reverseMembers = false) {
         NTiling::STileGroup group{
             .key              = {.deviceId = deviceId, .groupId = groupId},
@@ -237,9 +251,128 @@ namespace {
         return group;
     }
 
+    struct SGroupSpec {
+        uint32_t              groupId = 0;
+        std::vector<uint32_t> connectorIDs;
+        bool                  reverseMembers = false;
+    };
+
+    CSharedPointer<const CSnapshot> makeSnapshotImpl(const SObjectPool& pool, const SCompatibility& compatibility, std::vector<SGroupSpec> groupSpecs,
+                                                     std::vector<size_t> connectorOrder, std::vector<size_t> crtcOrder, std::vector<size_t> planeOrder, PDeviceIncarnation device) {
+        CHECK(compatibility.connectors.size() == pool.connectors.size());
+        CHECK(compatibility.planes.size() == pool.planes.size());
+        if (!device)
+            device = makeDevice();
+        if (connectorOrder.empty())
+            connectorOrder = naturalOrder(pool.connectors.size());
+        if (crtcOrder.empty())
+            crtcOrder = naturalOrder(pool.crtcs.size());
+        if (planeOrder.empty())
+            planeOrder = naturalOrder(pool.planes.size());
+
+        std::vector<uint32_t> connectorIDs;
+        connectorIDs.reserve(pool.connectors.size());
+        for (const auto& connector : pool.connectors)
+            connectorIDs.push_back(connector->id);
+        std::vector<NTiling::STileGroup> groups;
+        groups.reserve(groupSpecs.size());
+        for (const auto& spec : groupSpecs)
+            groups.push_back(tileGroup(device->deviceId(), spec.groupId, spec.connectorIDs, spec.reverseMembers));
+        const auto scan = CScanFixtureAuthority::mint(sessionFor(device), std::move(connectorIDs), std::move(groups), NEXT_OBSERVATION, NEXT_OBSERVATION);
+        ++NEXT_OBSERVATION;
+        CHECK(static_cast<bool>(scan));
+
+        std::vector<SConnectorCapture>    connectors;
+        std::vector<SCRTCCapture>         crtcs;
+        std::vector<SPrimaryPlaneCapture> planes;
+        connectors.reserve(connectorOrder.size());
+        crtcs.reserve(crtcOrder.size());
+        planes.reserve(planeOrder.size());
+        for (const auto index : connectorOrder) {
+            connectors.push_back({
+                .connector       = pool.connectors.at(index),
+                .possibleCRTCIDs = compatibility.connectors.at(index),
+            });
+        }
+        for (const auto index : crtcOrder) {
+            crtcs.push_back({
+                .crtc = pool.crtcs.at(index),
+            });
+        }
+        for (const auto index : planeOrder) {
+            planes.push_back({
+                .plane           = pool.planes.at(index),
+                .possibleCRTCIDs = compatibility.planes.at(index),
+                .usable          = true,
+            });
+        }
+
+        const auto snapshot = CSnapshot::create(scan, NEXT_ALLOCATION++, std::move(connectors), std::move(crtcs), std::move(planes));
+        CHECK(static_cast<bool>(snapshot));
+        return snapshot;
+    }
+
+    CSharedPointer<const CSnapshot> makeSnapshot(const SObjectPool& pool, const SCompatibility& compatibility, std::vector<size_t> connectorOrder = {},
+                                                 std::vector<size_t> crtcOrder = {}, std::vector<size_t> planeOrder = {}, PDeviceIncarnation device = {}) {
+        return makeSnapshotImpl(pool, compatibility, {}, std::move(connectorOrder), std::move(crtcOrder), std::move(planeOrder), std::move(device));
+    }
+
+    CSharedPointer<const CSnapshot> makeGroupedSnapshot(const SObjectPool& pool, const SCompatibility& compatibility, std::vector<SGroupSpec> groups,
+                                                        std::vector<size_t> connectorOrder = {}, std::vector<size_t> crtcOrder = {}, std::vector<size_t> planeOrder = {},
+                                                        PDeviceIncarnation device = {}) {
+        return makeSnapshotImpl(pool, compatibility, std::move(groups), std::move(connectorOrder), std::move(crtcOrder), std::move(planeOrder), std::move(device));
+    }
+
+    std::vector<SConnectorCapture> connectorCaptures(const CSharedPointer<const CSnapshot>& snapshot) {
+        std::vector<SConnectorCapture> result;
+        for (const auto& resource : snapshot->connectors())
+            result.push_back({.connector = resource.connector, .possibleCRTCIDs = resource.possibleCRTCIDs});
+        return result;
+    }
+
+    std::vector<SCRTCCapture> crtcCaptures(const CSharedPointer<const CSnapshot>& snapshot) {
+        std::vector<SCRTCCapture> result;
+        for (const auto& resource : snapshot->crtcs())
+            result.push_back({.crtc = resource.crtc});
+        return result;
+    }
+
+    std::vector<SPrimaryPlaneCapture> planeCaptures(const CSharedPointer<const CSnapshot>& snapshot) {
+        std::vector<SPrimaryPlaneCapture> result;
+        for (const auto& resource : snapshot->primaryPlanes())
+            result.push_back({.plane = resource.plane, .possibleCRTCIDs = resource.possibleCRTCIDs, .usable = resource.usable});
+        return result;
+    }
+
+    SConnectorHandle connectorHandle(const CSharedPointer<const CSnapshot>& snapshot, uint32_t id) {
+        const auto resource = std::ranges::find_if(snapshot->connectors(), [id](const auto& candidate) { return candidate.connector->id == id; });
+        CHECK(resource != snapshot->connectors().end());
+        return {.id = id, .incarnation = resource->incarnation};
+    }
+
+    SCRTCHandle crtcHandle(const CSharedPointer<const CSnapshot>& snapshot, uint32_t id) {
+        const auto resource = std::ranges::find_if(snapshot->crtcs(), [id](const auto& candidate) { return candidate.crtc->id == id; });
+        CHECK(resource != snapshot->crtcs().end());
+        return {.id = id, .incarnation = resource->incarnation};
+    }
+
+    SPrimaryPlaneHandle planeHandle(const CSharedPointer<const CSnapshot>& snapshot, uint32_t id) {
+        const auto resource = std::ranges::find_if(snapshot->primaryPlanes(), [id](const auto& candidate) { return candidate.plane->id == id; });
+        CHECK(resource != snapshot->primaryPlanes().end());
+        return {.id = id, .incarnation = resource->incarnation};
+    }
+
     CSharedPointer<const CGroupDefinition> makeDefinition(const CSharedPointer<const CSnapshot>& snapshot, uint32_t groupId, const std::vector<uint32_t>& connectorIDs,
                                                           bool reverseMembers = false) {
-        auto definition = CGroupDefinition::create(tileGroup(snapshot->device()->deviceId, groupId, connectorIDs, reverseMembers), snapshot->device(), NEXT_DEFINITION++);
+        static_cast<void>(reverseMembers);
+        const auto found = std::ranges::find_if(snapshot->scan()->definitions(), [&](const auto& candidate) {
+            if (!candidate || candidate->group().key.groupId != groupId || candidate->group().members.size() != connectorIDs.size())
+                return false;
+            return std::ranges::all_of(connectorIDs,
+                                       [&](uint32_t id) { return std::ranges::any_of(candidate->group().members, [id](const auto& member) { return member.connectorId == id; }); });
+        });
+        CHECK(found != snapshot->scan()->definitions().end());
+        auto definition = found == snapshot->scan()->definitions().end() ? CSharedPointer<const CGroupDefinition>{} : CGroupDefinition::create(*found);
         CHECK(static_cast<bool>(definition));
         return definition;
     }
@@ -260,19 +393,19 @@ namespace {
     SRequest requestFor(const CSharedPointer<const CSnapshot>& snapshot, std::vector<CSharedPointer<const CGroupDefinition>> definitions = {}) {
         SRequest request;
         request.snapshot                = snapshot;
-        request.currentBackendLifetime  = snapshot->device()->backendLifetime.lock();
+        request.currentScan             = snapshot->scan();
         request.currentGroupDefinitions = std::move(definitions);
         request.epoch                   = {
-            .session     = snapshot->generation().session,
-            .allocation  = NEXT_ALLOCATION++,
-            .eventThread = 1,
+            .session     = snapshot->session()->sessionEpoch(),
+            .allocation  = snapshot->allocationEpoch(),
+            .eventThread = snapshot->session()->eventThreadEpoch(),
         };
         return request;
     }
 
     CSharedPointer<const CAllocationObservation> observe(const SRequest& request) {
-        return CAllocationObservation::create(request.snapshot, request.currentBackendLifetime, request.currentGroupDefinitions, request.hardHolds, request.groups,
-                                              request.ordinary, request.connectorPreferences, request.planePreferences, request.epoch);
+        return CAllocationObservation::create(request.currentScan, request.snapshot, request.currentGroupDefinitions, request.hardHolds, request.groups, request.ordinary,
+                                              request.connectorPreferences, request.planePreferences, request.epoch);
     }
 
     CSharedPointer<const CPlan> solve(const CSharedPointer<const CSnapshot>& snapshot, const SRequest& request) {
@@ -283,8 +416,12 @@ namespace {
     SCurrentState currentState(const CSharedPointer<const CPlan>& plan) {
         CHECK(static_cast<bool>(plan));
         return {
+            .backendLifetime = plan->snapshot()->device()->backend().lock(),
+            .device          = plan->snapshot()->device(),
+            .session         = plan->snapshot()->session(),
+            .scan            = plan->snapshot()->scan(),
+            .scanObservation = plan->snapshot()->observation(),
             .snapshot        = plan->snapshot(),
-            .backendLifetime = plan->snapshot()->device()->backendLifetime.lock(),
             .observation     = plan->observation(),
             .epoch           = plan->observation()->epoch(),
         };
@@ -597,29 +734,26 @@ namespace {
         CHECK(snapshot->connectors().front().possibleCRTCIDs == std::vector<uint32_t>({10, 11}));
         CHECK(snapshot->primaryPlanes().front().possibleCRTCIDs == std::vector<uint32_t>({10, 11}));
 
-        auto connectors = snapshot->connectors();
+        auto connectors = connectorCaptures(snapshot);
         connectors.front().possibleCRTCIDs.push_back(999);
-        CHECK(!CSnapshot::create(snapshot->generation(), snapshot->observation(), std::move(connectors), snapshot->crtcs(), snapshot->primaryPlanes()));
+        CHECK(!CSnapshot::create(snapshot->scan(), NEXT_ALLOCATION++, std::move(connectors), crtcCaptures(snapshot), planeCaptures(snapshot)));
 
-        auto duplicateCRTCs = snapshot->crtcs();
-        duplicateCRTCs.push_back(snapshot->crtcs().front());
-        CHECK(!CSnapshot::create(snapshot->generation(), snapshot->observation(), snapshot->connectors(), std::move(duplicateCRTCs), snapshot->primaryPlanes()));
+        auto duplicateCRTCs = crtcCaptures(snapshot);
+        duplicateCRTCs.push_back(duplicateCRTCs.front());
+        CHECK(!CSnapshot::create(snapshot->scan(), NEXT_ALLOCATION++, connectorCaptures(snapshot), std::move(duplicateCRTCs), planeCaptures(snapshot)));
 
-        auto tooManyCRTCs = snapshot->crtcs();
+        auto tooManyCRTCs = crtcCaptures(snapshot);
         for (uint32_t id = 12; id < 43; ++id) {
             auto crtc = makeShared<SDRMCRTC>();
             crtc->id  = id;
-            tooManyCRTCs.push_back({
-                .crtc        = std::move(crtc),
-                .incarnation = makeIncarnation(eResourceKind::CRTC, id, snapshot->generation(), snapshot->device(), snapshot->observation()),
-            });
+            tooManyCRTCs.push_back({.crtc = std::move(crtc)});
         }
         CHECK(tooManyCRTCs.size() == 33);
-        CHECK(!CSnapshot::create(snapshot->generation(), snapshot->observation(), snapshot->connectors(), std::move(tooManyCRTCs), snapshot->primaryPlanes()));
+        CHECK(!CSnapshot::create(snapshot->scan(), NEXT_ALLOCATION++, connectorCaptures(snapshot), std::move(tooManyCRTCs), planeCaptures(snapshot)));
 
-        auto unusablePlanes           = snapshot->primaryPlanes();
+        auto unusablePlanes           = planeCaptures(snapshot);
         unusablePlanes.front().usable = false;
-        const auto unusableSnapshot   = CSnapshot::create(snapshot->generation(), snapshot->observation(), snapshot->connectors(), snapshot->crtcs(), std::move(unusablePlanes));
+        const auto unusableSnapshot   = CSnapshot::create(snapshot->scan(), NEXT_ALLOCATION++, connectorCaptures(snapshot), crtcCaptures(snapshot), std::move(unusablePlanes));
         CHECK(static_cast<bool>(unusableSnapshot));
         auto ordinary = requestFor(unusableSnapshot);
         ordinary.ordinary.push_back({.connector = connectorHandle(unusableSnapshot, 1)});
@@ -627,40 +761,26 @@ namespace {
     }
 
     void testDefinitionFactory() {
-        const auto device     = makeDevice(901, 10, 30, 90);
-        auto       valid      = tileGroup(device->deviceId, 7, {1, 2});
-        const auto definition = CGroupDefinition::create(valid, device, 1);
+        SObjectPool pool({1, 2}, {10, 11}, {100, 101});
+        const auto  snapshot       = makeGroupedSnapshot(pool, {.connectors = {{10}, {11}}, .planes = {{10}, {11}}}, {{.groupId = 7, .connectorIDs = {1, 2}}});
+        const auto  scanDefinition = snapshot->scan()->definitions().front();
+        const auto  definition     = CGroupDefinition::create(scanDefinition);
         CHECK(static_cast<bool>(definition));
+        CHECK(definition->scanDefinition() == scanDefinition);
+        CHECK(definition->device() == snapshot->device());
+        CHECK(definition->session() == snapshot->session());
         CHECK(definition->group().members.front().connectorId == 1);
-        CHECK(definition->serial() == 1);
+        CHECK(!CGroupDefinition::create({}));
 
-        auto singleton = tileGroup(device->deviceId, 7, {1});
-        CHECK(!CGroupDefinition::create(singleton, device, 2));
-        auto unified = valid;
-        unified.kind = NTiling::eTileGroupKind::DRIVER_UNIFIED;
-        CHECK(!CGroupDefinition::create(unified, device, 3));
-        auto notMonitor            = valid;
-        notMonitor.isSingleMonitor = false;
-        CHECK(!CGroupDefinition::create(notMonitor, device, 4));
-        auto incomplete     = valid;
-        incomplete.numHTile = 3;
-        CHECK(!CGroupDefinition::create(incomplete, device, 5));
-        auto duplicateConnector                      = valid;
-        duplicateConnector.members.at(1).connectorId = 1;
-        CHECK(!CGroupDefinition::create(duplicateConnector, device, 6));
-        auto duplicateCoordinate                   = valid;
-        duplicateCoordinate.members.at(1).tileHLoc = 0;
-        CHECK(!CGroupDefinition::create(duplicateCoordinate, device, 7));
-        auto badGeometry            = valid;
-        badGeometry.members.at(1).x = 99;
-        CHECK(!CGroupDefinition::create(badGeometry, device, 8));
-        auto badPrimary             = valid;
-        badPrimary.primaryConnector = 2;
-        CHECK(!CGroupDefinition::create(badPrimary, device, 9));
-        auto wrongDevice         = valid;
-        wrongDevice.key.deviceId = device->deviceId + 1;
-        CHECK(!CGroupDefinition::create(wrongDevice, device, 10));
-        CHECK(!CGroupDefinition::create(valid, device, 0));
+        auto unified             = tileGroup(snapshot->device()->deviceId(), 8, {1, 2});
+        unified.kind             = NTiling::eTileGroupKind::DRIVER_UNIFIED;
+        const auto unifiedSerial = NEXT_OBSERVATION++;
+        const auto unifiedScan   = CScanFixtureAuthority::mint(snapshot->session(), {1, 2}, {unified}, unifiedSerial, unifiedSerial);
+        CHECK(static_cast<bool>(unifiedScan));
+        CHECK(!CGroupDefinition::create(unifiedScan->definitions().front()));
+        const auto unifiedSnapshot = CSnapshot::create(unifiedScan, NEXT_ALLOCATION++, connectorCaptures(snapshot), crtcCaptures(snapshot), planeCaptures(snapshot));
+        CHECK(static_cast<bool>(unifiedSnapshot));
+        CHECK(static_cast<bool>(observe(requestFor(unifiedSnapshot))));
     }
 
     void testGroupGreedyTrapAndPreferences() {
@@ -681,7 +801,8 @@ namespace {
             if ((permutationBits & 4U) != 0)
                 std::ranges::reverse(planeOrder);
 
-            const auto snapshot = makeSnapshot(pool, compatibility, connectorOrder, crtcOrder, planeOrder);
+            const auto snapshot = makeGroupedSnapshot(pool, compatibility, {{.groupId = 50, .connectorIDs = {1, 2}, .reverseMembers = (permutationBits & 8U) != 0}}, connectorOrder,
+                                                      crtcOrder, planeOrder);
             auto       request  = oneGroupRequest(snapshot, 50, {1, 2}, (permutationBits & 8U) != 0, (permutationBits & 16U) != 0);
             const auto plan     = solve(snapshot, request);
             CHECK(plan->status() == ePlanStatus::READY);
@@ -696,7 +817,7 @@ namespace {
         }
 
         SObjectPool preferencePool({1, 2}, {10, 11, 12}, {100, 101, 102});
-        const auto  snapshot = makeSnapshot(preferencePool, {.connectors = {{10, 11}, {12}}, .planes = {{10, 11}, {10}, {12}}});
+        const auto  snapshot = makeGroupedSnapshot(preferencePool, {.connectors = {{10, 11}, {12}}, .planes = {{10, 11}, {10}, {12}}}, {{.groupId = 51, .connectorIDs = {1, 2}}});
         auto        request  = oneGroupRequest(snapshot, 51, {1, 2});
         request.connectorPreferences.push_back({.connector = connectorHandle(snapshot, 1), .crtc = crtcHandle(snapshot, 11)});
         request.planePreferences.push_back({.crtc = crtcHandle(snapshot, 11), .plane = planeHandle(snapshot, 101)});
@@ -722,7 +843,12 @@ namespace {
                 std::ranges::reverse(crtcOrder);
             if ((permutationBits & 4U) != 0)
                 std::ranges::reverse(planeOrder);
-            const auto snapshot = makeSnapshot(pool, compatibility, connectorOrder, crtcOrder, planeOrder);
+            const auto snapshot = makeGroupedSnapshot(pool, compatibility,
+                                                      {
+                                                          {.groupId = 10, .connectorIDs = {1, 2}, .reverseMembers = (permutationBits & 8U) != 0},
+                                                          {.groupId = 20, .connectorIDs = {3, 4}, .reverseMembers = (permutationBits & 16U) != 0},
+                                                      },
+                                                      connectorOrder, crtcOrder, planeOrder);
             const auto group10  = makeDefinition(snapshot, 10, {1, 2}, (permutationBits & 8U) != 0);
             const auto group20  = makeDefinition(snapshot, 20, {3, 4}, (permutationBits & 16U) != 0);
             auto       request  = requestFor(snapshot, {group20, group10});
@@ -748,7 +874,8 @@ namespace {
 
         // Status priority is lexicographic, not maximum group count.
         SObjectPool priorityPool({1, 2, 3, 4}, {10, 11}, {100, 101});
-        const auto  snapshot = makeSnapshot(priorityPool, {.connectors = {{10, 11}, {10, 11}, {10, 11}, {10, 11}}, .planes = {{10, 11}, {10, 11}}});
+        const auto  snapshot = makeGroupedSnapshot(priorityPool, {.connectors = {{10, 11}, {10, 11}, {10, 11}, {10, 11}}, .planes = {{10, 11}, {10, 11}}},
+                                                   {{.groupId = 10, .connectorIDs = {1, 2}}, {.groupId = 20, .connectorIDs = {3, 4}}});
         const auto  group10  = makeDefinition(snapshot, 10, {1, 2});
         const auto  group20  = makeDefinition(snapshot, 20, {3, 4});
         auto        request  = requestFor(snapshot, {group20, group10});
@@ -777,7 +904,8 @@ namespace {
                 std::ranges::reverse(crtcOrder);
             if ((permutationBits & 4U) != 0)
                 std::ranges::reverse(planeOrder);
-            const auto snapshot   = makeSnapshot(groupPool, groupCompatibility, connectorOrder, crtcOrder, planeOrder);
+            const auto snapshot   = makeGroupedSnapshot(groupPool, groupCompatibility, {{.groupId = 80, .connectorIDs = {1, 2}, .reverseMembers = (permutationBits & 8U) != 0}},
+                                                        connectorOrder, crtcOrder, planeOrder);
             const auto definition = makeDefinition(snapshot, 80, {1, 2}, (permutationBits & 8U) != 0);
             auto       request    = requestFor(snapshot, {definition});
             request.groups.push_back(groupRequest(snapshot, definition, (permutationBits & 16U) != 0));
@@ -841,7 +969,7 @@ namespace {
         // A complete group cannot worsen the already-optimal enabled
         // preference tuple merely to gain aggregate status.
         SObjectPool preferencePool({1, 2, 3}, {10, 11}, {100, 101});
-        const auto  preferenceSnapshot = makeSnapshot(preferencePool, {.connectors = {{10}, {11}, {10}}, .planes = {{10}, {11}}});
+        const auto  preferenceSnapshot = makeGroupedSnapshot(preferencePool, {.connectors = {{10}, {11}, {10}}, .planes = {{10}, {11}}}, {{.groupId = 81, .connectorIDs = {1, 2}}});
         const auto  preferenceGroup    = makeDefinition(preferenceSnapshot, 81, {1, 2});
         auto        preferenceRequest  = requestFor(preferenceSnapshot, {preferenceGroup});
         preferenceRequest.groups.push_back(groupRequest(preferenceSnapshot, preferenceGroup));
@@ -856,7 +984,7 @@ namespace {
         // Once the enabled tuple ties, complete-group status precedes raw ID
         // canonicalization.
         SObjectPool statusPool({1, 2, 3}, {10, 11}, {100, 101});
-        const auto  statusSnapshot = makeSnapshot(statusPool, {.connectors = {{10, 11}, {10}, {11}}, .planes = {{10}, {11}}});
+        const auto  statusSnapshot = makeGroupedSnapshot(statusPool, {.connectors = {{10, 11}, {10}, {11}}, .planes = {{10}, {11}}}, {{.groupId = 82, .connectorIDs = {1, 2}}});
         const auto  statusGroup    = makeDefinition(statusSnapshot, 82, {1, 2});
         auto        statusRequest  = requestFor(statusSnapshot, {statusGroup});
         statusRequest.groups.push_back(groupRequest(statusSnapshot, statusGroup));
@@ -913,7 +1041,8 @@ namespace {
             auto connectorOrder = naturalOrder(3);
             if ((permutationBits & 1U) != 0)
                 std::ranges::reverse(connectorOrder);
-            const auto fallbackSnapshot = makeSnapshot(fallbackPool, fallbackCompatibility, connectorOrder);
+            const auto fallbackSnapshot = makeGroupedSnapshot(fallbackPool, fallbackCompatibility,
+                                                              {{.groupId = 83, .connectorIDs = {100, 101}, .reverseMembers = (permutationBits & 2U) != 0}}, connectorOrder);
             const auto fallbackGroup    = makeDefinition(fallbackSnapshot, 83, {100, 101}, (permutationBits & 2U) != 0);
             auto       fallbackRequest  = requestFor(fallbackSnapshot, {fallbackGroup});
             fallbackRequest.groups.push_back(groupRequest(fallbackSnapshot, fallbackGroup, (permutationBits & 4U) != 0));
@@ -929,11 +1058,12 @@ namespace {
 
     void testRetainedGroupsAndContention() {
         SObjectPool pool({1, 2, 3, 4, 5, 6}, {10, 11, 12, 13, 14}, {100, 101, 102, 103, 104});
-        const auto  snapshot = makeSnapshot(pool,
-                                            {
-                                                .connectors = {{10, 12}, {11, 13}, {10}, {11}, {14}, {14}},
-                                                .planes     = {{10}, {11}, {12}, {13}, {14}},
-                                            });
+        const auto  snapshot = makeGroupedSnapshot(pool,
+                                                   {
+                                                       .connectors = {{10, 12}, {11, 13}, {10}, {11}, {14}, {14}},
+                                                       .planes     = {{10}, {11}, {12}, {13}, {14}},
+                                                   },
+                                                   {{.groupId = 10, .connectorIDs = {1, 2}}, {.groupId = 20, .connectorIDs = {3, 4}}});
         const auto  group10  = makeDefinition(snapshot, 10, {1, 2});
         const auto  group20  = makeDefinition(snapshot, 20, {3, 4});
         auto        request  = requestFor(snapshot, {group10, group20});
@@ -965,7 +1095,7 @@ namespace {
         // A disabled/quiesced retained group is still retained; ordinary state
         // is explicit and cannot displace it.
         SObjectPool disabledPool({1, 2, 3}, {10, 11}, {100, 101});
-        const auto  disabledSnapshot = makeSnapshot(disabledPool, {.connectors = {{10}, {11}, {10}}, .planes = {{10}, {11}}});
+        const auto  disabledSnapshot = makeGroupedSnapshot(disabledPool, {.connectors = {{10}, {11}, {10}}, .planes = {{10}, {11}}}, {{.groupId = 30, .connectorIDs = {1, 2}}});
         const auto  disabledGroup    = makeDefinition(disabledSnapshot, 30, {1, 2});
         auto        disabledRequest  = requestFor(disabledSnapshot, {disabledGroup});
         auto        disabledRetained = groupRequest(disabledSnapshot, disabledGroup);
@@ -1062,7 +1192,7 @@ namespace {
 
     void testHoldsHallAndZeroMutation() {
         SObjectPool pool({1, 2, 3}, {10, 11}, {100, 101});
-        const auto  snapshot = makeSnapshot(pool, {.connectors = {{10}, {10}, {11}}, .planes = {{10}, {11}}});
+        const auto  snapshot = makeGroupedSnapshot(pool, {.connectors = {{10}, {10}, {11}}, .planes = {{10}, {11}}}, {{.groupId = 40, .connectorIDs = {1, 2}}});
         auto        request  = oneGroupRequest(snapshot, 40, {1, 2});
         request.hardHolds.push_back({
             .reason    = eHardHoldReason::LEASED,
@@ -1146,71 +1276,91 @@ namespace {
         const auto  lifetime = makeBackendLifetime(7001);
         const auto  device   = makeDevice(902, 11, 31, 91, lifetime);
         SObjectPool pool({1, 2}, {10, 11}, {100, 101});
-        const auto  snapshot = makeSnapshot(pool, {.connectors = {{10}, {11}}, .planes = {{10}, {11}}}, {}, {}, {}, device);
+        const auto  snapshot = makeGroupedSnapshot(pool, {.connectors = {{10}, {11}}, .planes = {{10}, {11}}}, {{.groupId = 70, .connectorIDs = {1, 2}}}, {}, {}, {}, device);
         auto        request  = oneGroupRequest(snapshot, 70, {1, 2});
         const auto  ready    = solve(snapshot, request);
         CHECK(ready->status() == ePlanStatus::READY);
 
-        const auto wrongLifetime       = makeBackendLifetime(7002);
-        request.currentBackendLifetime = wrongLifetime;
-        const auto wrongPlan           = solve(snapshot, request);
-        CHECK(wrongPlan->status() == ePlanStatus::INVALID);
-        CHECK(bindingCount(wrongPlan) == 0);
+        // A test token can only capture resources with empty production owners.
+        auto unexpectedBackend           = makeOpaqueDRMBackendOwner();
+        pool.connectors.front()->backend = unexpectedBackend;
+        CHECK(!CSnapshot::create(snapshot->scan(), NEXT_ALLOCATION++, connectorCaptures(snapshot), crtcCaptures(snapshot), planeCaptures(snapshot)));
+        pool.connectors.front()->backend = {};
 
-        auto wrongObservation             = makeShared<SObservationIncarnation>(*snapshot->observation());
-        wrongObservation->backendLifetime = wrongLifetime;
-        CHECK(!CSnapshot::create(snapshot->generation(), asConst(std::move(wrongObservation)), {}, {}, {}));
-
-        auto productionDevice                  = makeShared<SDeviceIncarnation>(*device);
-        productionDevice->binding              = eBackendBinding::PRODUCTION_BACKEND;
-        const auto productionOwner             = asConst(std::move(productionDevice));
-        auto       productionObservation       = makeShared<SObservationIncarnation>();
-        productionObservation->generation      = snapshot->generation();
-        productionObservation->serial          = snapshot->observation()->serial;
-        productionObservation->device          = productionOwner;
-        productionObservation->backendLifetime = productionOwner->backendLifetime;
-        // A production-bound capture can never use an empty/expired actual DRM
-        // backend, even though the generic lifetime token is live.
-        CHECK(!CSnapshot::create(snapshot->generation(), asConst(std::move(productionObservation)), {}, {}, {}));
-
-        request.currentBackendLifetime.reset();
-        auto expiringLifetime = lifetime;
-        expiringLifetime.reset();
-        // The original const owner is still live until this scope ends, so make
-        // a separate snapshot whose token can actually expire.
+        // A short-lived test token invalidates every exact scan/allocation
+        // owner chained to it.
         auto       shortLifetime = makeBackendLifetime(7003);
         const auto shortDevice   = makeDevice(903, 12, 32, 92, shortLifetime);
-        const auto shortSnapshot = makeSnapshot(pool, {.connectors = {{10}, {11}}, .planes = {{10}, {11}}}, {}, {}, {}, shortDevice);
-        auto       shortRequest  = oneGroupRequest(shortSnapshot, 71, {1, 2});
-        const auto shortReady    = solve(shortSnapshot, shortRequest);
+        const auto shortSnapshot =
+            makeGroupedSnapshot(pool, {.connectors = {{10}, {11}}, .planes = {{10}, {11}}}, {{.groupId = 71, .connectorIDs = {1, 2}}}, {}, {}, {}, shortDevice);
+        auto       shortRequest = oneGroupRequest(shortSnapshot, 71, {1, 2});
+        const auto shortReady   = solve(shortSnapshot, shortRequest);
         CHECK(shortReady->status() == ePlanStatus::READY);
-        shortRequest.currentBackendLifetime.reset();
         shortLifetime.reset();
-        CHECK(!shortDevice->backendLifetime.valid());
+        CHECK(shortDevice->backend().expired());
         CHECK(Aquamarine::NDRM::NTiledCrtcAllocator::solve(shortReady->observation())->status() == ePlanStatus::STALE);
         auto staleCurrent            = currentState(shortReady);
         staleCurrent.backendLifetime = {};
         CHECK(!withCurrentPlan(shortReady, staleCurrent, [](const CPlan&) {}));
+
+        // Production binding is minted only from a live exact CDRMBackend
+        // owner, and every captured DRM resource must carry that same owner.
+        CSharedPointer<CDRMBackend> emptyBackend;
+        CHECK(!CScanFixtureAuthority::productionBackend(7100, emptyBackend));
+        auto       productionBackend  = makeOpaqueDRMBackendOwner();
+        const auto productionLifetime = CScanFixtureAuthority::productionBackend(7101, productionBackend);
+        CHECK(static_cast<bool>(productionLifetime));
+        const auto productionDevice = makeDevice(904, 13, 33, 93, productionLifetime);
+        for (auto& connector : pool.connectors)
+            connector->backend = productionBackend;
+        for (auto& crtc : pool.crtcs)
+            crtc->backend = productionBackend;
+        for (auto& plane : pool.planes)
+            plane->backend = productionBackend;
+        const auto productionSnapshot =
+            makeGroupedSnapshot(pool, {.connectors = {{10}, {11}}, .planes = {{10}, {11}}}, {{.groupId = 72, .connectorIDs = {1, 2}}}, {}, {}, {}, productionDevice);
+        const auto productionReady = solve(productionSnapshot, oneGroupRequest(productionSnapshot, 72, {1, 2}));
+        CHECK(productionReady->status() == ePlanStatus::READY);
+
+        auto wrongProductionBackend      = makeOpaqueDRMBackendOwner();
+        pool.connectors.front()->backend = wrongProductionBackend;
+        CHECK(!CSnapshot::create(productionSnapshot->scan(), NEXT_ALLOCATION++, connectorCaptures(productionSnapshot), crtcCaptures(productionSnapshot),
+                                 planeCaptures(productionSnapshot)));
+        pool.connectors.front()->backend = productionBackend;
+
+        CTiledBackendStateRegistry productionRegistry;
+        const auto                 productionCreated = productionRegistry.create(productionLifetime, productionDevice, sessionFor(productionDevice));
+        CHECK(static_cast<bool>(productionCreated));
+        productionBackend.reset();
+        CHECK(productionLifetime->structurallyValid());
+        CHECK(!productionLifetime->valid());
+        CHECK(Aquamarine::NDRM::NTiledCrtcAllocator::solve(productionReady->observation())->status() == ePlanStatus::STALE);
+        CHECK(!withCurrentPlan(productionReady, currentState(productionReady), [](const CPlan&) {}));
+        // Teardown must still accept the exact structural token after Hypr's
+        // weak CDRMBackend owner expires before a backend destructor body.
+        CHECK(productionRegistry.beginTeardown(productionLifetime) == eRegistryResult::OK);
+        CHECK(productionRegistry.erase(productionLifetime) == eRegistryResult::OK);
     }
 
     void testStaleIdentityAndCurrentness() {
         SObjectPool pool({1, 2}, {10, 11}, {100, 101});
-        const auto  snapshot = makeSnapshot(pool, {.connectors = {{10}, {11}}, .planes = {{10}, {11}}});
+        const auto  snapshot = makeGroupedSnapshot(pool, {.connectors = {{10}, {11}}, .planes = {{10}, {11}}}, {{.groupId = 50, .connectorIDs = {1, 2}}});
         auto        request  = oneGroupRequest(snapshot, 50, {1, 2});
 
-        auto        twinConnectors             = snapshot->connectors();
-        twinConnectors.front().possibleCRTCIDs = {10, 11};
-        const auto twin = CSnapshot::create(snapshot->generation(), snapshot->observation(), std::move(twinConnectors), snapshot->crtcs(), snapshot->primaryPlanes());
+        auto        twinConnectorCaptures             = connectorCaptures(snapshot);
+        twinConnectorCaptures.front().possibleCRTCIDs = {10, 11};
+        const auto twin = CSnapshot::create(snapshot->scan(), NEXT_ALLOCATION++, std::move(twinConnectorCaptures), crtcCaptures(snapshot), planeCaptures(snapshot));
         CHECK(static_cast<bool>(twin));
 
         const auto originalDefinition = request.groups.front().definition;
-        const auto clonedDefinition   = CGroupDefinition::create(originalDefinition->group(), snapshot->device(), originalDefinition->serial());
+        const auto clonedDefinition   = CGroupDefinition::create(originalDefinition->scanDefinition());
         CHECK(static_cast<bool>(clonedDefinition));
         auto cloneRequest                      = request;
         cloneRequest.groups.front().definition = clonedDefinition;
         const auto clonePlan                   = solve(snapshot, cloneRequest);
-        CHECK(clonePlan->status() == ePlanStatus::STALE);
-        CHECK(bindingCount(clonePlan) == 0);
+        CHECK(clonePlan->status() == ePlanStatus::READY);
+        CHECK(clonePlan->groups().front().definition() == clonedDefinition);
+        CHECK(clonePlan->groups().front().definition()->scanDefinition() == originalDefinition->scanDefinition());
 
         auto badProjection = request;
         badProjection.groups.front().connectors.pop_back();
@@ -1220,9 +1370,8 @@ namespace {
         missingDefinition.groups.clear();
         CHECK(solve(snapshot, missingDefinition)->status() == ePlanStatus::INVALID);
 
-        auto clonedIncarnation                                    = makeShared<SResourceIncarnation>(*request.groups.front().connectors.front().incarnation);
         auto staleHandle                                          = request;
-        staleHandle.groups.front().connectors.front().incarnation = asConst(std::move(clonedIncarnation));
+        staleHandle.groups.front().connectors.front().incarnation = connectorHandle(twin, 1).incarnation;
         CHECK(solve(snapshot, staleHandle)->status() == ePlanStatus::STALE);
 
         const auto readyPlan    = solve(snapshot, request);
@@ -1235,6 +1384,24 @@ namespace {
         CHECK(!withCurrentPlan(readyPlan, twinCurrent, [&](const CPlan&) { ++callbacks; }));
         CHECK(fakeGroupMutations(readyPlan, twinCurrent) == 0);
 
+        // A new committed scan with identical values is a distinct authority.
+        const auto cloneScanSnapshot =
+            makeGroupedSnapshot(pool, {.connectors = {{10}, {11}}, .planes = {{10}, {11}}}, {{.groupId = 50, .connectorIDs = {1, 2}}}, {}, {}, {}, snapshot->device());
+        const auto cloneScanDefinition   = makeDefinition(cloneScanSnapshot, 50, {1, 2});
+        auto       scanSnapshotMismatch  = request;
+        scanSnapshotMismatch.currentScan = cloneScanSnapshot->scan();
+        CHECK(!observe(scanSnapshotMismatch));
+        CHECK(Aquamarine::NDRM::NTiledCrtcAllocator::solve(observe(scanSnapshotMismatch))->status() == ePlanStatus::INVALID);
+        auto scanDefinitionMismatch                      = request;
+        scanDefinitionMismatch.currentGroupDefinitions   = {cloneScanDefinition};
+        scanDefinitionMismatch.groups.front().definition = cloneScanDefinition;
+        CHECK(!observe(scanDefinitionMismatch));
+
+        auto scanMismatchCurrent = freshCurrent;
+        scanMismatchCurrent.scan = cloneScanSnapshot->scan();
+        CHECK(!withCurrentPlan(readyPlan, scanMismatchCurrent, [&](const CPlan&) { ++callbacks; }));
+        CHECK(fakeGroupMutations(readyPlan, scanMismatchCurrent) == 0);
+
         auto replacementRequest                      = request;
         replacementRequest.currentGroupDefinitions   = {clonedDefinition};
         replacementRequest.groups.front().definition = clonedDefinition;
@@ -1249,15 +1416,17 @@ namespace {
         CHECK(callbacks == 1);
 
         // Same numeric IDs on another device owner cannot rehabilitate a group.
-        const auto otherDevice   = makeDevice(901, 10, 30, 90);
-        const auto otherSnapshot = makeSnapshot(pool, {.connectors = {{10}, {11}}, .planes = {{10}, {11}}}, {}, {}, {}, otherDevice);
-        auto       crossDevice   = requestFor(otherSnapshot, {originalDefinition});
+        const auto otherDevice = makeDevice(901, 10, 30, 90);
+        const auto otherSnapshot =
+            makeGroupedSnapshot(pool, {.connectors = {{10}, {11}}, .planes = {{10}, {11}}}, {{.groupId = 50, .connectorIDs = {1, 2}}}, {}, {}, {}, otherDevice);
+        auto crossDevice = requestFor(otherSnapshot, {originalDefinition});
         crossDevice.groups.push_back(groupRequest(otherSnapshot, originalDefinition));
-        CHECK(solve(otherSnapshot, crossDevice)->status() == ePlanStatus::STALE);
-        CHECK(!CGroupDefinition::create(tileGroup(snapshot->device()->deviceId, 50, {1, 2}), otherDevice, 99));
+        CHECK(!observe(crossDevice));
+        CHECK(solve(otherSnapshot, crossDevice)->status() == ePlanStatus::INVALID);
 
         // Observation-generation ABA with the same resource IDs stays stale.
-        const auto newerSnapshot   = makeSnapshot(pool, {.connectors = {{10}, {11}}, .planes = {{10}, {11}}}, {}, {}, {}, snapshot->device());
+        const auto newerSnapshot =
+            makeGroupedSnapshot(pool, {.connectors = {{10}, {11}}, .planes = {{10}, {11}}}, {{.groupId = 50, .connectorIDs = {1, 2}}}, {}, {}, {}, snapshot->device());
         const auto newerDefinition = makeDefinition(newerSnapshot, 50, {1, 2});
         auto       generationABA   = groupRequest(newerSnapshot, newerDefinition);
         generationABA.connectors   = request.groups.front().connectors;
@@ -1268,11 +1437,12 @@ namespace {
 
     void testAllocationObservationCurrentness() {
         SObjectPool pool({1, 2, 3, 4, 5}, {10, 11, 12, 13, 14}, {100, 101, 102, 103, 104});
-        const auto  snapshot   = makeSnapshot(pool,
-                                              {
-                                                  .connectors = {{10}, {11}, {12}, {13}, {14}},
-                                                  .planes     = {{10}, {11}, {12}, {13}, {14}},
-                                              });
+        const auto  snapshot   = makeGroupedSnapshot(pool,
+                                                     {
+                                                         .connectors = {{10}, {11}, {12}, {13}, {14}},
+                                                         .planes     = {{10}, {11}, {12}, {13}, {14}},
+                                                     },
+                                                     {{.groupId = 90, .connectorIDs = {1, 2}}});
         const auto  definition = makeDefinition(snapshot, 90, {1, 2});
         auto        request    = requestFor(snapshot, {definition});
         auto        retained   = groupRequest(snapshot, definition);
@@ -1347,7 +1517,7 @@ namespace {
 
         auto allocationEpochChanged = request;
         ++allocationEpochChanged.epoch.allocation;
-        rejectsReplacement(allocationEpochChanged);
+        CHECK(!observe(allocationEpochChanged));
 
         auto sessionChanged = freshCurrent;
         ++sessionChanged.epoch.session;
@@ -1359,11 +1529,34 @@ namespace {
         std::atomic_size_t          wrongThreadCallbacks   = 0;
         std::atomic_bool            readyGateAccepted      = true;
         std::atomic_bool            workerPlanGateAccepted = true;
+        std::atomic_bool            workerObservationMade  = true;
+        std::atomic_bool            workerSnapshotMade     = true;
         CSharedPointer<const CPlan> workerPlan;
-        std::thread                 wrongThread([&] {
+        auto                        workerScan           = snapshot->scan();
+        auto                        workerSnapshot       = snapshot;
+        auto                        workerDefinitions    = request.currentGroupDefinitions;
+        auto                        workerHardHolds      = request.hardHolds;
+        auto                        workerGroups         = request.groups;
+        auto                        workerOrdinary       = request.ordinary;
+        auto                        workerConnectorPrefs = request.connectorPreferences;
+        auto                        workerPlanePrefs     = request.planePreferences;
+        auto                        workerEpoch          = request.epoch;
+        auto                        workerSnapshotScan   = snapshot->scan();
+        auto                        workerConnectors     = connectorCaptures(snapshot);
+        auto                        workerCRTCs          = crtcCaptures(snapshot);
+        auto                        workerPlanes         = planeCaptures(snapshot);
+        std::thread                 wrongThread([&, scan = std::move(workerScan), capturedSnapshot = std::move(workerSnapshot), definitions = std::move(workerDefinitions),
+                                                 holds = std::move(workerHardHolds), groups = std::move(workerGroups), ordinary = std::move(workerOrdinary),
+                                                 connectorPrefs = std::move(workerConnectorPrefs), planePrefs = std::move(workerPlanePrefs), epoch = workerEpoch,
+                                                 snapshotScan = std::move(workerSnapshotScan), connectors = std::move(workerConnectors), crtcs = std::move(workerCRTCs),
+                                                 planes = std::move(workerPlanes)]() mutable {
             readyGateAccepted      = withCurrentPlan(plan, freshCurrent, [&](const CPlan&) { ++wrongThreadCallbacks; });
             workerPlan             = Aquamarine::NDRM::NTiledCrtcAllocator::solve(plan->observation());
             workerPlanGateAccepted = withCurrentPlan(workerPlan, freshCurrent, [&](const CPlan&) { ++wrongThreadCallbacks; });
+            workerObservationMade =
+                static_cast<bool>(CAllocationObservation::create(std::move(scan), std::move(capturedSnapshot), std::move(definitions), std::move(holds), std::move(groups),
+                                                                 std::move(ordinary), std::move(connectorPrefs), std::move(planePrefs), epoch));
+            workerSnapshotMade = static_cast<bool>(CSnapshot::create(std::move(snapshotScan), NEXT_ALLOCATION++, std::move(connectors), std::move(crtcs), std::move(planes)));
         });
         wrongThread.join();
         CHECK(!readyGateAccepted.load());
@@ -1372,38 +1565,78 @@ namespace {
         CHECK(!workerPlan->snapshot());
         CHECK(bindingCount(workerPlan) == 0);
         CHECK(!workerPlanGateAccepted.load());
+        CHECK(!workerObservationMade.load());
+        CHECK(!workerSnapshotMade.load());
         CHECK(wrongThreadCallbacks.load() == 0);
         CHECK(callbacks == 1);
     }
 
     void testOwnerRetentionForBothStatuses() {
         CWeakPointer<const CGroupDefinition> allocatedOwner;
+        CWeakPointer<CScanGroupDefinition>   allocatedScanDefinition;
+        CWeakPointer<CCommittedScan>         allocatedScan;
+        CWeakPointer<CScanObservation>       allocatedScanObservation;
         CWeakPointer<const CGroupDefinition> unmatchedOwner;
+        CWeakPointer<CScanGroupDefinition>   unmatchedScanDefinition;
+        CWeakPointer<CCommittedScan>         unmatchedScan;
+        CWeakPointer<CScanObservation>       unmatchedScanObservation;
         CSharedPointer<const CPlan>          allocatedPlan;
         CSharedPointer<const CPlan>          unmatchedPlan;
         {
             SObjectPool allocatedPool({1, 2}, {10, 11}, {100, 101});
-            const auto  snapshot = makeSnapshot(allocatedPool, {.connectors = {{10}, {11}}, .planes = {{10}, {11}}});
-            auto        request  = oneGroupRequest(snapshot, 60, {1, 2});
-            allocatedOwner       = request.groups.front().definition;
-            allocatedPlan        = solve(snapshot, request);
+            const auto  snapshot     = makeGroupedSnapshot(allocatedPool, {.connectors = {{10}, {11}}, .planes = {{10}, {11}}}, {{.groupId = 60, .connectorIDs = {1, 2}}});
+            auto        request      = oneGroupRequest(snapshot, 60, {1, 2});
+            allocatedOwner           = request.groups.front().definition;
+            allocatedScanDefinition  = request.groups.front().definition->scanDefinition();
+            allocatedScan            = snapshot->scan();
+            allocatedScanObservation = snapshot->observation();
+            allocatedPlan            = solve(snapshot, request);
         }
         {
             SObjectPool unmatchedPool({1, 2}, {10}, {100});
-            const auto  snapshot = makeSnapshot(unmatchedPool, {.connectors = {{10}, {10}}, .planes = {{10}}});
-            auto        request  = oneGroupRequest(snapshot, 61, {1, 2});
-            unmatchedOwner       = request.groups.front().definition;
-            unmatchedPlan        = solve(snapshot, request);
+            const auto  snapshot     = makeGroupedSnapshot(unmatchedPool, {.connectors = {{10}, {10}}, .planes = {{10}}}, {{.groupId = 61, .connectorIDs = {1, 2}}});
+            auto        request      = oneGroupRequest(snapshot, 61, {1, 2});
+            unmatchedOwner           = request.groups.front().definition;
+            unmatchedScanDefinition  = request.groups.front().definition->scanDefinition();
+            unmatchedScan            = snapshot->scan();
+            unmatchedScanObservation = snapshot->observation();
+            unmatchedPlan            = solve(snapshot, request);
         }
         CHECK(allocatedPlan->groups().front().status() == eGroupStatus::ALLOCATED);
         CHECK(unmatchedPlan->groups().front().status() == eGroupStatus::NO_MATCH);
+        CHECK(unmatchedPlan->groups().front().bindings().empty());
         CHECK(allocatedOwner.valid());
+        CHECK(allocatedScanDefinition.valid());
+        CHECK(allocatedScan.valid());
+        CHECK(allocatedScanObservation.valid());
         CHECK(unmatchedOwner.valid());
+        CHECK(unmatchedScanDefinition.valid());
+        CHECK(unmatchedScan.valid());
+        CHECK(unmatchedScanObservation.valid());
+        CHECK(allocatedPlan->observation()->scan() == allocatedPlan->snapshot()->scan());
+        CHECK(unmatchedPlan->observation()->scan() == unmatchedPlan->snapshot()->scan());
+        CHECK(allocatedPlan->groups().front().definition()->scanDefinition() == allocatedScanDefinition.lock());
+        CHECK(unmatchedPlan->groups().front().definition()->scanDefinition() == unmatchedScanDefinition.lock());
         CHECK(allocatedPlan->groups().front().definition().impl_ == allocatedPlan->groups().front().bindings().front().definition().impl_);
+        std::vector<uint32_t> unmatchedMembers;
+        for (const auto& binding : unmatchedPlan->ordinaryBindings()) {
+            CHECK(!binding.tiled());
+            CHECK(!binding.definition());
+            unmatchedMembers.push_back(binding.connector()->id);
+        }
+        unmatchedMembers.insert(unmatchedMembers.end(), unmatchedPlan->unallocatedOrdinaryConnectorIDs().begin(), unmatchedPlan->unallocatedOrdinaryConnectorIDs().end());
+        std::ranges::sort(unmatchedMembers);
+        CHECK(unmatchedMembers == std::vector<uint32_t>({1, 2}));
         allocatedPlan = {};
         unmatchedPlan = {};
         CHECK(!allocatedOwner.valid());
+        CHECK(!allocatedScanDefinition.valid());
+        CHECK(!allocatedScan.valid());
+        CHECK(!allocatedScanObservation.valid());
         CHECK(!unmatchedOwner.valid());
+        CHECK(!unmatchedScanDefinition.valid());
+        CHECK(!unmatchedScan.valid());
+        CHECK(!unmatchedScanObservation.valid());
     }
 
     void testExhaustiveCompatibility() {
@@ -1463,9 +1696,9 @@ namespace {
                         compatibility.planes.push_back({11});
                     }
 
-                    const auto snapshot  = makeSnapshot(pool, compatibility);
-                    const auto plan      = solve(snapshot, oneGroupRequest(snapshot, 1, allConnectorIDs));
-                    const auto reference = bruteForce(connectorMasks, planeMasks, variableCRTCIDs, variablePlaneIDs);
+                    const auto groupSnapshot = makeGroupedSnapshot(pool, compatibility, {{.groupId = 1, .connectorIDs = allConnectorIDs}});
+                    const auto plan          = solve(groupSnapshot, oneGroupRequest(groupSnapshot, 1, allConnectorIDs));
+                    const auto reference     = bruteForce(connectorMasks, planeMasks, variableCRTCIDs, variablePlaneIDs);
                     ++groupCases;
                     CHECK(plan->status() == ePlanStatus::READY);
                     CHECK(plan->groups().size() == 1);
@@ -1482,10 +1715,11 @@ namespace {
                         }
                     }
 
-                    auto ordinaryRequest = requestFor(snapshot);
+                    const auto ordinarySnapshot = makeSnapshot(pool, compatibility);
+                    auto       ordinaryRequest  = requestFor(ordinarySnapshot);
                     for (const auto connectorID : variableConnectorIDs)
-                        ordinaryRequest.ordinary.push_back({.connector = connectorHandle(snapshot, connectorID)});
-                    const auto        ordinaryPlan      = solve(snapshot, ordinaryRequest);
+                        ordinaryRequest.ordinary.push_back({.connector = connectorHandle(ordinarySnapshot, connectorID)});
+                    const auto        ordinaryPlan      = solve(ordinarySnapshot, ordinaryRequest);
                     const auto        ordinaryReference = bruteForceOrdinary(connectorMasks, planeMasks, variableConnectorIDs, variableCRTCIDs, variablePlaneIDs);
                     COrdinaryBindings ordinaryActual;
                     for (const auto& binding : ordinaryPlan->ordinaryBindings())
@@ -1495,14 +1729,16 @@ namespace {
                     CHECK(ordinaryActual == ordinaryReference);
 
                     if (size == 3) {
-                        const auto combinedDefinition = makeDefinition(snapshot, 2, {variableConnectorIDs.at(0), variableConnectorIDs.at(1)});
-                        auto       combinedRequest    = requestFor(snapshot, {combinedDefinition});
-                        combinedRequest.groups.push_back(groupRequest(snapshot, combinedDefinition));
+                        const auto combinedSnapshot =
+                            makeGroupedSnapshot(pool, compatibility, {{.groupId = 2, .connectorIDs = {variableConnectorIDs.at(0), variableConnectorIDs.at(1)}}});
+                        const auto combinedDefinition = makeDefinition(combinedSnapshot, 2, {variableConnectorIDs.at(0), variableConnectorIDs.at(1)});
+                        auto       combinedRequest    = requestFor(combinedSnapshot, {combinedDefinition});
+                        combinedRequest.groups.push_back(groupRequest(combinedSnapshot, combinedDefinition));
                         combinedRequest.ordinary.push_back({
-                            .connector = connectorHandle(snapshot, variableConnectorIDs.at(2)),
+                            .connector = connectorHandle(combinedSnapshot, variableConnectorIDs.at(2)),
                             .priority  = eOrdinaryPriority::ENABLED_UNMATCHED,
                         });
-                        const auto                 combinedPlan  = solve(snapshot, combinedRequest);
+                        const auto                 combinedPlan  = solve(combinedSnapshot, combinedRequest);
                         const SCombinedOracleInput combinedInput = {
                             .candidates =
                                 {
@@ -1542,12 +1778,12 @@ namespace {
                     }
 
                     if (size == 2) {
-                        auto tierRequest     = requestFor(snapshot);
+                        auto tierRequest     = requestFor(ordinarySnapshot);
                         tierRequest.ordinary = {
-                            {.connector = connectorHandle(snapshot, variableConnectorIDs.at(0)), .priority = eOrdinaryPriority::ENABLED_UNMATCHED},
-                            {.connector = connectorHandle(snapshot, variableConnectorIDs.at(1)), .priority = eOrdinaryPriority::DETACHED_DISABLED_BACKUP},
+                            {.connector = connectorHandle(ordinarySnapshot, variableConnectorIDs.at(0)), .priority = eOrdinaryPriority::ENABLED_UNMATCHED},
+                            {.connector = connectorHandle(ordinarySnapshot, variableConnectorIDs.at(1)), .priority = eOrdinaryPriority::DETACHED_DISABLED_BACKUP},
                         };
-                        const auto                 tierPlan  = solve(snapshot, tierRequest);
+                        const auto                 tierPlan  = solve(ordinarySnapshot, tierRequest);
                         const SCombinedOracleInput tierInput = {
                             .candidates =
                                 {
diff --git a/tests/TiledVisibility.cmake b/tests/TiledVisibility.cmake
index ab089ff6c27cdd8e9f5e5dc3094a77514c67f705..a59ce36465699a6df2422fee868c56ecaa5112b4 100644
--- a/tests/TiledVisibility.cmake
+++ b/tests/TiledVisibility.cmake
@@ -74,6 +74,6 @@ if(NOT demangle_result EQUAL 0)
 endif()
 
 if(demangled_output MATCHES
-   "Aquamarine::(NTiling|TiledCrtcAllocator)::|Aquamarine::NDRM::.*(Tile|tile|PlaneViewport|PlaneFormats|intersectPlaneFormats|encodePlaneViewport)")
+   "Aquamarine::(NTiling|TiledCrtcAllocator)::|Aquamarine::NDRM::NTiled(CrtcAllocator|Incarnations|Scan)::|Aquamarine::NDRM::.*(Tile|tile|PlaneViewport|PlaneFormats|intersectPlaneFormats|encodePlaneViewport)")
   message(FATAL_ERROR "source-private TILE symbol family is dynamically exported")
 endif()