v0.3.4-pre.008

crates/ksp-store-lib/src/lib.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-lib/src/lib.rs
-// version: 8
+// version: 9
 
 #![warn(missing_docs)]
 #![deny(unreachable_pub)]
@@ -8,9 +8,10 @@
 //! Common backend-neutral Store runtime facade for KSP.
 //!
 //! The runtime facade owns backend selection, lifecycle, safe diagnostics and
-//! backend-neutral capability dispatch. `0.3.3-pre.008` completes the PostgreSQL
-//! `RawTransaction` vertical slice by implementing the six transaction capabilities
-//! on both the physical backend and this common facade without exposing physical types.
+//! backend-neutral capability dispatch. `0.3.3-pre.008` completed the six PostgreSQL
+//! `RawTransaction` capabilities. `0.3.4-pre.008` adds the four `RawAccount*` capabilities
+//! on both the physical backend and this common facade, completing the RAW inventory at
+//! ten capabilities without exposing physical types.
 //!
 //! The default `postgres` feature compiles the official PostgreSQL backend as
 //! an optional implementation dependency. No backend implementation type is

crates/ksp-store-lib/src/store.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-lib/src/store.rs
-// version: 6
+// version: 7
 
 /// Opaque common Store runtime facade.
 ///
@@ -116,6 +116,156 @@ impl std::fmt::Debug for Store {
     }
 }
 
