create-feltdb 0.9.1 → 0.10.0

package/dist/package-versions.js

@@ -1,4 +1,4 @@
 // One release train keeps generated applications installable. The repository
 // validation script checks these values against every workspace manifest.
-export const FELTDB_PACKAGE_VERSION = '0.9.1';
+export const FELTDB_PACKAGE_VERSION = '0.10.0';
 export const feltdbPackageRange = `^${FELTDB_PACKAGE_VERSION}`;

package/dist/server-source/crates/feltdb/src/acceptance_tests.rs

@@ -1460,9 +1460,12 @@ mod convergence_acceptance_tests {
     use crate::FeltDb;
     use serde::{Deserialize, Serialize};
     use std::path::PathBuf;
+    use std::sync::atomic::{AtomicU64, Ordering};
     use std::time::SystemTime;
     use std::time::UNIX_EPOCH;
 
+    static TEMP_FILE_SEQUENCE: AtomicU64 = AtomicU64::new(0);
+
     #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
     struct Task {
         title: String,
@@ -1475,7 +1478,11 @@ mod convergence_acceptance_tests {
             .duration_since(UNIX_EPOCH)
             .expect("time")
             .as_nanos();
-        std::env::temp_dir().join(format!("feltdb-convergence-test-{nanos}.data"))
+        let sequence = TEMP_FILE_SEQUENCE.fetch_add(1, Ordering::Relaxed);
+        std::env::temp_dir().join(format!(
+            "feltdb-convergence-test-{}-{nanos}-{sequence}.data",
+            std::process::id()
+        ))
     }
 
     /// Test convergence: Two instances make concurrent mutations on same key

package/dist/server-source/crates/feltdb/src/application.rs

@@ -1203,6 +1203,22 @@ impl ApplicationStore {
             records: Arc::new(RwLock::new(records)),
         })
     }
+
+    /// Return every tenant scope asserted by canonical application definition
+    /// records for one stable application identity. Callers must reject zero
+    /// or multiple distinct tenants; ordering is never ownership evidence.
+    pub fn tenant_ownership_candidates(&self, application_id: &str) -> Vec<String> {
+        let Ok(records) = self.records.read() else {
+            return Vec::new();
+        };
+        records
+            .revisions
+            .iter()
+            .map(|value| (&value.application_id, &value.tenant_id))
+            .filter(|(candidate, _)| candidate.as_str() == application_id)
+            .map(|(_, tenant)| tenant.clone())
+            .collect()
+    }
     fn persist(&self, r: &RevisionRecords) -> Result<(), String> {
         if let Some(parent) = self.path.parent() {
             fs::create_dir_all(parent).map_err(|e| e.to_string())?;

package/dist/server-source/crates/feltdb/src/bin/feltdb_node.rs

@@ -744,11 +744,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                                 link.peer.clone(),
                                 envelope.envelope_id.sequence,
                             );
-                            if link.io.send(message.clone()).await.is_ok() {
-                                delivered.push(link.peer.clone());
-                            } else if connect_with_retry(link, 3).await
-                                && link.io.send(message).await.is_ok()
-                            {
+                            // Forwarding, like re-sending, is an explicit
+                            // recovery operation. Prefer a fresh connection so
+                            // a peer restart cannot leave this write accepted
+                            // by a stale local socket and delivered nowhere.
+                            let _ = connect_with_retry(link, 3).await;
+                            if link.io.send(message).await.is_ok() {
                                 delivered.push(link.peer.clone());
                             }
                         }
@@ -793,19 +794,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                                 link.peer.clone(),
                                 envelope.envelope_id.sequence,
                             );
-                            // The peer this is aimed at may have restarted
-                            // since the link was established, which is the
-                            // whole point of re-sending. Reconnect and retry,
-                            // as `execute-tx` does.
-                            match link.io.send(message.clone()).await {
-                                Ok(()) => delivered.push(link.peer.clone()),
-                                Err(_) => {
-                                    if connect_with_retry(link, 3).await
-                                        && link.io.send(message).await.is_ok()
-                                    {
-                                        delivered.push(link.peer.clone());
-                                    }
-                                }
+                            // Re-sending is the recovery primitive used after a
+                            // peer restart. A write to the old TCP socket can
+                            // still return success after the peer has exited,
+                            // because that only confirms acceptance by the
+                            // local kernel. Try to establish a fresh connection
+                            // first. If the peer never restarted, the connect
+                            // attempt leaves the established stream untouched.
+                            let _ = connect_with_retry(link, 3).await;
+                            if link.io.send(message).await.is_ok() {
+                                delivered.push(link.peer.clone());
                             }
                         }
                         println!(
@@ -961,12 +959,13 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
                 let mut delivered = Vec::new();
                 for link in &send_links {
+                    // Acknowledgements are durable recovery evidence and are
+                    // commonly rebroadcast after a peer restart. Refresh the
+                    // connection first for the same reason as explicit
+                    // envelope replay.
+                    let _ = connect_with_retry(link, 3).await;
                     if link.io.send_acknowledgement(ack.clone()).await.is_ok() {
                         delivered.push(link.peer.clone());
-                    } else if connect_with_retry(link, 3).await
-                        && link.io.send_acknowledgement(ack.clone()).await.is_ok()
-                    {
-                        delivered.push(link.peer.clone());
                     }
                 }
                 println!(