@feltdb/core 0.4.12 → 0.4.13

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

@@ -0,0 +1,1086 @@
+use feltdb::FeltDb;
+use serde_json::Value;
+use std::sync::Arc;
+use wasm_bindgen::prelude::*;
+
+/// Canonicalizes a typed application manifest using the same Rust implementation
+/// used by the server. JavaScript never defines revision identity independently.
+#[wasm_bindgen]
+pub fn canonicalize_application_manifest(input: &str) -> std::result::Result<String, JsValue> {
+    let manifest: feltdb::application::ApplicationManifest =
+        serde_json::from_str(input).map_err(|error| JsValue::from_str(&error.to_string()))?;
+    let bytes = feltdb::application::canonical_bytes(&manifest)
+        .map_err(|error| JsValue::from_str(&error))?;
+    String::from_utf8(bytes).map_err(|error| JsValue::from_str(&error.to_string()))
+}
+
+#[wasm_bindgen]
+pub fn hash_application_manifest(input: &str) -> std::result::Result<String, JsValue> {
+    let manifest: feltdb::application::ApplicationManifest =
+        serde_json::from_str(input).map_err(|error| JsValue::from_str(&error.to_string()))?;
+    feltdb::application::manifest_hash(&manifest).map_err(|error| JsValue::from_str(&error))
+}
+
+#[wasm_bindgen]
+pub fn resolve_application_runtime(
+    revision: &str,
+    environment: &str,
+) -> std::result::Result<String, JsValue> {
+    let revision: feltdb::application::ApplicationRevision =
+        serde_json::from_str(revision).map_err(|error| JsValue::from_str(&error.to_string()))?;
+    let contract =
+        feltdb::application_runtime::resolve_runtime(&revision, environment, &Default::default())
+            .map_err(|report| {
+            JsValue::from_str(
+                &serde_json::to_string(&report)
+                    .unwrap_or_else(|_| "runtime resolution failed".into()),
+            )
+        })?;
+    serde_json::to_string(&contract).map_err(|error| JsValue::from_str(&error.to_string()))
+}
+
+#[wasm_bindgen]
+pub fn hash_application_runtime(
+    revision: &str,
+    environment: &str,
+) -> std::result::Result<String, JsValue> {
+    let revision: feltdb::application::ApplicationRevision =
+        serde_json::from_str(revision).map_err(|error| JsValue::from_str(&error.to_string()))?;
+    let contract =
+        feltdb::application_runtime::resolve_runtime(&revision, environment, &Default::default())
+            .map_err(|report| {
+            JsValue::from_str(
+                &serde_json::to_string(&report)
+                    .unwrap_or_else(|_| "runtime resolution failed".into()),
+            )
+        })?;
+    feltdb::application_runtime::runtime_hash(&contract).map_err(|error| JsValue::from_str(&error))
+}
+
+#[wasm_bindgen]
+pub fn diff_application_revisions(
+    from: Option<String>,
+    to: &str,
+) -> std::result::Result<String, JsValue> {
+    let before = from
+        .as_deref()
+        .map(serde_json::from_str::<feltdb::application::ApplicationRevision>)
+        .transpose()
+        .map_err(|error| JsValue::from_str(&error.to_string()))?;
+    let after: feltdb::application::ApplicationRevision =
+        serde_json::from_str(to).map_err(|error| JsValue::from_str(&error.to_string()))?;
+    let diff = feltdb::application::application_revision_diff(before.as_ref(), &after)
+        .map_err(|error| JsValue::from_str(&error))?;
+    serde_json::to_string(&diff).map_err(|error| JsValue::from_str(&error.to_string()))
+}
+
+#[wasm_bindgen]
+pub fn validate_state_schema(schema: &str) -> std::result::Result<String, JsValue> {
+    let schema: feltdb::state_contract::StateSchema =
+        serde_json::from_str(schema).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    serde_json::to_string(&feltdb::state_contract::validate_schema(&schema))
+        .map_err(|e| JsValue::from_str(&e.to_string()))
+}
+#[wasm_bindgen]
+pub fn hash_state_schema(schema: &str) -> std::result::Result<String, JsValue> {
+    let schema: feltdb::state_contract::StateSchema =
+        serde_json::from_str(schema).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    feltdb::state_contract::schema_hash(&schema).map_err(|e| JsValue::from_str(&e))
+}
+#[wasm_bindgen]
+pub fn compare_state_schemas(before: &str, after: &str) -> std::result::Result<String, JsValue> {
+    let before: feltdb::state_contract::StateSchema =
+        serde_json::from_str(before).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let after: feltdb::state_contract::StateSchema =
+        serde_json::from_str(after).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    serde_json::to_string(&feltdb::state_contract::compare_schemas(&before, &after))
+        .map_err(|e| JsValue::from_str(&e.to_string()))
+}
+
+/// Verify a portable signed grant with the exact Rust canonicalization used by
+/// the server. The verification key is provisioned with the offline app shell.
+#[wasm_bindgen]
+pub fn verify_signed_grant(
+    signed_grant: &str,
+    key_id: &str,
+    verification_key: &str,
+    request: &str,
+    grant_chain: &str,
+    revocations: &str,
+) -> std::result::Result<String, JsValue> {
+    use feltdb::authorization::{AuthorizationRequest, GrantSigner, RevocationState, SignedGrant};
+    use std::collections::BTreeMap;
+    let signed: SignedGrant =
+        serde_json::from_str(signed_grant).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let request: AuthorizationRequest =
+        serde_json::from_str(request).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let grants: BTreeMap<String, SignedGrant> =
+        serde_json::from_str(grant_chain).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let revoked: RevocationState =
+        serde_json::from_str(revocations).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let signer = GrantSigner::verifier_hex(key_id, verification_key)
+        .map_err(|e| JsValue::from_str(&e.to_string()))?;
+    feltdb::authorization::verify_grant(&signed, &signer, &request, &grants, &revoked).map_err(
+        |e| JsValue::from_str(&serde_json::to_string(&e).unwrap_or_else(|_| e.to_string())),
+    )?;
+    Ok(signed
+        .grant
+        .digest()
+        .map_err(|e| JsValue::from_str(&e.to_string()))?)
+}
+
+#[wasm_bindgen]
+pub fn authorize_offline(
+    signed_grant: &str,
+    key_id: &str,
+    verification_key: &str,
+    request: &str,
+    grant_chain: &str,
+    revocations: &str,
+) -> std::result::Result<String, JsValue> {
+    use feltdb::authorization::{AuthorizationRequest, GrantSigner, RevocationState, SignedGrant};
+    use std::collections::BTreeMap;
+    let signed: SignedGrant =
+        serde_json::from_str(signed_grant).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let request: AuthorizationRequest =
+        serde_json::from_str(request).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let grants: BTreeMap<String, SignedGrant> =
+        serde_json::from_str(grant_chain).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let revoked: RevocationState =
+        serde_json::from_str(revocations).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let signer = GrantSigner::verifier_hex(key_id, verification_key)
+        .map_err(|e| JsValue::from_str(&e.to_string()))?;
+    serde_json::to_string(&feltdb::authorization::authorize(
+        &request,
+        Some(&signed),
+        &signer,
+        &grants,
+        &revoked,
+    ))
+    .map_err(|e| JsValue::from_str(&e.to_string()))
+}
+
+#[wasm_bindgen]
+pub fn validate_sync_operation(operation: &str) -> std::result::Result<String, JsValue> {
+    let operation: feltdb::sync_contract::SyncOperation =
+        serde_json::from_str(operation).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    operation.validate_identity().map_err(|e| {
+        JsValue::from_str(&serde_json::to_string(&e).unwrap_or_else(|_| e.to_string()))
+    })?;
+    Ok(operation.hash())
+}
+
+#[wasm_bindgen]
+pub fn apply_sync_result(
+    local_runtime: &str,
+    result: &str,
+) -> std::result::Result<String, JsValue> {
+    use feltdb::sync_contract::{OutboxStatus, SyncResult};
+    use std::collections::BTreeMap;
+    let mut outbox: BTreeMap<String, OutboxStatus> =
+        serde_json::from_str(local_runtime).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let result: SyncResult =
+        serde_json::from_str(result).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    for ack in result.acknowledgements {
+        outbox.insert(ack.operation_id, OutboxStatus::Acknowledged);
+    }
+    for rejection in result.rejections {
+        outbox.insert(
+            rejection.operation_id,
+            if rejection.retryable {
+                OutboxStatus::Retryable
+            } else {
+                OutboxStatus::Rejected
+            },
+        );
+    }
+    for conflict in result.conflicts {
+        outbox.insert(conflict.operation_id, OutboxStatus::Conflicted);
+    }
+    serde_json::to_string(&outbox).map_err(|e| JsValue::from_str(&e.to_string()))
+}
+
+#[wasm_bindgen]
+pub fn validate_workload_transition(from: &str, to: &str) -> std::result::Result<bool, JsValue> {
+    let from: feltdb::workload::WorkloadState = serde_json::from_str(&format!("\"{from}\""))
+        .map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let to: feltdb::workload::WorkloadState = serde_json::from_str(&format!("\"{to}\""))
+        .map_err(|e| JsValue::from_str(&e.to_string()))?;
+    Ok(feltdb::workload::can_transition(from, to))
+}
+
+#[wasm_bindgen]
+pub fn validate_worker_transition(from: &str, to: &str) -> std::result::Result<bool, JsValue> {
+    let from: feltdb::worker_mesh::WorkerLifecycle =
+        serde_json::from_str(&format!("\"{from}\""))
+            .map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let to: feltdb::worker_mesh::WorkerLifecycle = serde_json::from_str(&format!("\"{to}\""))
+        .map_err(|e| JsValue::from_str(&e.to_string()))?;
+    Ok(feltdb::worker_mesh::worker_transition(from, to))
+}
+
+#[wasm_bindgen]
+pub fn validate_mesh_claim(
+    claim: &str,
+    worker: &str,
+    workload: &str,
+    now: i64,
+) -> std::result::Result<(), JsValue> {
+    let claim: feltdb::worker_mesh::MeshExecutionClaim =
+        serde_json::from_str(claim).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let worker: feltdb::worker_mesh::Worker =
+        serde_json::from_str(worker).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let workload: feltdb::workload::Workload =
+        serde_json::from_str(workload).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    feltdb::worker_mesh::validate_mesh_claim(&claim, &worker, &workload, now).map_err(|e| {
+        JsValue::from_str(&serde_json::to_string(&e).unwrap_or_else(|_| e.to_string()))
+    })
+}
+
+/// Wrapper around FeltDb for JavaScript interop
+#[wasm_bindgen]
+pub struct JsDb {
+    db: Arc<FeltDb>,
+}
+
+/// Result type for WASM operations
+#[wasm_bindgen]
+pub struct JsResult {
+    success: bool,
+    data: Option<String>,
+    error: Option<String>,
+}
+
+#[wasm_bindgen]
+impl JsResult {
+    #[wasm_bindgen(getter)]
+    pub fn success(&self) -> bool {
+        self.success
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn data(&self) -> Option<String> {
+        self.data.clone()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn error(&self) -> Option<String> {
+        self.error.clone()
+    }
+}
+
+fn feltdb_error_to_js(err: feltdb::FlowError) -> JsValue {
+    JsValue::from_str(&format!("FeltDB error: {}", err))
+}
+
+/// Opens or creates a FeltDB database
+///
+/// # Arguments
+/// * `path` - Path to the database file
+///
+/// # Returns
+/// JsDb instance or error
+#[wasm_bindgen]
+pub fn open(path: &str) -> std::result::Result<JsDb, JsValue> {
+    let db = FeltDb::open(path).map_err(feltdb_error_to_js)?;
+    Ok(JsDb { db: Arc::new(db) })
+}
+
+#[wasm_bindgen]
+impl JsDb {
+    pub fn execute_canonical_query(
+        &self,
+        schema: &str,
+        authorization: &str,
+        state_namespace: &str,
+        query: &str,
+    ) -> JsResult {
+        let result = (|| {
+            let schema: feltdb::state_contract::StateSchema =
+                serde_json::from_str(schema).map_err(|e| e.to_string())?;
+            let authorization: feltdb::state_contract::AuthorizationContext =
+                serde_json::from_str(authorization).map_err(|e| e.to_string())?;
+            let query: feltdb::state_contract::CanonicalQuery =
+                serde_json::from_str(query).map_err(|e| e.to_string())?;
+            let context = feltdb::state_contract::begin_read(
+                &self.db,
+                &schema,
+                state_namespace,
+                authorization,
+            )
+            .map_err(|e| serde_json::to_string(&e).unwrap_or(e.message))?;
+            feltdb::state_contract::execute_query(&self.db, &schema, &context, &query)
+                .map_err(|e| serde_json::to_string(&e).unwrap_or(e.message))
+        })()
+        .and_then(|v| serde_json::to_string(&v).map_err(|e| e.to_string()));
+        match result {
+            Ok(data) => JsResult {
+                success: true,
+                data: Some(data),
+                error: None,
+            },
+            Err(error) => JsResult {
+                success: false,
+                data: None,
+                error: Some(error),
+            },
+        }
+    }
+    pub fn execute_canonical_transaction(&self, schema: &str, request: &str) -> JsResult {
+        let result = (|| {
+            let schema: feltdb::state_contract::StateSchema =
+                serde_json::from_str(schema).map_err(|e| e.to_string())?;
+            let request: feltdb::state_contract::TransactionRequest =
+                serde_json::from_str(request).map_err(|e| e.to_string())?;
+            feltdb::state_contract::execute_transaction(&self.db, &schema, &request)
+                .map_err(|e| serde_json::to_string(&e).unwrap_or(e.message))
+        })()
+        .and_then(|v| serde_json::to_string(&v).map_err(|e| e.to_string()));
+        match result {
+            Ok(data) => JsResult {
+                success: true,
+                data: Some(data),
+                error: None,
+            },
+            Err(error) => JsResult {
+                success: false,
+                data: None,
+                error: Some(error),
+            },
+        }
+    }
+    /// Insert a record into the database
+    ///
+    /// # Arguments
+    /// * `key` - Key for the record (e.g., "users:123")
+    /// * `value` - JSON object as a string
+    ///
+    /// # Returns
+    /// JsResult with success status
+    pub fn insert(&self, key: &str, value: &str) -> JsResult {
+        match serde_json::from_str::<Value>(value) {
+            Ok(json_value) => match self.db.insert(key, &json_value) {
+                Ok(_) => JsResult {
+                    success: true,
+                    data: Some(key.to_string()),
+                    error: None,
+                },
+                Err(e) => JsResult {
+                    success: false,
+                    data: None,
+                    error: Some(format!("Insert failed: {}", e)),
+                },
+            },
+            Err(e) => JsResult {
+                success: false,
+                data: None,
+                error: Some(format!("Invalid JSON: {}", e)),
+            },
+        }
+    }
+
+    /// Update an existing record through the canonical update operation.
+    pub fn update(&self, key: &str, value: &str) -> JsResult {
+        match serde_json::from_str::<Value>(value) {
+            Ok(json_value) => match self.db.update(key, &json_value) {
+                Ok(_) => JsResult {
+                    success: true,
+                    data: Some(key.to_string()),
+                    error: None,
+                },
+                Err(e) => JsResult {
+                    success: false,
+                    data: None,
+                    error: Some(format!("Update failed: {}", e)),
+                },
+            },
+            Err(e) => JsResult {
+                success: false,
+                data: None,
+                error: Some(format!("Invalid JSON: {}", e)),
+            },
+        }
+    }
+
+    /// Delete a record from the database.
+    pub fn delete(&self, key: &str) -> JsResult {
+        match self.db.delete(key) {
+            Ok(_) => JsResult {
+                success: true,
+                data: Some(key.to_string()),
+                error: None,
+            },
+            Err(e) => JsResult {
+                success: false,
+                data: None,
+                error: Some(format!("Delete failed: {}", e)),
+            },
+        }
+    }
+
+    /// Retrieve a record from the database
+    ///
+    /// # Arguments
+    /// * `key` - Key for the record
+    ///
+    /// # Returns
+    /// JSON string of the record or error
+    pub fn get(&self, key: &str) -> JsResult {
+        match self.db.get::<Value>(key) {
+            Ok(Some(value)) => JsResult {
+                success: true,
+                data: Some(value.to_string()),
+                error: None,
+            },
+            Ok(None) => JsResult {
+                success: true,
+                data: None,
+                error: None,
+            },
+            Err(e) => JsResult {
+                success: false,
+                data: None,
+                error: Some(format!("Get failed: {}", e)),
+            },
+        }
+    }
+
+    /// Query records in the database with a predicate
+    ///
+    /// For now, this returns all records of a given type namespace as a simplified implementation.
+    /// The full closure-based predicate from Rust cannot be directly represented in WASM bindings.
+    ///
+    /// # Arguments
+    /// * `capability` - Capability/namespace to query (e.g., "users")
+    ///
+    /// # Returns
+    /// JSON array string of matching records
+    pub fn query(&self, capability: &str) -> JsResult {
+        // Get the capability and find all records in it
+        let cap = self.db.capability(capability);
+        match cap.find::<Value, _>(|_| true) {
+            Ok(values) => {
+                let json_array = Value::Array(values);
+                JsResult {
+                    success: true,
+                    data: Some(json_array.to_string()),
+                    error: None,
+                }
+            }
+            Err(e) => JsResult {
+                success: false,
+                data: None,
+                error: Some(format!("Query failed: {}", e)),
+            },
+        }
+    }
+
+    /// Get all records in a capability namespace
+    ///
+    /// # Arguments
+    /// * `capability` - Capability/namespace name
+    ///
+    /// # Returns
+    /// JSON array string of all records in the capability
+    pub fn get_capability_records(&self, capability: &str) -> JsResult {
+        let cap = self.db.capability(capability);
+        match cap.find::<Value, _>(|_| true) {
+            Ok(values) => {
+                let json_array = Value::Array(values);
+                JsResult {
+                    success: true,
+                    data: Some(json_array.to_string()),
+                    error: None,
+                }
+            }
+            Err(e) => JsResult {
+                success: false,
+                data: None,
+                error: Some(format!("Get capability records failed: {}", e)),
+            },
+        }
+    }
+
+    /// Check if a type is auto-indexed
+    ///
+    /// # Returns
+    /// Whether the default (generic JSON) type is auto-indexed
+    pub fn is_auto_indexed(&self) -> bool {
+        self.db.is_auto_indexed::<Value>()
+    }
+
+    /// Get current sync state information
+    ///
+    /// # Returns
+    /// JSON string containing sync state metrics
+    pub fn sync_info(&self) -> JsResult {
+        match self.db.sync_info() {
+            Ok(sync_state) => match serde_json::to_string(&sync_state) {
+                Ok(json) => JsResult {
+                    success: true,
+                    data: Some(json),
+                    error: None,
+                },
+                Err(e) => JsResult {
+                    success: false,
+                    data: None,
+                    error: Some(format!("Serialization failed: {}", e)),
+                },
+            },
+            Err(e) => JsResult {
+                success: false,
+                data: None,
+                error: Some(format!("Sync info failed: {}", e)),
+            },
+        }
+    }
+
+    /// Add a peer for synchronization
+    ///
+    /// # Arguments
+    /// * `peer_id` - Unique identifier for the peer
+    ///
+    /// # Returns
+    /// JsResult with success status
+    pub fn add_sync_peer(&self, peer_id: &str) -> JsResult {
+        match self.db.add_sync_peer(peer_id.to_string()) {
+            Ok(_) => JsResult {
+                success: true,
+                data: Some(format!("Added peer: {}", peer_id)),
+                error: None,
+            },
+            Err(e) => JsResult {
+                success: false,
+                data: None,
+                error: Some(format!("Add peer failed: {}", e)),
+            },
+        }
+    }
+
+    /// Remove a peer from synchronization
+    ///
+    /// # Arguments
+    /// * `peer_id` - Unique identifier for the peer
+    ///
+    /// # Returns
+    /// JsResult with success status
+    pub fn remove_sync_peer(&self, peer_id: &str) -> JsResult {
+        match self.db.remove_sync_peer(peer_id) {
+            Ok(_) => JsResult {
+                success: true,
+                data: Some(format!("Removed peer: {}", peer_id)),
+                error: None,
+            },
+            Err(e) => JsResult {
+                success: false,
+                data: None,
+                error: Some(format!("Remove peer failed: {}", e)),
+            },
+        }
+    }
+
+    /// Get pending operations for a peer since a given sequence
+    ///
+    /// # Arguments
+    /// * `peer_id` - Unique identifier for the peer
+    /// * `since_sequence` - Get operations after this sequence number
+    ///
+    /// # Returns
+    /// JSON array of operations as a string
+    pub fn get_pending_for_peer(&self, peer_id: &str, since_sequence: u64) -> JsResult {
+        match self.db.get_pending_for_peer(peer_id, since_sequence) {
+            Ok(operations) => match serde_json::to_string(&operations) {
+                Ok(json) => JsResult {
+                    success: true,
+                    data: Some(json),
+                    error: None,
+                },
+                Err(e) => JsResult {
+                    success: false,
+                    data: None,
+                    error: Some(format!("Serialization failed: {}", e)),
+                },
+            },
+            Err(e) => JsResult {
+                success: false,
+                data: None,
+                error: Some(format!("Get pending failed: {}", e)),
+            },
+        }
+    }
+
+    /// Acknowledge receipt of operations from a peer
+    ///
+    /// # Arguments
+    /// * `peer_id` - Unique identifier for the peer
+    /// * `sequence` - Acknowledge operations up to this sequence number
+    ///
+    /// # Returns
+    /// JsResult with success status
+    pub fn acknowledge_peer_operations(&self, peer_id: &str, sequence: u64) -> JsResult {
+        match self
+            .db
+            .acknowledge_peer_operations(peer_id.to_string(), sequence)
+        {
+            Ok(_) => JsResult {
+                success: true,
+                data: Some(format!("Acknowledged sequence {}", sequence)),
+                error: None,
+            },
+            Err(e) => JsResult {
+                success: false,
+                data: None,
+                error: Some(format!("Acknowledgement failed: {}", e)),
+            },
+        }
+    }
+
+    /// Get the instance ID for this FeltDB instance
+    ///
+    /// # Returns
+    /// The unique instance ID as a string
+    pub fn instance_id(&self) -> String {
+        self.db
+            .instance_id()
+            .unwrap_or_else(|_| "unknown".to_string())
+    }
+
+    /// Get the current sequence number for this instance
+    ///
+    /// # Returns
+    /// The current sequence number
+    pub fn get_sequence(&self) -> u64 {
+        self.db.sequence().unwrap_or(0)
+    }
+}
+
+// Note: Live queries require async/await support which requires special handling in WASM.
+// For now, the synchronous query methods above are sufficient for frontend integration.
+// Live query subscriptions can be added using a message-passing pattern or WebWorkers.
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_namespace = console)]
+    fn log(s: &str);
+}
+
+fn canonical_json(value: &serde_json::Value) -> serde_json::Value {
+    match value {
+        serde_json::Value::Object(map) => serde_json::Value::Object(
+            map.iter()
+                .map(|(k, v)| (k.clone(), canonical_json(v)))
+                .collect::<std::collections::BTreeMap<_, _>>()
+                .into_iter()
+                .collect(),
+        ),
+        serde_json::Value::Array(values) => {
+            serde_json::Value::Array(values.iter().map(canonical_json).collect())
+        }
+        value => value.clone(),
+    }
+}
+#[wasm_bindgen]
+pub fn canonical_bundle_hash(bundle_json: &str) -> Result<String, JsValue> {
+    use sha2::{Digest, Sha256};
+    let value: serde_json::Value =
+        serde_json::from_str(bundle_json).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let bytes = serde_json::to_vec(&canonical_json(&value))
+        .map_err(|e| JsValue::from_str(&e.to_string()))?;
+    Ok(format!("sha256:{:x}", Sha256::digest(bytes)))
+}
+#[wasm_bindgen]
+pub fn verify_bundle_integrity(bundle_json: &str) -> Result<bool, JsValue> {
+    use sha2::{Digest, Sha256};
+    let value: serde_json::Value =
+        serde_json::from_str(bundle_json).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    if value.get("format").and_then(|v| v.as_str()) != Some("feltdb-bundle/v1") {
+        return Ok(false);
+    }
+    let checksums = value
+        .get("checksums")
+        .ok_or_else(|| JsValue::from_str("checksums missing"))?;
+    let bytes = serde_json::to_vec(&canonical_json(checksums))
+        .map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let root = format!("sha256:{:x}", Sha256::digest(bytes));
+    Ok(value
+        .pointer("/bundle/integrity_root")
+        .and_then(|v| v.as_str())
+        == Some(&root))
+}
+
+/// High-performance index manager for collections.
+/// Wraps Rust IndexManager for optimal query performance.
+#[wasm_bindgen]
+pub struct WasmIndexManager {
+    manager: feltdb::IndexManager,
+}
+
+#[wasm_bindgen]
+impl WasmIndexManager {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> WasmIndexManager {
+        WasmIndexManager {
+            manager: feltdb::IndexManager::new(),
+        }
+    }
+
+    /// Create a new index on the collection.
+    #[wasm_bindgen]
+    pub fn create_index(&mut self, config: &str) -> Result<(), JsValue> {
+        let index_config: feltdb::IndexConfig =
+            serde_json::from_str(config).map_err(|e| JsValue::from_str(&e.to_string()))?;
+        self.manager.create_index(index_config)
+            .map_err(|e| JsValue::from_str(&e))
+    }
+
+    /// Update a record's index entries.
+    #[wasm_bindgen]
+    pub fn update_record(
+        &mut self,
+        record_id: &str,
+        old_value: Option<String>,
+        new_value: &str,
+    ) -> Result<(), JsValue> {
+        self.manager
+            .update_record(record_id, old_value.as_deref(), new_value)
+            .map_err(|e| JsValue::from_str(&e))
+    }
+
+    /// Query an index.
+    #[wasm_bindgen]
+    pub fn query_index(
+        &mut self,
+        index_name: &str,
+        operator: &str,
+        value: &str,
+    ) -> Result<String, JsValue> {
+        let results = self.manager
+            .query_index(index_name, operator, value)
+            .map_err(|e| JsValue::from_str(&e))?;
+        serde_json::to_string(&results).map_err(|e| JsValue::from_str(&e.to_string()))
+    }
+
+    /// List all indexes.
+    #[wasm_bindgen]
+    pub fn list_indexes(&self) -> Result<String, JsValue> {
+        let indexes = self.manager.list_indexes();
+        serde_json::to_string(&indexes).map_err(|e| JsValue::from_str(&e.to_string()))
+    }
+
+    /// Get statistics for an index.
+    #[wasm_bindgen]
+    pub fn get_stats(&self, name: &str) -> Result<String, JsValue> {
+        let stats = self.manager
+            .get_stats(name)
+            .ok_or_else(|| JsValue::from_str("Index not found"))?;
+        serde_json::to_string(&stats).map_err(|e| JsValue::from_str(&e.to_string()))
+    }
+}
+
+/// Shard manager for horizontal scaling.
+/// Distributes data across shards and handles rebalancing.
+#[wasm_bindgen]
+pub struct WasmShardManager {
+    manager: feltdb::ShardManager,
+}
+
+#[wasm_bindgen]
+impl WasmShardManager {
+    #[wasm_bindgen(constructor)]
+    pub fn new(shard_field: &str, strategy: &str) -> WasmShardManager {
+        let sharding_key = feltdb::ShardKey {
+            field: shard_field.to_string(),
+            hash_function: "xxhash".to_string(),
+        };
+
+        let strat = match strategy {
+            "range" => feltdb::ShardingStrategy::RangeBasedHash,
+            "modulo" => feltdb::ShardingStrategy::KeyModulo,
+            _ => feltdb::ShardingStrategy::ConsistentHash,
+        };
+
+        WasmShardManager {
+            manager: feltdb::ShardManager::new(sharding_key, strat),
+        }
+    }
+
+    /// Initialize shards
+    #[wasm_bindgen]
+    pub fn initialize_shards(&mut self, shard_ids_json: &str) -> Result<(), JsValue> {
+        let shard_ids: Vec<String> = serde_json::from_str(shard_ids_json)
+            .map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+        let shard_ids: Vec<_> = shard_ids
+            .into_iter()
+            .map(|id| feltdb::ShardId(id))
+            .collect();
+
+        self.manager
+            .initialize_shards(shard_ids, std::collections::HashMap::new());
+        Ok(())
+    }
+
+    /// Get shard for a key
+    #[wasm_bindgen]
+    pub fn get_shard_for_key(&self, key: &str) -> Result<String, JsValue> {
+        let shard = self
+            .manager
+            .get_shard_for_key(key)
+            .ok_or_else(|| JsValue::from_str("No shard found for key"))?;
+        Ok(shard.shard_id.0.clone())
+    }
+
+    /// Record a shard operation
+    #[wasm_bindgen]
+    pub fn record_shard_operation(
+        &mut self,
+        shard_id: &str,
+        operation: &str,
+        time_ms: f64,
+        records_affected: u32,
+        size_bytes: u64,
+    ) {
+        self.manager.record_shard_operation(
+            &feltdb::ShardId(shard_id.to_string()),
+            operation,
+            time_ms,
+            records_affected as usize,
+            size_bytes,
+        );
+    }
+
+    /// Get all shard metrics
+    #[wasm_bindgen]
+    pub fn get_all_metrics(&self) -> Result<String, JsValue> {
+        let metrics = self.manager.get_all_metrics();
+        serde_json::to_string(&metrics).map_err(|e| JsValue::from_str(&e.to_string()))
+    }
+
+    /// Detect hotspots
+    #[wasm_bindgen]
+    pub fn detect_hotspots(&self) -> Result<String, JsValue> {
+        let hotspots = self.manager.detect_hotspots();
+        serde_json::to_string(&hotspots).map_err(|e| JsValue::from_str(&e.to_string()))
+    }
+
+    /// Generate rebalance operations
+    #[wasm_bindgen]
+    pub fn generate_rebalance_ops(&self) -> Result<String, JsValue> {
+        let ops = self.manager.generate_rebalance_ops();
+        serde_json::to_string(&ops).map_err(|e| JsValue::from_str(&e.to_string()))
+    }
+
+    /// Get distribution summary
+    #[wasm_bindgen]
+    pub fn get_distribution_summary(&self) -> Result<String, JsValue> {
+        let summary = self.manager.get_distribution_summary();
+        serde_json::to_string(&summary).map_err(|e| JsValue::from_str(&e.to_string()))
+    }
+}
+
+/// Distributed index manager for multi-node synchronization.
+/// Coordinates index replication, consistency, and conflict resolution.
+#[wasm_bindgen]
+pub struct WasmDistributedIndexManager {
+    manager: feltdb::DistributedIndexManager,
+}
+
+#[wasm_bindgen]
+impl WasmDistributedIndexManager {
+    #[wasm_bindgen(constructor)]
+    pub fn new(peer_id: &str) -> WasmDistributedIndexManager {
+        WasmDistributedIndexManager {
+            manager: feltdb::DistributedIndexManager::new(peer_id.to_string()),
+        }
+    }
+
+    /// Register a peer for replication
+    #[wasm_bindgen]
+    pub fn register_peer(&mut self, peer_id: &str) {
+        self.manager.register_peer(peer_id.to_string());
+    }
+
+    /// Create a replicated index
+    #[wasm_bindgen]
+    pub fn create_replicated_index(
+        &mut self,
+        name: &str,
+        field: &str,
+        index_type: &str,
+    ) -> Result<(), JsValue> {
+        self.manager
+            .create_replicated_index(name.to_string(), field.to_string(), index_type.to_string())
+            .map_err(|e| JsValue::from_str(&e))
+    }
+
+    /// Get replication status for an index
+    #[wasm_bindgen]
+    pub fn get_replication_status(&self, index_name: &str) -> Result<String, JsValue> {
+        let status = self
+            .manager
+            .get_replication_status(index_name)
+            .ok_or_else(|| JsValue::from_str("Index not found"))?;
+        serde_json::to_string(&status).map_err(|e| JsValue::from_str(&e.to_string()))
+    }
+
+    /// Get list of peers needing replication for an index
+    #[wasm_bindgen]
+    pub fn get_replication_targets(&self, index_name: &str) -> Result<String, JsValue> {
+        let targets = self.manager.get_replication_targets(index_name);
+        serde_json::to_string(&targets).map_err(|e| JsValue::from_str(&e.to_string()))
+    }
+
+    /// Detect version conflicts
+    #[wasm_bindgen]
+    pub fn detect_conflicts(&self, index_name: &str) -> Result<String, JsValue> {
+        let conflicts = self.manager.detect_conflicts(index_name);
+        serde_json::to_string(&conflicts).map_err(|e| JsValue::from_str(&e.to_string()))
+    }
+
+    /// Merge concurrent versions
+    #[wasm_bindgen]
+    pub fn merge_versions(&mut self, index_name: &str) -> Result<(), JsValue> {
+        self.manager
+            .merge_versions(index_name)
+            .map_err(|e| JsValue::from_str(&e))
+    }
+
+    /// Set peer reachability
+    #[wasm_bindgen]
+    pub fn set_peer_reachable(&mut self, peer_id: &str, reachable: bool) {
+        self.manager.set_peer_reachable(peer_id, reachable);
+    }
+
+    /// Get overall synchronization status
+    #[wasm_bindgen]
+    pub fn get_sync_status(&self) -> Result<String, JsValue> {
+        let status = self.manager.get_sync_status();
+        serde_json::to_string(&status).map_err(|e| JsValue::from_str(&e.to_string()))
+    }
+}
+
+/// High-performance analytics engine for index monitoring.
+/// Tracks metrics, generates reports, and provides tuning recommendations.
+#[wasm_bindgen]
+pub struct WasmAnalytics {
+    analytics: feltdb::analytics::IndexAnalytics,
+}
+
+#[wasm_bindgen]
+impl WasmAnalytics {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> WasmAnalytics {
+        WasmAnalytics {
+            analytics: feltdb::analytics::IndexAnalytics::new(),
+        }
+    }
+
+    /// Record an index usage event.
+    #[wasm_bindgen]
+    pub fn record_index_usage(&mut self, index_name: &str, operation: &str, time_ms: f64) {
+        self.analytics.record_index_usage(index_name, operation, time_ms);
+    }
+
+    /// Record a query execution with performance metrics.
+    #[wasm_bindgen]
+    pub fn record_query(
+        &mut self,
+        fields_json: &str,
+        operator: &str,
+        execution_time_ms: f64,
+        rows_scanned: u64,
+        result_count: u64,
+        index_used: Option<String>,
+    ) -> Result<(), JsValue> {
+        let fields: Vec<String> = serde_json::from_str(fields_json)
+            .map_err(|e| JsValue::from_str(&e.to_string()))?;
+        self.analytics.record_query(
+            fields,
+            operator.to_string(),
+            execution_time_ms,
+            rows_scanned,
+            result_count,
+            index_used,
+        );
+        Ok(())
+    }
+
+    /// Get metrics for a specific index.
+    #[wasm_bindgen]
+    pub fn get_index_metrics(&self, index_name: &str) -> Result<String, JsValue> {
+        let metrics = self
+            .analytics
+            .get_index_metrics(index_name)
+            .ok_or_else(|| JsValue::from_str("Index not found"))?;
+        serde_json::to_string(&metrics).map_err(|e| JsValue::from_str(&e.to_string()))
+    }
+
+    /// Get metrics for all indexes.
+    #[wasm_bindgen]
+    pub fn get_all_metrics(&self) -> Result<String, JsValue> {
+        let metrics = self.analytics.get_all_metrics();
+        serde_json::to_string(&metrics).map_err(|e| JsValue::from_str(&e.to_string()))
+    }
+
+    /// Get slowest queries.
+    #[wasm_bindgen]
+    pub fn get_slowest_queries(&self, limit: usize) -> Result<String, JsValue> {
+        let traces = self.analytics.get_slowest_queries(limit);
+        serde_json::to_string(&traces).map_err(|e| JsValue::from_str(&e.to_string()))
+    }
+
+    /// Get most frequently accessed fields.
+    #[wasm_bindgen]
+    pub fn get_frequent_fields(&self, limit: usize) -> Result<String, JsValue> {
+        let fields = self.analytics.get_frequent_fields(limit);
+        serde_json::to_string(&fields).map_err(|e| JsValue::from_str(&e.to_string()))
+    }
+
+    /// Generate performance report for a collection.
+    #[wasm_bindgen]
+    pub fn generate_report(&self, collection_name: &str, period: &str) -> Result<String, JsValue> {
+        let report = self.analytics.generate_report(collection_name, period);
+        serde_json::to_string(&report).map_err(|e| JsValue::from_str(&e.to_string()))
+    }
+
+    /// Reset all collected metrics.
+    #[wasm_bindgen]
+    pub fn reset(&mut self) {
+        self.analytics.reset();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+
+    #[test]
+    fn test_wasm_open() {
+        let test_path = "test_wasm.db";
+        let _db = open(test_path).expect("open should succeed");
+        assert!(std::path::Path::new(test_path).exists());
+        let _ = fs::remove_file(test_path);
+    }
+    #[test]
+    fn wasm_schema_hash_uses_the_canonical_rust_contract() {
+        let schema = feltdb::state_contract::StateSchema {
+            contract_version: 1,
+            schema_version: 2,
+            application_id: "app".into(),
+            revision_id: "rev".into(),
+            collections: vec![],
+        };
+        let json = serde_json::to_string(&schema).unwrap();
+        assert_eq!(
+            hash_state_schema(&json).unwrap(),
+            feltdb::state_contract::schema_hash(&schema).unwrap()
+        );
+        let validation = validate_state_schema(&json).unwrap();
+        assert!(
+            serde_json::from_str::<feltdb::state_contract::SchemaValidation>(&validation)
+                .unwrap()
+                .valid
+        );
+    }
+}