+impl ksp_store_api::RawAccountObservationRead for Store {
+    fn get_raw_account_observation<'a>(
+        &'a self,
+        observation_key: &'a ksp_store_api::RawObservationKey,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawAccountObservation>>> {
+        return std::boxed::Box::pin(async move {
+            #[cfg(feature = "postgres")]
+            {
+                return match &self.runtime {
+                    StoreRuntime::Postgres(backend) => {
+                        let result = backend.get_raw_account_observation(observation_key).await;
+                        result.map_err(|error| return map_postgres_error(error, self.backend_kind, self.network.as_str()))
+                    },
+                };
+            }
+            #[cfg(not(feature = "postgres"))]
+            {
+                let _ = observation_key;
+                return std::result::Result::Err(unavailable_runtime_error(self.backend_kind));
+            }
+        });
+    }
+}
+
+impl ksp_store_api::RawAccountObservationWrite for Store {
+    fn record_raw_account_observation<'a>(
+        &'a self,
+        observation: ksp_store_api::RawAccountObservation,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawObservationWriteOutcome>> {
+        let network_check = validate_operation_network(&self.network, observation.account().network(), self.backend_kind);
+        if let std::result::Result::Err(error) = network_check {
+            return std::boxed::Box::pin(async move {
+                return std::result::Result::Err(error);
+            });
+        }
+        return std::boxed::Box::pin(async move {
+            #[cfg(feature = "postgres")]
+            {
+                return match &self.runtime {
+                    StoreRuntime::Postgres(backend) => {
+                        let result = backend.record_raw_account_observation(observation).await;
+                        result.map_err(|error| return map_postgres_error(error, self.backend_kind, self.network.as_str()))
+                    },
+                };
+            }
+            #[cfg(not(feature = "postgres"))]
+            {
+                let _ = observation;
+                return std::result::Result::Err(unavailable_runtime_error(self.backend_kind));
+            }
+        });
+    }
+}
+
+impl ksp_store_api::RawAccountStateRead for Store {
+    fn get_raw_account_state<'a>(
+        &'a self,
+        reference: &'a ksp_store_api::RawAccountStateReference,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawAccountState>>> {
+        let network_check = validate_operation_network(&self.network, reference.network(), self.backend_kind);
+        if let std::result::Result::Err(error) = network_check {
+            return std::boxed::Box::pin(async move {
+                return std::result::Result::Err(error);
+            });
+        }
+        return std::boxed::Box::pin(async move {
+            #[cfg(feature = "postgres")]
+            {
+                return match &self.runtime {
+                    StoreRuntime::Postgres(backend) => {
+                        let result = backend.get_raw_account_state(reference).await;
+                        result.map_err(|error| return map_postgres_error(error, self.backend_kind, self.network.as_str()))
+                    },
+                };
+            }
+            #[cfg(not(feature = "postgres"))]
+            {
+                let _ = reference;
+                return std::result::Result::Err(unavailable_runtime_error(self.backend_kind));
+            }
+        });
+    }
+
+    fn list_raw_account_states<'a>(
+        &'a self,
+        query: &'a ksp_store_api::RawAccountStateQuery,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawPage<ksp_store_api::RawAccountStateReference>>> {
+        let network_check = validate_operation_network(&self.network, query.network(), self.backend_kind);
+        if let std::result::Result::Err(error) = network_check {
+            return std::boxed::Box::pin(async move {
+                return std::result::Result::Err(error);
+            });
+        }
+        return std::boxed::Box::pin(async move {
+            #[cfg(feature = "postgres")]
+            {
+                return match &self.runtime {
+                    StoreRuntime::Postgres(backend) => {
+                        let result = backend.list_raw_account_states(query).await;
+                        result.map_err(|error| return map_postgres_error(error, self.backend_kind, self.network.as_str()))
+                    },
+                };
+            }
+            #[cfg(not(feature = "postgres"))]
+            {
+                let _ = query;
+                return std::result::Result::Err(unavailable_runtime_error(self.backend_kind));
+            }
+        });
+    }
+}
+
+impl ksp_store_api::RawAccountStateWrite for Store {
+    fn persist_raw_account_acquisition<'a>(
+        &'a self,
+        state: ksp_store_api::RawAccountState,
+        observation: ksp_store_api::RawAccountObservation,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawAcquisitionWriteOutcome>> {
+        let state_network = validate_operation_network(&self.network, state.reference().network(), self.backend_kind);
+        if let std::result::Result::Err(error) = state_network {
+            return std::boxed::Box::pin(async move {
+                return std::result::Result::Err(error);
+            });
+        }
+        let observation_network = validate_operation_network(&self.network, observation.account().network(), self.backend_kind);
+        if let std::result::Result::Err(error) = observation_network {
+            return std::boxed::Box::pin(async move {
+                return std::result::Result::Err(error);
+            });
+        }
+        return std::boxed::Box::pin(async move {
+            #[cfg(feature = "postgres")]
+            {
+                return match &self.runtime {
+                    StoreRuntime::Postgres(backend) => {
+                        let result = backend.persist_raw_account_acquisition(state, observation).await;
+                        result.map_err(|error| return map_postgres_error(error, self.backend_kind, self.network.as_str()))
+                    },
+                };
+            }
+            #[cfg(not(feature = "postgres"))]
+            {
+                let _ = state;
+                let _ = observation;
+                return std::result::Result::Err(unavailable_runtime_error(self.backend_kind));
+            }
+        });
+    }
+}
+
 impl ksp_store_api::RawTransactionRead for Store {
     fn get_raw_transaction<'a>(
         &'a self,

crates/ksp-store-lib/tests/dependency_boundary.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-lib/tests/dependency_boundary.rs
-// version: 7
+// version: 8
 
 #![warn(missing_docs)]
 #![deny(unreachable_pub)]
@@ -60,34 +60,28 @@ fn pre_005_facade_exposes_no_physical_postgres_types_or_environment_bypass() {
 }
 
 #[test]
-fn pre_008_facade_dispatches_six_raw_transaction_capabilities_without_physical_leak() {
+fn pre_008_facade_dispatches_exact_ten_raw_capabilities_without_physical_leak() {
     let store = include_str!("../src/store.rs");
     for required in [
-        "impl ksp_store_api::RawTransactionRead for Store",
-        "impl ksp_store_api::RawTransactionWrite for Store",
+        "impl ksp_store_api::RawAccountObservationRead for Store",
+        "impl ksp_store_api::RawAccountObservationWrite for Store",
+        "impl ksp_store_api::RawAccountStateRead for Store",
+        "impl ksp_store_api::RawAccountStateWrite for Store",
         "impl ksp_store_api::RawTransactionObservationRead for Store",
         "impl ksp_store_api::RawTransactionObservationWrite for Store",
+        "impl ksp_store_api::RawTransactionRead for Store",
         "impl ksp_store_api::RawTransactionRetentionRead for Store",
         "impl ksp_store_api::RawTransactionRetentionWrite for Store",
+        "impl ksp_store_api::RawTransactionWrite for Store",
         "validate_operation_network",
         "StoreRuntime::Postgres(backend)",
         "map_postgres_error",
     ] {
         assert!(store.contains(required), "missing pre.008 Store capability dispatch contract: {required}");
     }
-    for forbidden in [
-        "impl ksp_store_api::RawAccountStateRead for Store",
-        "impl ksp_store_api::RawAccountStateWrite for Store",
-        "impl ksp_store_api::RawAccountObservationRead for Store",
-        "impl ksp_store_api::RawAccountObservationWrite for Store",
-        "tokio_postgres::",
-        "deadpool_postgres::",
-        "CREATE TABLE",
-        "INSERT INTO",
-        "UPDATE ksp_",
-        "DELETE FROM",
-    ] {
-        assert!(!store.contains(forbidden), "pre.008 facade leaked physical or RawAccount scope: {forbidden}");
+    assert_eq!(store.matches("impl ksp_store_api::Raw").count(), 10);
+    for forbidden in ["tokio_postgres::", "deadpool_postgres::", "CREATE TABLE", "INSERT INTO", "UPDATE ksp_", "DELETE FROM"] {
+        assert!(!store.contains(forbidden), "pre.008 facade leaked physical backend material: {forbidden}");
     }
     return;
 }

crates/ksp-store-lib/tests/hardening_completeness.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-lib/tests/hardening_completeness.rs
-// version: 4
+// version: 5
 
 #![warn(missing_docs)]
 #![deny(unreachable_pub)]
@@ -263,27 +263,24 @@ fn pre_009_facade_production_sources_keep_config_env_physical_sql_and_backend_ha
 }
 
 #[test]
-fn pre_010_facade_raw_transaction_capability_inventory_is_exact_and_raw_account_scope_stays_closed() {
+fn pre_010_facade_raw_capability_inventory_is_exactly_ten() {
     let store = include_str!("../src/store.rs");
     let capability_impls = [
-        "impl ksp_store_api::RawTransactionRead for Store",
-        "impl ksp_store_api::RawTransactionWrite for Store",
+        "impl ksp_store_api::RawAccountObservationRead for Store",
+        "impl ksp_store_api::RawAccountObservationWrite for Store",
+        "impl ksp_store_api::RawAccountStateRead for Store",
+        "impl ksp_store_api::RawAccountStateWrite for Store",
         "impl ksp_store_api::RawTransactionObservationRead for Store",
         "impl ksp_store_api::RawTransactionObservationWrite for Store",
+        "impl ksp_store_api::RawTransactionRead for Store",
         "impl ksp_store_api::RawTransactionRetentionRead for Store",
         "impl ksp_store_api::RawTransactionRetentionWrite for Store",
+        "impl ksp_store_api::RawTransactionWrite for Store",
     ];
     for implementation in capability_impls {
         assert_eq!(store.matches(implementation).count(), 1, "unexpected Store capability implementation inventory: {implementation}");
     }
-    for forbidden in [
-        "impl ksp_store_api::RawAccountStateRead for Store",
-        "impl ksp_store_api::RawAccountStateWrite for Store",
-        "impl ksp_store_api::RawAccountObservationRead for Store",
-        "impl ksp_store_api::RawAccountObservationWrite for Store",
-    ] {
-        assert!(!store.contains(forbidden), "RawAccountState scope opened in Store during RawTransaction hardening: {forbidden}");
-    }
-    assert_eq!(store.matches("validate_operation_network(").count(), 9);
+    assert_eq!(store.matches("impl ksp_store_api::Raw").count(), 10);
+    assert_eq!(store.matches("validate_operation_network(").count(), 14);
     return;
 }

crates/ksp-store-lib/tests/public_api.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-lib/tests/public_api.rs
-// version: 7
+// version: 8
 
 #![warn(missing_docs)]
 #![deny(unreachable_pub)]
@@ -74,21 +74,25 @@ fn pre_007_health_and_runtime_snapshot_types_are_portable_crate_root_contracts()
     return;
 }
 
-fn assert_raw_transaction_capabilities<T>()
+fn assert_raw_capabilities<T>()
 where
-    T: ksp_store_lib::RawTransactionRead
-        + ksp_store_lib::RawTransactionWrite
+    T: ksp_store_lib::RawAccountObservationRead
+        + ksp_store_lib::RawAccountObservationWrite
+        + ksp_store_lib::RawAccountStateRead
+        + ksp_store_lib::RawAccountStateWrite
         + ksp_store_lib::RawTransactionObservationRead
         + ksp_store_lib::RawTransactionObservationWrite
+        + ksp_store_lib::RawTransactionRead
         + ksp_store_lib::RawTransactionRetentionRead
-        + ksp_store_lib::RawTransactionRetentionWrite,
+        + ksp_store_lib::RawTransactionRetentionWrite
+        + ksp_store_lib::RawTransactionWrite,
 {
     let _marker = std::marker::PhantomData::<T>;
     return;
 }
 
 #[test]
-fn pre_008_store_facade_implements_all_six_raw_transaction_capabilities() {
-    assert_raw_transaction_capabilities::<ksp_store_lib::Store>();
+fn pre_008_store_facade_implements_exact_raw_capability_set_10_of_10() {
+    assert_raw_capabilities::<ksp_store_lib::Store>();
     return;
 }

crates/ksp-store-postgres-lib/src/lib.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-postgres-lib/src/lib.rs
-// version: 20
+// version: 21
 
 #![warn(missing_docs)]
 #![deny(unreachable_pub)]
@@ -29,8 +29,10 @@
 //! adds backend-private RAW account state/observation read mapping and hostile-row
 //! guards. `0.3.4-pre.005` adds atomic account state+observation acquisition writes
 //! with exact idempotence/conflict classification. `0.3.4-pre.006` adds additional
-//! account observations guarded by the existing state reference while pagination and
-//! all four account trait implementations remain closed.
+//! account observations guarded by the existing state reference. `0.3.4-pre.007` adds
+//! deterministic account keyset pagination with the fixed `KSPA` cursor. `0.3.4-pre.008`
+//! implements the four `RawAccount*` capabilities directly on `PostgresBackend`, completing
+//! the backend RAW capability inventory at ten without exposing physical PostgreSQL types.
 //!
 //! This crate depends on `ksp-store-api` and never on `ksp-store-lib`. The
 //! common facade consumes only this crate's narrow backend bridge and never

crates/ksp-store-postgres-lib/src/runtime.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-postgres-lib/src/runtime.rs
-// version: 14
+// version: 15
 
 const APPLICATION_NAME: &str = "ksp-store";
 const MAX_CONNECTION_URI_BYTES: usize = 4_096;
@@ -469,6 +469,65 @@ impl std::fmt::Debug for PostgresBackend {
     }
 }
 
+impl ksp_store_api::RawAccountObservationRead for PostgresBackend {
+    fn get_raw_account_observation<'a>(
+        &'a self,
+        observation_key: &'a ksp_store_api::RawObservationKey,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawAccountObservation>>> {
+        return std::boxed::Box::pin(async move {
+            let result = PostgresBackend::get_raw_account_observation(self, observation_key).await;
+            return result.map_err(map_capability_error);
+        });
+    }
+}
+
+impl ksp_store_api::RawAccountObservationWrite for PostgresBackend {
+    fn record_raw_account_observation<'a>(
+        &'a self,
+        observation: ksp_store_api::RawAccountObservation,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawObservationWriteOutcome>> {
+        return std::boxed::Box::pin(async move {
+            let result = PostgresBackend::record_raw_account_observation(self, observation).await;
+            return result.map_err(map_capability_error);
+        });
+    }
+}
+
+impl ksp_store_api::RawAccountStateRead for PostgresBackend {
+    fn get_raw_account_state<'a>(
+        &'a self,
+        reference: &'a ksp_store_api::RawAccountStateReference,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawAccountState>>> {
+        return std::boxed::Box::pin(async move {
+            let result = PostgresBackend::get_raw_account_state(self, reference).await;
+            return result.map_err(map_capability_error);
+        });
+    }
+
+    fn list_raw_account_states<'a>(
+        &'a self,
+        query: &'a ksp_store_api::RawAccountStateQuery,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawPage<ksp_store_api::RawAccountStateReference>>> {
+        return std::boxed::Box::pin(async move {
+            let result = PostgresBackend::list_raw_account_states(self, query).await;
+            return result.map_err(map_capability_error);
+        });
+    }
+}
+
+impl ksp_store_api::RawAccountStateWrite for PostgresBackend {
+    fn persist_raw_account_acquisition<'a>(
+        &'a self,
+        state: ksp_store_api::RawAccountState,
+        observation: ksp_store_api::RawAccountObservation,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawAcquisitionWriteOutcome>> {
+        return std::boxed::Box::pin(async move {
+            let result = PostgresBackend::persist_raw_account_acquisition(self, state, observation).await;
+            return result.map_err(map_capability_error);
+        });
+    }
+}
+
 impl ksp_store_api::RawTransactionRead for PostgresBackend {
     fn get_raw_transaction<'a>(
         &'a self,

crates/ksp-store-postgres-lib/tests/dependency_boundary.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-postgres-lib/tests/dependency_boundary.rs
-// version: 22
+// version: 23
 
 #![warn(missing_docs)]
 #![deny(unreachable_pub)]
@@ -54,7 +54,6 @@ fn pre_005_backend_keeps_environment_sql_migrations_and_physical_types_private()
     ] {
         assert!(!crate_root.contains(forbidden), "forbidden PostgreSQL crate-root surface detected: {forbidden}");
     }
