@feltdb/core 0.9.0 → 0.10.0

package/dist/create/server-source/crates/feltdb-server/src/connections.rs

@@ -2,7 +2,7 @@ use crate::{
     key_provider::{
         KeyProvider, KeyProviderHealth, KeyReference, KeyScope, LocalKeyProvider, WrappedKey,
     },
-    principals::PrincipalStore,
+    canonical_principals::CanonicalPrincipalAuthority,
     tenancy::TenancyStore,
 };
 use base64::{engine::general_purpose::STANDARD, Engine};
@@ -659,7 +659,7 @@ impl ConnectionStore {
     }
     pub fn execution_context(
         &self,
-        principals: &PrincipalStore,
+        principals: &CanonicalPrincipalAuthority,
         worker_id: &str,
         workload_id: &str,
         connection_ids: &[String],
@@ -862,7 +862,7 @@ mod tests {
             Ok(())
         }
     }
-    fn setup() -> (TenancyStore, PrincipalStore, ConnectionStore, String) {
+    fn setup() -> (TenancyStore, CanonicalPrincipalAuthority, ConnectionStore, String) {
         let suffix = id("test");
         let tenancy =
             TenancyStore::load(std::env::temp_dir().join(format!("{suffix}-tenant.json"))).unwrap();
@@ -872,9 +872,12 @@ mod tests {
         let app = tenancy
             .create_application("owner", &tenant.id, "App")
             .unwrap();
-        let principals =
-            PrincipalStore::load(std::env::temp_dir().join(format!("{suffix}-principals.json")))
-                .unwrap();
+        let principals = CanonicalPrincipalAuthority::new(
+            feltdb::FeltDb::open(
+                std::env::temp_dir().join(format!("{suffix}-principal-authority.log")),
+            )
+            .unwrap(),
+        );
         let connections = ConnectionStore::load(
             std::env::temp_dir().join(format!("{suffix}-connections.json")),
             [7u8; 32],

package/dist/create/server-source/crates/feltdb-server/src/control_plane.rs

@@ -45,6 +45,7 @@ use feltdb::state_model::{
 use feltdb::{Operation, OperationType};
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
+use sha2::{Digest, Sha256};
 
 // ============================================================================
 // Declared capabilities
@@ -471,9 +472,61 @@ pub fn capabilities() -> Value {
         "contract": "feltdb.control-plane.capabilities",
         "version": 1,
         "capabilities": CAPABILITIES,
+        "public_contract": {
+            "contract": "feltdb.public.substrate",
+            "contract_version": "1.0",
+            "cursor_format_version": "fh1",
+            "stored_state_schema_version": 1,
+            "migration_version": "0.10A",
+            "capabilities": public_substrate_capabilities(),
+        },
     })
 }
 
+/// Stable fingerprint of the public substrate declaration served to clients.
+///
+/// Release certification compares this value with the live deployment. It is
+/// derived from the declaration itself so a capability change cannot retain a
+/// stale, hand-maintained release marker.
+pub fn public_contract_capability_fingerprint() -> String {
+    let declaration = capabilities();
+    let public = &declaration["public_contract"];
+    format!(
+        "sha256:{:x}",
+        Sha256::digest(serde_json::to_vec(public).expect("public contract serializes"))
+    )
+}
+
+fn public_substrate_capabilities() -> Value {
+    let capability = |name: &str, transports: &[&str], scope: &str, durability: &str| {
+        json!({
+            "capability": name,
+            "contract_version": "1.0",
+            "support": "supported",
+            "supported_transport": transports,
+            "scope_requirements": scope,
+            "durability_semantics": durability,
+            "authority_owner": "canonical_feltdb",
+        })
+    };
+    json!([
+        capability("state", &["rust", "http", "sdk", "indexeddb"], "tenant+application", "commit-before-success except memory"),
+        capability("transactions", &["rust", "http", "sdk", "indexeddb"], "tenant+application", "atomic canonical commit"),
+        capability("cas", &["rust", "http", "sdk", "indexeddb"], "tenant+application+record", "authority-owned record version"),
+        capability("history", &["rust", "http", "sdk"], "tenant+application", "canonical transaction/revision history"),
+        capability("refs", &["rust"], "namespace+name", "durable-object CAS"),
+        capability("materialization", &["rust"], "durable object/revision", "projection only"),
+        capability("durable_objects", &["rust"], "backend key", "durable backend is authoritative"),
+        capability("principals", &["rust", "http", "sdk"], "tenant+application", "canonical principal transaction"),
+        capability("durable_work", &["rust", "http", "sdk"], "tenant+application", "canonical CAS-protected aggregate"),
+        capability("events", &["rust", "http", "sdk"], "authority+tenant+application", "projection of committed history"),
+        capability("opaque_cursors", &["http", "sdk"], "authority+tenant+application", "restartable scoped history position"),
+        capability("provenance", &["rust", "http", "sdk"], "tenant+application", "complete canonical history"),
+        capability("recovery", &["rust", "http", "sdk", "indexeddb"], "authority", "fresh-process reconstruction"),
+        capability("capability_discovery", &["http", "sdk"], "authenticated authority", "generated declaration"),
+    ])
+}
+
 // ============================================================================
 // State model projections
 // ============================================================================
@@ -770,6 +823,43 @@ mod tests {
         }
     }
 
+    #[test]
+    fn public_substrate_declaration_is_complete_and_semantic() {
+        let declaration = capabilities();
+        let public = &declaration["public_contract"];
+        assert_eq!(public["contract"], json!("feltdb.public.substrate"));
+        assert_eq!(public["contract_version"], json!("1.0"));
+        assert_eq!(public["cursor_format_version"], json!("fh1"));
+        let entries = public["capabilities"].as_array().unwrap();
+        let names = entries
+            .iter()
+            .map(|entry| entry["capability"].as_str().unwrap())
+            .collect::<std::collections::BTreeSet<_>>();
+        for required in [
+            "state", "transactions", "cas", "history", "refs", "materialization",
+            "durable_objects", "principals", "durable_work", "events", "opaque_cursors",
+            "provenance", "recovery", "capability_discovery",
+        ] {
+            assert!(names.contains(required), "missing public capability {required}");
+        }
+        for entry in entries {
+            assert_eq!(entry["support"], json!("supported"));
+            assert_eq!(entry["authority_owner"], json!("canonical_feltdb"));
+            assert!(!entry["supported_transport"].as_array().unwrap().is_empty());
+            assert!(!entry["scope_requirements"].as_str().unwrap().is_empty());
+            assert!(!entry["durability_semantics"].as_str().unwrap().is_empty());
+        }
+    }
+
+    #[test]
+    fn public_capability_fingerprint_is_derived_and_stable() {
+        let first = public_contract_capability_fingerprint();
+        let second = public_contract_capability_fingerprint();
+        assert_eq!(first, second);
+        assert!(first.starts_with("sha256:"));
+        assert_eq!(first.len(), "sha256:".len() + 64);
+    }
+
     #[test]
     fn a_path_survives_the_round_trip_with_its_component_kinds() {
         let path = vec![

package/dist/create/server-source/crates/feltdb-server/src/lib.rs

@@ -6,6 +6,7 @@ pub mod auth;
 pub mod authenticated_principal;
 pub mod authorization;
 pub mod backup;
+pub mod canonical_principals;
 pub mod causal;
 pub mod certification;
 pub mod certification_harness;