fixing some tests

crates/jacquard-repo/src/mst/cursor.rs

···
     async fn test_cursor_single_leaf() {
         let storage = Arc::new(MemoryBlockStore::new());
         let tree = Mst::new(storage);
-        let tree = tree.add("key1", test_cid(1)).await.unwrap();
+        let tree = tree.add("com.example.test/key1", test_cid(1)).await.unwrap();
 
         let mut cursor = MstCursor::new(tree);
 
···
 
         // Advance to first leaf
         cursor.advance().await.unwrap();
-        assert_eq!(cursor.key(), Some("key1"));
+        assert_eq!(cursor.key(), Some("com.example.test/key1"));
 
         // Advance past last leaf
         cursor.advance().await.unwrap();
···
     async fn test_cursor_multiple_leaves() {
         let storage = Arc::new(MemoryBlockStore::new());
         let tree = Mst::new(storage);
-        let tree = tree.add("a", test_cid(1)).await.unwrap();
-        let tree = tree.add("b", test_cid(2)).await.unwrap();
-        let tree = tree.add("c", test_cid(3)).await.unwrap();
+        let tree = tree.add("com.example.test/a", test_cid(1)).await.unwrap();
+        let tree = tree.add("com.example.test/b", test_cid(2)).await.unwrap();
+        let tree = tree.add("com.example.test/c", test_cid(3)).await.unwrap();
 
         let mut cursor = MstCursor::new(tree);
 
···
             cursor.advance().await.unwrap();
         }
 
-        assert_eq!(keys, vec!["a", "b", "c"]);
+        assert_eq!(keys, vec!["com.example.test/a", "com.example.test/b", "com.example.test/c"]);
     }
 
     #[tokio::test]
···
         let tree = Mst::new(storage);
 
         // Add enough keys to create subtrees
-        let tree = tree.add("a", test_cid(1)).await.unwrap();
-        let tree = tree.add("b", test_cid(2)).await.unwrap();
-        let tree = tree.add("c", test_cid(3)).await.unwrap();
+        let tree = tree.add("com.example.test/a", test_cid(1)).await.unwrap();
+        let tree = tree.add("com.example.test/b", test_cid(2)).await.unwrap();
+        let tree = tree.add("com.example.test/c", test_cid(3)).await.unwrap();
 
         let mut cursor = MstCursor::new(tree);
 

crates/jacquard-repo/src/mst/diff.rs

···
 
         let storage2 = Arc::new(MemoryBlockStore::new());
         let tree2 = Mst::new(storage2);
-        let tree2 = tree2.add("a", test_cid(1)).await.unwrap();
-        let tree2 = tree2.add("b", test_cid(2)).await.unwrap();
+        let tree2 = tree2.add("com.example.test/a", test_cid(1)).await.unwrap();
+        let tree2 = tree2.add("com.example.test/b", test_cid(2)).await.unwrap();
 
         let diff = tree1.diff(&tree2).await.unwrap();
 
···
         assert!(
             diff.creates
                 .iter()
-                .any(|(k, c)| k == "a" && *c == test_cid(1))
+                .any(|(k, c)| k == "com.example.test/a" && *c == test_cid(1))
         );
         assert!(
             diff.creates
                 .iter()
-                .any(|(k, c)| k == "b" && *c == test_cid(2))
+                .any(|(k, c)| k == "com.example.test/b" && *c == test_cid(2))
         );
     }
 
···
     async fn test_diff_deletes() {
         let storage1 = Arc::new(MemoryBlockStore::new());
         let tree1 = Mst::new(storage1);
-        let tree1 = tree1.add("a", test_cid(1)).await.unwrap();
-        let tree1 = tree1.add("b", test_cid(2)).await.unwrap();
+        let tree1 = tree1.add("com.example.test/a", test_cid(1)).await.unwrap();
+        let tree1 = tree1.add("com.example.test/b", test_cid(2)).await.unwrap();
 
         let storage2 = Arc::new(MemoryBlockStore::new());
         let tree2 = Mst::new(storage2);
···
         assert!(
             diff.deletes
                 .iter()
-                .any(|(k, c)| k == "a" && *c == test_cid(1))
+                .any(|(k, c)| k == "com.example.test/a" && *c == test_cid(1))
         );
         assert!(
             diff.deletes
                 .iter()
-                .any(|(k, c)| k == "b" && *c == test_cid(2))
+                .any(|(k, c)| k == "com.example.test/b" && *c == test_cid(2))
         );
     }
 