-    let runtime = include_str!("../src/runtime.rs");
     for forbidden in [
         "std::env",
         "dotenv",
@@ -126,7 +125,7 @@ fn pre_003_fix_001_migration_engine_uses_split_schema_contract_and_binds_network
 }
 
 #[test]
-fn pre_003_v002_schema_is_complete_without_account_trait_or_write_dispatch() {
+fn pre_003_v002_schema_is_complete_and_keeps_capability_implementation_out_of_schema_layers() {
     let migration = include_str!("../src/migration.rs");
     let schema = include_str!("../src/schema.rs");
     let runtime = include_str!("../src/runtime.rs");
@@ -147,12 +146,13 @@ fn pre_003_v002_schema_is_complete_without_account_trait_or_write_dispatch() {
     assert!(slot_check.contains("slot >= 0 AND slot <= 18446744073709551615"));
     assert!(index.contains("ON ksp_raw_account_states (slot, pubkey, state_hash)"));
     assert!(!index.contains("WHERE"));
-    assert!(!runtime.contains("impl ksp_store_api::RawAccount"));
+    assert!(!migration.contains("impl ksp_store_api::RawAccount"));
+    assert!(!schema.contains("impl ksp_store_api::RawAccount"));
     return;
 }
 
 #[test]
-fn pre_005_raw_account_acquisition_is_atomic_idempotent_and_keeps_destructive_trait_scope_closed() {
+fn pre_005_raw_account_acquisition_is_atomic_idempotent_and_keeps_trait_impls_out_of_sql_module() {
     let crate_root = include_str!("../src/lib.rs");
     let raw = include_str!("../src/raw_account.rs");
     let runtime = include_str!("../src/runtime.rs");
@@ -183,13 +183,14 @@ fn pre_005_raw_account_acquisition_is_atomic_idempotent_and_keeps_destructive_tr
     for forbidden in ["UPDATE ", "DELETE FROM", "ON CONFLICT DO UPDATE", " OFFSET "] {
         assert!(!raw.contains(forbidden), "pre.005 account module contains later/destructive scope: {forbidden}");
     }
-    for forbidden in [
+    for implementation in [
         "impl ksp_store_api::RawAccountStateRead for PostgresBackend",
         "impl ksp_store_api::RawAccountStateWrite for PostgresBackend",
         "impl ksp_store_api::RawAccountObservationRead for PostgresBackend",
         "impl ksp_store_api::RawAccountObservationWrite for PostgresBackend",
     ] {
-        assert!(!runtime.contains(forbidden), "pre.005 opened RawAccount trait scope prematurely: {forbidden}");
+        assert!(!raw.contains(implementation), "account capability implementation leaked into SQL/mapping module: {implementation}");
+        assert_eq!(runtime.matches(implementation).count(), 1, "missing or duplicated account runtime bridge implementation: {implementation}");
     }
     for forbidden in ["std::env", "dotenv", "ksp_store_lib", "ksp_config_lib", "sqlx::", "SELECT *"] {
         assert!(!raw.contains(forbidden), "RAW account module contains forbidden ownership/query material: {forbidden}");
@@ -216,13 +217,14 @@ fn pre_006_raw_account_additional_observation_is_reference_guarded_cancellation_
     for forbidden in ["UPDATE ", "DELETE FROM", "ON CONFLICT DO UPDATE", " OFFSET "] {
         assert!(!raw.contains(forbidden), "pre.006 account module contains later/destructive scope: {forbidden}");
     }
-    for forbidden in [
+    for implementation in [
         "impl ksp_store_api::RawAccountStateRead for PostgresBackend",
         "impl ksp_store_api::RawAccountStateWrite for PostgresBackend",
         "impl ksp_store_api::RawAccountObservationRead for PostgresBackend",
         "impl ksp_store_api::RawAccountObservationWrite for PostgresBackend",
     ] {
-        assert!(!runtime.contains(forbidden), "pre.006 opened RawAccount trait scope prematurely: {forbidden}");
+        assert!(!raw.contains(implementation), "account capability implementation leaked into SQL/mapping module: {implementation}");
+        assert_eq!(runtime.matches(implementation).count(), 1, "missing or duplicated account runtime bridge implementation: {implementation}");
     }
     return;
 }
@@ -368,7 +370,7 @@ fn pre_007_raw_account_pagination_is_keyset_cursor_bound_and_policy_free() {
         "impl ksp_store_api::RawAccountObservationRead for PostgresBackend",
         "impl ksp_store_api::RawAccountObservationWrite for PostgresBackend",
     ] {
-        assert!(!raw.contains(forbidden), "pre.007 opened account trait scope prematurely: {forbidden}");
+        assert!(!raw.contains(forbidden), "account trait implementation leaked into raw account SQL/mapping module: {forbidden}");
     }
     return;
 }
@@ -406,25 +408,22 @@ fn pre_007_raw_retention_is_atomic_compare_and_transition_without_fake_compactio
 }
 
 #[test]
-fn pre_008_backend_trait_implementations_stay_in_runtime_bridge_and_raw_account_scope_stays_closed() {
+fn pre_008_backend_trait_implementations_cover_exact_ten_raw_capabilities_in_runtime_bridge() {
     let runtime = include_str!("../src/runtime.rs");
-    for required in [
-        "impl ksp_store_api::RawTransactionRead for PostgresBackend",
-        "impl ksp_store_api::RawTransactionWrite for PostgresBackend",
-        "impl ksp_store_api::RawTransactionObservationRead for PostgresBackend",
-        "impl ksp_store_api::RawTransactionObservationWrite for PostgresBackend",
-        "impl ksp_store_api::RawTransactionRetentionRead for PostgresBackend",
-        "impl ksp_store_api::RawTransactionRetentionWrite for PostgresBackend",
-    ] {
-        assert!(runtime.contains(required), "missing pre.008 PostgreSQL capability implementation: {required}");
-    }
-    for forbidden in [
-        "impl ksp_store_api::RawAccountStateRead for PostgresBackend",
-        "impl ksp_store_api::RawAccountStateWrite for PostgresBackend",
+    for implementation in [
         "impl ksp_store_api::RawAccountObservationRead for PostgresBackend",
         "impl ksp_store_api::RawAccountObservationWrite for PostgresBackend",
+        "impl ksp_store_api::RawAccountStateRead for PostgresBackend",
+        "impl ksp_store_api::RawAccountStateWrite for PostgresBackend",
+        "impl ksp_store_api::RawTransactionObservationRead for PostgresBackend",
+        "impl ksp_store_api::RawTransactionObservationWrite for PostgresBackend",
+        "impl ksp_store_api::RawTransactionRead for PostgresBackend",
+        "impl ksp_store_api::RawTransactionRetentionRead for PostgresBackend",
+        "impl ksp_store_api::RawTransactionRetentionWrite for PostgresBackend",
+        "impl ksp_store_api::RawTransactionWrite for PostgresBackend",
     ] {
-        assert!(!runtime.contains(forbidden), "pre.008 opened RawAccount capability scope prematurely: {forbidden}");
+        assert_eq!(runtime.matches(implementation).count(), 1, "unexpected PostgreSQL RAW capability inventory: {implementation}");
     }
+    assert_eq!(runtime.matches("impl ksp_store_api::Raw").count(), 10);
     return;
 }

crates/ksp-store-postgres-lib/tests/hardening_completeness.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-postgres-lib/tests/hardening_completeness.rs
-// version: 14
+// version: 15
 
 #![warn(missing_docs)]
 #![deny(unreachable_pub)]
@@ -186,7 +186,7 @@ fn pre_009_backend_error_bridge_cannot_retain_external_error_or_secret_text() {
 }
 
 #[test]
-fn pre_009_backend_has_no_env_bypass_reverse_facade_edge_or_raw_account_trait_implementation() {
+fn pre_009_backend_has_no_env_bypass_reverse_facade_edge_and_keeps_account_impls_in_runtime_bridge() {
     let production = std::format!(
         "{}
 {}
@@ -224,9 +224,8 @@ fn pre_009_backend_has_no_env_bypass_reverse_facade_edge_or_raw_account_trait_im
         "ksp_store_lib",
         "ksp_config_lib",
         "sqlx::",
-        "impl ksp_store_api::RawAccount",
     ] {
-        assert!(!production.contains(forbidden), "forbidden backend ownership/reverse-edge/RawAccount material detected: {forbidden}");
+        assert!(!production.contains(forbidden), "forbidden backend ownership/reverse-edge material detected: {forbidden}");
     }
     let bootstrap_sql = include_str!("../migrations/v000_bootstrap/tables/001_ksp_store_schema_migrations.sql");
     assert!(bootstrap_sql.contains("ksp_store_schema_migrations"));
@@ -262,27 +261,24 @@ fn pre_009_live_raw_transaction_proof_is_opt_in_isolated_and_secret_safe() {
 }
 
 #[test]
-fn pre_010_raw_transaction_capability_implementation_inventory_is_exact_and_raw_account_scope_stays_closed() {
+fn pre_010_raw_capability_implementation_inventory_is_exactly_ten() {
     let runtime = include_str!("../src/runtime.rs");
     let capability_impls = [
-        "impl ksp_store_api::RawTransactionRead for PostgresBackend",
-        "impl ksp_store_api::RawTransactionWrite for PostgresBackend",
+        "impl ksp_store_api::RawAccountObservationRead for PostgresBackend",
+        "impl ksp_store_api::RawAccountObservationWrite for PostgresBackend",
+        "impl ksp_store_api::RawAccountStateRead for PostgresBackend",
+        "impl ksp_store_api::RawAccountStateWrite for PostgresBackend",
         "impl ksp_store_api::RawTransactionObservationRead for PostgresBackend",
         "impl ksp_store_api::RawTransactionObservationWrite for PostgresBackend",
+        "impl ksp_store_api::RawTransactionRead for PostgresBackend",
         "impl ksp_store_api::RawTransactionRetentionRead for PostgresBackend",
         "impl ksp_store_api::RawTransactionRetentionWrite for PostgresBackend",
+        "impl ksp_store_api::RawTransactionWrite for PostgresBackend",
     ];
     for implementation in capability_impls {
         assert_eq!(runtime.matches(implementation).count(), 1, "unexpected PostgreSQL capability implementation inventory: {implementation}");
     }
-    for forbidden in [
-        "impl ksp_store_api::RawAccountStateRead for PostgresBackend",
-        "impl ksp_store_api::RawAccountStateWrite for PostgresBackend",
-        "impl ksp_store_api::RawAccountObservationRead for PostgresBackend",
-        "impl ksp_store_api::RawAccountObservationWrite for PostgresBackend",
-    ] {
-        assert!(!runtime.contains(forbidden), "RawAccountState scope opened during RawTransaction hardening: {forbidden}");
-    }
+    assert_eq!(runtime.matches("impl ksp_store_api::Raw").count(), 10);
     let migration = include_str!("../src/migration.rs");
     assert!(migration.contains("raw_account_state"));
     assert!(migration.contains("crate::V002_RESOURCES"));

crates/ksp-store-postgres-lib/tests/public_api.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-postgres-lib/tests/public_api.rs
-// version: 13
+// version: 14
 
 #![warn(missing_docs)]
 #![deny(unreachable_pub)]
@@ -128,21 +128,25 @@ fn pre_007_raw_retention_write_bridge_uses_backend_independent_transition_and_ou
     return;
 }
 
-fn assert_raw_transaction_capabilities<T>()
+fn assert_raw_capabilities<T>()
 where
-    T: ksp_store_api::RawTransactionRead
-        + ksp_store_api::RawTransactionWrite
+    T: ksp_store_api::RawAccountObservationRead
+        + ksp_store_api::RawAccountObservationWrite
+        + ksp_store_api::RawAccountStateRead
+        + ksp_store_api::RawAccountStateWrite
         + ksp_store_api::RawTransactionObservationRead
         + ksp_store_api::RawTransactionObservationWrite
+        + ksp_store_api::RawTransactionRead
         + ksp_store_api::RawTransactionRetentionRead
-        + ksp_store_api::RawTransactionRetentionWrite,
+        + ksp_store_api::RawTransactionRetentionWrite
+        + ksp_store_api::RawTransactionWrite,
 {
     let _marker = std::marker::PhantomData::<T>;
     return;
 }
 
 #[test]
-fn pre_008_postgres_backend_implements_all_six_raw_transaction_capabilities() {
-    assert_raw_transaction_capabilities::<ksp_store_postgres_lib::PostgresBackend>();
+fn pre_008_postgres_backend_implements_exact_raw_capability_set_10_of_10() {
+    assert_raw_capabilities::<ksp_store_postgres_lib::PostgresBackend>();
     return;
 }