cultcache-rs: pin the renamed-type tie-break; push_all resolves a shared schema id by given order

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

packages/cultcache-rs/CHANGELOG.md

@@ -17,7 +17,7 @@ only in git history.
 - A single-file store holds one record per key. The v1 and legacy readers refuse a store with two records under one key (`CultCacheStoreUnreadable`, the record `Undecodable`): the store does not open, and a write over it refuses and leaves the file. A consumer that holds such a file must repair it with the runtime that wrote it before opening it here.
 - Every single-file writer (`push`, `push_all`, `insert_entry_if_absent`, the compare-exchange and snapshot-append family, and the cache's puts and batches) refuses to put a second type under a key the store holds, with `SchemaConflictError` naming the key and both types, writing nothing. Retyping a key is a delete, then an add (one batch may hold both). A write owns the held record when its schema id equals the id the held record is stored under, as C# `WrittenOwns` asks; a type renamed under a stable id therefore replaces its own record, and a write of another type name under another id is refused (a write of the same type name under another id still replaces the record, as before). Registered types here declare no compatible ids, so equality is the whole test. Writers used to leave two records under the key.
 - `compare_and_swap_entry` over a single file refuses an in-place retype (expected `A/k`, replacement `B/k` under another schema id) with the same `SchemaConflictError`, as `compare_exchange` does, where it used to retype the record and return `true`. A lost race still returns `false` first.
-- A write of the same type under a held key replaces the record by key, and in one `push_all` the last of several same-type entries under a key is the record. The redb stores are unchanged and still key by type and key.
+- A write of the same type under a held key replaces the record by key, and in one `push_all` the last given of several entries under a key and a schema id is the record, whatever their type names. The redb stores are unchanged and still key by type and key.
 
 ### Added
 

packages/cultcache-rs/src/lib.rs

@@ -1777,11 +1777,11 @@ impl CacheBackingStore for SingleFileMessagePackBackingStore {
                 return Ok(());
             }
 
-            // Of same-type entries sharing a key the last one given is the record; a second type under a key reaches the
-            // commit guard.
+            // Of entries sharing a key and a schema id the last one given is the record, whatever their type names (a type
+            // renamed under a stable id); a second schema id under a key reaches the commit guard.
             let mut by_id = BTreeMap::<(String, String), &CultCacheEnvelope>::new();
             for entry in entries {
-                by_id.insert(entry_id(entry), entry);
+                by_id.insert((schema_identity(entry).to_string(), entry.key.clone()), entry);
             }
             let mut entries: Vec<CultCacheEnvelope> = by_id.into_values().cloned().collect();
             entries.sort_by_key(entry_id);
@@ -6679,6 +6679,52 @@ mod tests {
         Ok(())
     }
 
+    // Where a held record and a written one share a schema id under different type names, the written one is the record
+    // whichever name sorts first: the writers hand settle_one_record_per_key their entries sorted by type name.
+    #[test]
+    fn a_renamed_type_replaces_the_held_record_whether_its_name_sorts_before_or_after() -> Result<()> {
+        for new_name in ["a.new", "z.new"] {
+            let temp = tempfile::tempdir()?;
+            let path = temp.path().join("store.msgpack");
+            store_file(&path, &[("t.s", "t.old")], &[("a", "t.s", b"one".to_vec())])?;
+            let written = CultCacheEnvelope {
+                key: "a".into(),
+                r#type: new_name.into(),
+                payload: b"two".to_vec(),
+                stored_at: "2026-09-30T00:00:00Z".into(),
+                schema_id: Some("t.s".into()),
+            };
+            SingleFileMessagePackBackingStore::new(&path).push(&written)?;
+            let held = SingleFileMessagePackBackingStore::new(&path).pull_all()?;
+            assert_eq!(held.len(), 1, "{new_name}");
+            assert_eq!(held[0].payload, b"two".to_vec(), "{new_name}");
+        }
+        Ok(())
+    }
+
+    // In one push_all, entries under a key and a schema id with different type names resolve by the order given, not by
+    // the order of the names.
+    #[test]
+    fn push_all_resolves_same_id_entries_with_different_names_by_the_order_given() -> Result<()> {
+        let envelope = |r#type: &str, payload: &[u8]| CultCacheEnvelope {
+            key: "a".into(),
+            r#type: r#type.into(),
+            payload: payload.to_vec(),
+            stored_at: "2026-09-30T00:00:00Z".into(),
+            schema_id: Some("t.s".into()),
+        };
+        for (first, second) in [("a.name", "b.name"), ("b.name", "a.name")] {
+            let temp = tempfile::tempdir()?;
+            let path = temp.path().join("store.msgpack");
+            let mut store = SingleFileMessagePackBackingStore::new(&path);
+            store.push_all(&[envelope(first, b"first"), envelope(second, b"second")], PushAllOptions::default())?;
+            let held = store.pull_all()?;
+            assert_eq!(held.len(), 1, "{first} then {second}");
+            assert_eq!(held[0].payload, b"second".to_vec(), "{first} then {second}");
+        }
+        Ok(())
+    }
+
     // Of same-type entries sharing a key in one push_all the last one given is the record.
     #[test]
     fn push_all_keeps_the_last_of_two_same_type_entries_under_a_key() -> Result<()> {