···
     async fn test_diff_updates() {
         let storage1 = Arc::new(MemoryBlockStore::new());
         let tree1 = Mst::new(storage1);
-        let tree1 = tree1.add("a", test_cid(1)).await.unwrap();
-        let tree1 = tree1.add("b", test_cid(2)).await.unwrap();
+        let tree1 = tree1.add("com.example.test/a", test_cid(1)).await.unwrap();
+        let tree1 = tree1.add("com.example.test/b", test_cid(2)).await.unwrap();
 
         let storage2 = Arc::new(MemoryBlockStore::new());
         let tree2 = Mst::new(storage2);
-        let tree2 = tree2.add("a", test_cid(10)).await.unwrap(); // Changed CID
-        let tree2 = tree2.add("b", test_cid(2)).await.unwrap(); // Same CID
+        let tree2 = tree2.add("com.example.test/a", test_cid(10)).await.unwrap(); // Changed CID
+        let tree2 = tree2.add("com.example.test/b", test_cid(2)).await.unwrap(); // Same CID
 
         let diff = tree1.diff(&tree2).await.unwrap();
 
···
         assert_eq!(diff.op_count(), 1);
 
         // Check update content
-        assert_eq!(diff.updates[0].0, "a");
+        assert_eq!(diff.updates[0].0, "com.example.test/a");
         assert_eq!(diff.updates[0].1, test_cid(10)); // new CID
         assert_eq!(diff.updates[0].2, test_cid(1)); // old CID
     }
···
     async fn test_diff_mixed_operations() {
         let storage1 = Arc::new(MemoryBlockStore::new());
         let tree1 = Mst::new(storage1);
-        let tree1 = tree1.add("a", test_cid(1)).await.unwrap();
-        let tree1 = tree1.add("b", test_cid(2)).await.unwrap();
-        let tree1 = tree1.add("c", test_cid(3)).await.unwrap();
+        let tree1 = tree1.add("com.example.test/a", test_cid(1)).await.unwrap();
+        let tree1 = tree1.add("com.example.test/b", test_cid(2)).await.unwrap();
+        let tree1 = tree1.add("com.example.test/c", test_cid(3)).await.unwrap();
 
         let storage2 = Arc::new(MemoryBlockStore::new());
         let tree2 = Mst::new(storage2);
-        let tree2 = tree2.add("a", test_cid(10)).await.unwrap(); // Updated
-        let tree2 = tree2.add("b", test_cid(2)).await.unwrap(); // Unchanged
+        let tree2 = tree2.add("com.example.test/a", test_cid(10)).await.unwrap(); // Updated
+        let tree2 = tree2.add("com.example.test/b", test_cid(2)).await.unwrap(); // Unchanged
         // "c" deleted
-        let tree2 = tree2.add("d", test_cid(4)).await.unwrap(); // Created
+        let tree2 = tree2.add("com.example.test/d", test_cid(4)).await.unwrap(); // Created
 
         let diff = tree1.diff(&tree2).await.unwrap();
 
···
     async fn test_diff_to_empty() {
         let storage = Arc::new(MemoryBlockStore::new());
         let tree = Mst::new(storage);
-        let tree = tree.add("a", test_cid(1)).await.unwrap();
-        let tree = tree.add("b", test_cid(2)).await.unwrap();
-        let tree = tree.add("c", test_cid(3)).await.unwrap();
+        let tree = tree.add("com.example.test/a", test_cid(1)).await.unwrap();
+        let tree = tree.add("com.example.test/b", test_cid(2)).await.unwrap();
+        let tree = tree.add("com.example.test/c", test_cid(3)).await.unwrap();
 
         let diff = tree.diff_to_empty().await.unwrap();
 
···
         // diff(A, B) should be inverse of diff(B, A)
         let storage1 = Arc::new(MemoryBlockStore::new());
         let tree1 = Mst::new(storage1);
-        let tree1 = tree1.add("a", test_cid(1)).await.unwrap();
-        let tree1 = tree1.add("b", test_cid(2)).await.unwrap();
+        let tree1 = tree1.add("com.example.test/a", test_cid(1)).await.unwrap();
+        let tree1 = tree1.add("com.example.test/b", test_cid(2)).await.unwrap();
 
         let storage2 = Arc::new(MemoryBlockStore::new());
         let tree2 = Mst::new(storage2);
-        let tree2 = tree2.add("b", test_cid(2)).await.unwrap();
-        let tree2 = tree2.add("c", test_cid(3)).await.unwrap();
+        let tree2 = tree2.add("com.example.test/b", test_cid(2)).await.unwrap();
+        let tree2 = tree2.add("com.example.test/c", test_cid(3)).await.unwrap();
 
         let diff1 = tree1.diff(&tree2).await.unwrap();
         let diff2 = tree2.diff(&tree1).await.unwrap();

crates/jacquard-repo/src/mst/tree.rs

···
 use super::node::NodeEntry;
 use super::util;
 use crate::error::{RepoError, Result};
+use crate::mst::util::validate_key;
 use crate::storage::BlockStore;
 use cid::Cid as IpldCid;
 use core::fmt;
···
     ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Option<IpldCid>>> + Send + 'a>>
     {
         Box::pin(async move {
-            util::validate_key(key)?;
+            validate_key(key)?;
 
             let entries = self.get_entries().await?;
             let index = Self::find_gt_or_equal_leaf_index_in(&entries, key);
···
         cid: IpldCid,
     ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Mst<S>>> + Send + 'a>> {
         Box::pin(async move {
-            util::validate_key(key)?;
+            validate_key(key)?;
 
             let key_layer = util::layer_for_key(key);
             let node_layer = self.get_layer().await?;
···
         key: &'a str,
     ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Mst<S>>> + Send + 'a>> {
         Box::pin(async move {
-            util::validate_key(key)?;
+            validate_key(key)?;
 
             let altered = self.delete_recurse(key).await?;
             altered.trim_top().await
···
 
     /// Update an existing key (returns new tree)
     pub async fn update(&self, key: &str, cid: IpldCid) -> Result<Mst<S>> {
-        util::validate_key(key)?;
+        validate_key(key)?;
 
         // Check key exists
         if self.get(key).await?.is_none() {
···
     ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Vec<IpldCid>>> + Send + 'a>>
     {
         Box::pin(async move {
-            util::validate_key(key)?;
+            validate_key(key)?;
 
             let mut cids = vec![self.get_pointer().await?];
             let entries = self.get_entries().await?;
···
         let storage = Arc::new(MemoryBlockStore::new());
         let mst = Mst::new(storage);
 
-        let result = mst.get("test/key").await.unwrap();
+        let result = mst.get("com.example.test/key").await.unwrap();
         assert!(result.is_none());
     }
 
···
 
         let entries = vec![
             NodeEntry::Leaf {
-                key: SmolStr::new("a"),
+                key: SmolStr::new("com.example.test/a"),
                 value: test_cid(1),
             },
             NodeEntry::Leaf {
-                key: SmolStr::new("b"),
+                key: SmolStr::new("com.example.test/b"),
                 value: test_cid(2),
             },
             NodeEntry::Leaf {
-                key: SmolStr::new("c"),
+                key: SmolStr::new("com.example.test/c"),
                 value: test_cid(3),
             },
         ];
 
         let mst = Mst::create(storage, entries, Some(0)).await.unwrap();
 
-        assert_eq!(mst.get("a").await.unwrap(), Some(test_cid(1)));
-        assert_eq!(mst.get("b").await.unwrap(), Some(test_cid(2)));
-        assert_eq!(mst.get("c").await.unwrap(), Some(test_cid(3)));
-        assert_eq!(mst.get("d").await.unwrap(), None);
+        assert_eq!(
+            mst.get("com.example.test/a").await.unwrap(),
+            Some(test_cid(1))
+        );
+        assert_eq!(
+            mst.get("com.example.test/b").await.unwrap(),
+            Some(test_cid(2))
+        );
+        assert_eq!(
+            mst.get("com.example.test/c").await.unwrap(),
+            Some(test_cid(3))
+        );
+        assert_eq!(mst.get("com.example.test/d").await.unwrap(), None);
+    }
+
+    #[tokio::test]
+    async fn test_allowed_keys() -> Result<()> {
+        let cid1str = "bafyreie5cvv4h45feadgeuwhbcutmh6t2ceseocckahdoe6uat64zmz454";
+        let cid1 = IpldCid::try_from(cid1str).unwrap();
+
+        let storage = Arc::new(MemoryBlockStore::new());
+        let mst = Mst::new(storage);
+        // Rejects empty key
+        let result = mst.add(&"".to_string(), cid1).await;
+        assert!(result.is_err());
+
+        // Rejects a key with no collection
+        let result = mst.add(&"asdf".to_string(), cid1).await;
+        assert!(result.is_err());
+
+        // Rejects a key with a nested collection
+        let result = mst.add(&"nested/collection/asdf".to_string(), cid1).await;
+        assert!(result.is_err());
+
+        // Rejects on empty coll or rkey
+        let result = mst.add(&"coll/".to_string(), cid1).await;
+        assert!(result.is_err());
+        let result = mst.add(&"/rkey".to_string(), cid1).await;
+        assert!(result.is_err());
+
+        // Rejects non-ascii chars
+        let result = mst.add(&"coll/jalapeñoA".to_string(), cid1).await;
+        assert!(result.is_err());
+        let result = mst.add(&"coll/coöperative".to_string(), cid1).await;
+        assert!(result.is_err());
+        let result = mst.add(&"coll/abc💩".to_string(), cid1).await;
+        assert!(result.is_err());
+
+        // Rejects ascii that we don't support
+        let invalid_chars = vec!["$", "%", "(", ")", "+", "="];
+        for ch in invalid_chars {
+            let key = format!("coll/key{}", ch);
+            let result = mst.add(&key, cid1).await;
+            assert!(result.is_err(), "Key '{}' should be invalid", key);
+        }
+
+        // Rejects keys over 256 chars
+        let long_key: String = "a".repeat(253);
+        let key = format!("coll/{}", long_key);
+        let result = mst.add(&key, cid1).await;
+        assert!(result.is_err());
+
+        // Allows long key under 256 chars
+        let long_key: String = "a".repeat(250);
+        let key = format!("coll/{}", long_key);
+        let result = mst.add(&key, cid1).await;
+        assert!(result.is_ok());
+
+        // Allows URL-safe chars
+        let valid_keys = vec![
+            "coll/key0",
+            "coll/key_",
+            "coll/key:",
+            "coll/key.",
+            "coll/key-",
+        ];
+        for key in valid_keys {
+            let result = mst.add(&key.to_string(), cid1).await;
+            assert!(result.is_ok(), "Key '{}' should be valid", key);
+        }
+
+        Ok(())
     }
 
     #[tokio::test]
···
         let storage = Arc::new(MemoryBlockStore::new());
         let mst = Mst::new(storage);
 
-        let updated = mst.add("test/key", test_cid(1)).await.unwrap();
+        let updated = mst.add("com.example.test/key", test_cid(1)).await.unwrap();
 
-        assert_eq!(updated.get("test/key").await.unwrap(), Some(test_cid(1)));
+        assert_eq!(
+            updated.get("com.example.test/key").await.unwrap(),
+            Some(test_cid(1))
+        );
     }
 
     #[tokio::test]
···
         let storage = Arc::new(MemoryBlockStore::new());
         let mst = Mst::new(storage);
 
-        let mst = mst.add("a", test_cid(1)).await.unwrap();
-        let mst = mst.add("b", test_cid(2)).await.unwrap();
-        let mst = mst.add("c", test_cid(3)).await.unwrap();
+        let mst = mst.add("com.example.test/a", test_cid(1)).await.unwrap();
+        let mst = mst.add("com.example.test/b", test_cid(2)).await.unwrap();
+        let mst = mst.add("com.example.test/c", test_cid(3)).await.unwrap();
 
-        assert_eq!(mst.get("a").await.unwrap(), Some(test_cid(1)));
-        assert_eq!(mst.get("b").await.unwrap(), Some(test_cid(2)));
-        assert_eq!(mst.get("c").await.unwrap(), Some(test_cid(3)));
+        assert_eq!(
+            mst.get("com.example.test/a").await.unwrap(),
+            Some(test_cid(1))
+        );
+        assert_eq!(
+            mst.get("com.example.test/b").await.unwrap(),
+            Some(test_cid(2))
+        );
+        assert_eq!(
+            mst.get("com.example.test/c").await.unwrap(),
+            Some(test_cid(3))
+        );
     }
 
     #[tokio::test]
···
         let storage = Arc::new(MemoryBlockStore::new());
         let mst = Mst::new(storage);
 
-        let mst = mst.add("test", test_cid(1)).await.unwrap();
-        let mst = mst.add("test", test_cid(2)).await.unwrap();
+        let mst = mst.add("com.example.test/key1", test_cid(1)).await.unwrap();
+        let mst = mst.add("com.example.test/key1", test_cid(2)).await.unwrap();
 
-        assert_eq!(mst.get("test").await.unwrap(), Some(test_cid(2)));
+        assert_eq!(
+            mst.get("com.example.test/key1").await.unwrap(),
+            Some(test_cid(2))
+        );
     }
 
     #[tokio::test]
···
         let storage = Arc::new(MemoryBlockStore::new());
         let mst = Mst::new(storage);
 
-        let mst = mst.add("test", test_cid(1)).await.unwrap();
-        let mst = mst.delete("test").await.unwrap();
+        let mst = mst.add("com.example.test/key1", test_cid(1)).await.unwrap();
+        let mst = mst.delete("com.example.test/key1").await.unwrap();
 
-        assert_eq!(mst.get("test").await.unwrap(), None);
+        assert_eq!(mst.get("com.example.test/key1").await.unwrap(), None);
         assert_eq!(mst.get_entries().await.unwrap().len(), 0);
     }
 
···
         let storage = Arc::new(MemoryBlockStore::new());
         let mst = Mst::new(storage);
 
-        let mst = mst.add("a", test_cid(1)).await.unwrap();
-        let mst = mst.add("b", test_cid(2)).await.unwrap();
-        let mst = mst.add("c", test_cid(3)).await.unwrap();
+        let mst = mst.add("com.example.test/a", test_cid(1)).await.unwrap();
+        let mst = mst.add("com.example.test/b", test_cid(2)).await.unwrap();
+        let mst = mst.add("com.example.test/c", test_cid(3)).await.unwrap();
 
-        let mst = mst.delete("b").await.unwrap();
+        let mst = mst.delete("com.example.test/b").await.unwrap();
 
-        assert_eq!(mst.get("a").await.unwrap(), Some(test_cid(1)));
-        assert_eq!(mst.get("b").await.unwrap(), None);
-        assert_eq!(mst.get("c").await.unwrap(), Some(test_cid(3)));
+        assert_eq!(
+            mst.get("com.example.test/a").await.unwrap(),
+            Some(test_cid(1))
+        );
+        assert_eq!(mst.get("com.example.test/b").await.unwrap(), None);
+        assert_eq!(
+            mst.get("com.example.test/c").await.unwrap(),
+            Some(test_cid(3))
+        );
     }
 
     #[tokio::test]
···
         let storage = Arc::new(MemoryBlockStore::new());
         let mst = Mst::new(storage);
 
-        let mst = mst.add("a", test_cid(1)).await.unwrap();
+        let mst = mst.add("com.example.test/a", test_cid(1)).await.unwrap();
 
-        let result = mst.delete("b").await;
+        let result = mst.delete("com.example.test/b").await;
         assert!(result.is_err());
     }
 
···
         let storage = Arc::new(MemoryBlockStore::new());
         let mst = Mst::new(storage.clone());
 
-        let mst = mst.add("a", test_cid(1)).await.unwrap();
-        let mst = mst.add("b", test_cid(2)).await.unwrap();
-        let mst = mst.add("c", test_cid(3)).await.unwrap();
+        let mst = mst.add("com.example.test/a", test_cid(1)).await.unwrap();
+        let mst = mst.add("com.example.test/b", test_cid(2)).await.unwrap();
+        let mst = mst.add("com.example.test/c", test_cid(3)).await.unwrap();
 
         // Persist to storage
         let cid = mst.persist().await.unwrap();
···
         let reloaded = Mst::load(storage, cid, Some(0));
 
         // Verify all keys are present
-        assert_eq!(reloaded.get("a").await.unwrap(), Some(test_cid(1)));
-        assert_eq!(reloaded.get("b").await.unwrap(), Some(test_cid(2)));
-        assert_eq!(reloaded.get("c").await.unwrap(), Some(test_cid(3)));
+        assert_eq!(
+            reloaded.get("com.example.test/a").await.unwrap(),
+            Some(test_cid(1))
+        );
+        assert_eq!(
+            reloaded.get("com.example.test/b").await.unwrap(),
+            Some(test_cid(2))
+        );
+        assert_eq!(
+            reloaded.get("com.example.test/c").await.unwrap(),
+            Some(test_cid(3))
+        );
     }
 
     #[tokio::test]
···
         // Same keys inserted in same order should produce same CID
         let storage1 = Arc::new(MemoryBlockStore::new());
         let mst1 = Mst::new(storage1);
-        let mst1 = mst1.add("a", test_cid(1)).await.unwrap();
-        let mst1 = mst1.add("b", test_cid(2)).await.unwrap();
-        let mst1 = mst1.add("c", test_cid(3)).await.unwrap();
+        let mst1 = mst1.add("com.example.test/a", test_cid(1)).await.unwrap();
+        let mst1 = mst1.add("com.example.test/b", test_cid(2)).await.unwrap();
+        let mst1 = mst1.add("com.example.test/c", test_cid(3)).await.unwrap();
         let cid1 = mst1.get_pointer().await.unwrap();
 
         let storage2 = Arc::new(MemoryBlockStore::new());
         let mst2 = Mst::new(storage2);
-        let mst2 = mst2.add("a", test_cid(1)).await.unwrap();
-        let mst2 = mst2.add("b", test_cid(2)).await.unwrap();
-        let mst2 = mst2.add("c", test_cid(3)).await.unwrap();
+        let mst2 = mst2.add("com.example.test/a", test_cid(1)).await.unwrap();
+        let mst2 = mst2.add("com.example.test/b", test_cid(2)).await.unwrap();
+        let mst2 = mst2.add("com.example.test/c", test_cid(3)).await.unwrap();
         let cid2 = mst2.get_pointer().await.unwrap();
 
         assert_eq!(cid1, cid2);
···
         // Different insertion orders should produce same CID
         let storage1 = Arc::new(MemoryBlockStore::new());
         let mst1 = Mst::new(storage1);
-        let mst1 = mst1.add("a", test_cid(1)).await.unwrap();
-        let mst1 = mst1.add("b", test_cid(2)).await.unwrap();
-        let mst1 = mst1.add("c", test_cid(3)).await.unwrap();
+        let mst1 = mst1.add("com.example.test/a", test_cid(1)).await.unwrap();
+        let mst1 = mst1.add("com.example.test/b", test_cid(2)).await.unwrap();
+        let mst1 = mst1.add("com.example.test/c", test_cid(3)).await.unwrap();
         let cid1 = mst1.get_pointer().await.unwrap();
 
         let storage2 = Arc::new(MemoryBlockStore::new());
         let mst2 = Mst::new(storage2);
-        let mst2 = mst2.add("c", test_cid(3)).await.unwrap();
-        let mst2 = mst2.add("a", test_cid(1)).await.unwrap();
-        let mst2 = mst2.add("b", test_cid(2)).await.unwrap();
+        let mst2 = mst2.add("com.example.test/c", test_cid(3)).await.unwrap();
+        let mst2 = mst2.add("com.example.test/a", test_cid(1)).await.unwrap();
+        let mst2 = mst2.add("com.example.test/b", test_cid(2)).await.unwrap();
         let cid2 = mst2.get_pointer().await.unwrap();
 
         assert_eq!(cid1, cid2);
···
 
         let ops = vec![
             VerifiedWriteOp::Create {
-                key: SmolStr::new("a"),
+                key: SmolStr::new("com.example.test/a"),
                 cid: test_cid(1),
             },
             VerifiedWriteOp::Create {
-                key: SmolStr::new("b"),
+                key: SmolStr::new("com.example.test/b"),
                 cid: test_cid(2),
             },
             VerifiedWriteOp::Create {
-                key: SmolStr::new("c"),
+                key: SmolStr::new("com.example.test/c"),
                 cid: test_cid(3),
             },
         ];
 
         let mst = mst.batch(&ops).await.unwrap();
 
-        assert_eq!(mst.get("a").await.unwrap(), Some(test_cid(1)));
-        assert_eq!(mst.get("b").await.unwrap(), Some(test_cid(2)));
-        assert_eq!(mst.get("c").await.unwrap(), Some(test_cid(3)));
+        assert_eq!(
+            mst.get("com.example.test/a").await.unwrap(),
+            Some(test_cid(1))
+        );
+        assert_eq!(
+            mst.get("com.example.test/b").await.unwrap(),
+            Some(test_cid(2))
+        );
+        assert_eq!(
+            mst.get("com.example.test/c").await.unwrap(),
+            Some(test_cid(3))
+        );
     }
 
     #[tokio::test]
···
         let mst = Mst::new(storage);
 
         // Start with some keys
-        let mst = mst.add("a", test_cid(1)).await.unwrap();
-        let mst = mst.add("b", test_cid(2)).await.unwrap();
-        let mst = mst.add("c", test_cid(3)).await.unwrap();
+        let mst = mst.add("com.example.test/a", test_cid(1)).await.unwrap();
+        let mst = mst.add("com.example.test/b", test_cid(2)).await.unwrap();
+        let mst = mst.add("com.example.test/c", test_cid(3)).await.unwrap();
 
         let ops = vec![
             VerifiedWriteOp::Create {
-                key: SmolStr::new("d"),
+                key: SmolStr::new("com.example.test/d"),
                 cid: test_cid(4),
             },
             VerifiedWriteOp::Update {
-                key: SmolStr::new("a"),
+                key: SmolStr::new("com.example.test/a"),
                 cid: test_cid(10),
                 prev: test_cid(1),
             },
             VerifiedWriteOp::Delete {
-                key: SmolStr::new("b"),
+                key: SmolStr::new("com.example.test/b"),
                 prev: test_cid(2),
             },
         ];
 
         let mst = mst.batch(&ops).await.unwrap();
 
-        assert_eq!(mst.get("a").await.unwrap(), Some(test_cid(10))); // Updated
-        assert_eq!(mst.get("b").await.unwrap(), None); // Deleted
-        assert_eq!(mst.get("c").await.unwrap(), Some(test_cid(3))); // Unchanged
-        assert_eq!(mst.get("d").await.unwrap(), Some(test_cid(4))); // Created
+        assert_eq!(
+            mst.get("com.example.test/a").await.unwrap(),
+            Some(test_cid(10))
+        ); // Updated
+        assert_eq!(mst.get("com.example.test/b").await.unwrap(), None); // Deleted
+        assert_eq!(
+            mst.get("com.example.test/c").await.unwrap(),
+            Some(test_cid(3))
+        ); // Unchanged
+        assert_eq!(
+            mst.get("com.example.test/d").await.unwrap(),
+            Some(test_cid(4))
+        ); // Created
     }
 
     #[tokio::test]
     async fn test_batch_with_prev_validation() {
         let storage = Arc::new(MemoryBlockStore::new());
         let mst = Mst::new(storage);
-        let mst = mst.add("a", test_cid(1)).await.unwrap();
+        let mst = mst.add("com.example.test/a", test_cid(1)).await.unwrap();
 
         // Update with correct prev - should succeed
         let ops = vec![VerifiedWriteOp::Update {
-            key: SmolStr::new("a"),
+            key: SmolStr::new("com.example.test/a"),
             cid: test_cid(2),
             prev: test_cid(1),
         }];
         let mst = mst.batch(&ops).await.unwrap();
-        assert_eq!(mst.get("a").await.unwrap(), Some(test_cid(2)));
+        assert_eq!(
+            mst.get("com.example.test/a").await.unwrap(),
+            Some(test_cid(2))
+        );
 
         // Update with wrong prev - should fail
         let ops = vec![VerifiedWriteOp::Update {
-            key: SmolStr::new("a"),
+            key: SmolStr::new("com.example.test/a"),
             cid: test_cid(3),
             prev: test_cid(99), // Wrong CID
         }];
···
 
         // Delete with correct prev - should succeed
         let ops = vec![VerifiedWriteOp::Delete {
-            key: SmolStr::new("a"),
+            key: SmolStr::new("com.example.test/a"),
             prev: test_cid(2),
         }];
         let mst = mst.batch(&ops).await.unwrap();
-        assert_eq!(mst.get("a").await.unwrap(), None);
+        assert_eq!(mst.get("com.example.test/a").await.unwrap(), None);
     }
 
     #[tokio::test]
     async fn test_batch_create_duplicate_error() {
         let storage = Arc::new(MemoryBlockStore::new());
         let mst = Mst::new(storage);
-        let mst = mst.add("a", test_cid(1)).await.unwrap();
+        let mst = mst.add("com.example.test/a", test_cid(1)).await.unwrap();
 
         let ops = vec![VerifiedWriteOp::Create {
-            key: SmolStr::new("a"),
+            key: SmolStr::new("com.example.test/a"),
             cid: test_cid(2),
         }];
 
···
         let mst = Mst::new(storage);
 
         let ops = vec![VerifiedWriteOp::Update {
-            key: SmolStr::new("a"),
+            key: SmolStr::new("com.example.test/a"),
             cid: test_cid(1),
             prev: test_cid(99), // Doesn't matter since key doesn't exist
         }];
···
         let mst = Mst::new(storage);
 
         let ops = vec![VerifiedWriteOp::Delete {
-            key: SmolStr::new("a"),
+            key: SmolStr::new("com.example.test/a"),
             prev: test_cid(99), // Doesn't matter since key doesn't exist
         }];
 
···
     async fn test_batch_empty() {
         let storage = Arc::new(MemoryBlockStore::new());
         let mst = Mst::new(storage);
-        let mst = mst.add("a", test_cid(1)).await.unwrap();
+        let mst = mst.add("com.example.test/a", test_cid(1)).await.unwrap();
 
         let ops = vec![];
         let mst = mst.batch(&ops).await.unwrap();
 
         // Should be unchanged
-        assert_eq!(mst.get("a").await.unwrap(), Some(test_cid(1)));
+        assert_eq!(
+            mst.get("com.example.test/a").await.unwrap(),
+            Some(test_cid(1))
+        );
     }
 
     #[tokio::test]
···
         let storage = Arc::new(MemoryBlockStore::new());
         let mst = Mst::new(storage);
 
-        let mst = mst.add("a", test_cid(1)).await.unwrap();
-        let mst = mst.add("b", test_cid(2)).await.unwrap();
-        let mst = mst.add("c", test_cid(3)).await.unwrap();
+        let mst = mst.add("com.example.test/a", test_cid(1)).await.unwrap();
+        let mst = mst.add("com.example.test/b", test_cid(2)).await.unwrap();
+        let mst = mst.add("com.example.test/c", test_cid(3)).await.unwrap();
 
         // Get proof path for key "b"
-        let cids = mst.cids_for_path("b").await.unwrap();
+        let cids = mst.cids_for_path("com.example.test/b").await.unwrap();
 
         // Should contain: root CID, record CID
         assert_eq!(cids.len(), 2);
···
         let storage = Arc::new(MemoryBlockStore::new());
         let mst = Mst::new(storage);
 
-        let mst = mst.add("a", test_cid(1)).await.unwrap();
-        let mst = mst.add("c", test_cid(3)).await.unwrap();
+        let mst = mst.add("com.example.test/a", test_cid(1)).await.unwrap();
+        let mst = mst.add("com.example.test/c", test_cid(3)).await.unwrap();
 
         // Get proof path for nonexistent key "b"
-        let cids = mst.cids_for_path("b").await.unwrap();
+        let cids = mst.cids_for_path("com.example.test/b").await.unwrap();
 
         // Should contain root CID first, and NOT contain the record CID (proves absence)
         assert!(cids.len() >= 1, "Should have at least the root CID");

crates/jacquard-repo/src/mst/util.rs

···
 
 /// Validate MST key format
 ///
-/// Keys must match: [a-zA-Z0-9._:~-]+
-/// Max length: 256 bytes (atproto limit)
 pub fn validate_key(key: &str) -> Result<()> {
     if key.is_empty() {
         return Err(MstError::EmptyKey.into());
···
         .into());
     }
 
-    Ok(())
+    let split: Vec<&str> = key.split("/").collect();
+
+    return if split.len() == 2 && split[0].len() > 0 && split[1].len() > 0 {
+        Ok(())
+    } else {
+        Err(MstError::InvalidKeyChars {
+            key: key.to_string(),
+        }
+        .into())
+    };
 }
 
 /// Count shared prefix length between two strings
···
     #[test]
     fn test_validate_key_valid() {
         assert!(validate_key("app.bsky.feed.post/abc123").is_ok());
-        assert!(validate_key("foo.bar/test-key_2024").is_ok());
-        assert!(validate_key("a").is_ok());
+        assert!(validate_key("foo.bar.baz/test-key_2024").is_ok());
+        assert!(validate_key("com.example.test/a").is_ok());
     }
 
     #[test]