Merge pull request #35 from wowemulation-dev/fix/encoding-lookup-and-toc-hash

fix: encoding page lookup and archive group TOC hash

Author: danielsreichenbach

crates/cascette-formats/src/archive/archive_group.rs

@@ -198,10 +198,18 @@ impl ArchiveGroupBuilder {
         let total_data_size = entry_count * bytes_per_entry;
         let chunk_count = total_data_size.div_ceil(0x1000); // 4KB chunks
 
-        // Write entries in chunks (archive-groups don't use TOC)
+        // Write entries in chunks, collecting first keys for TOC hash
+        let entries_per_chunk = 0x1000 / bytes_per_entry;
+        let mut toc_keys: Vec<Vec<u8>> = Vec::with_capacity(chunk_count);
+
         for chunk_idx in 0..chunk_count {
-            let start_idx = chunk_idx * (0x1000 / bytes_per_entry);
-            let end_idx = ((chunk_idx + 1) * (0x1000 / bytes_per_entry)).min(entry_count);
+            let start_idx = chunk_idx * entries_per_chunk;
+            let end_idx = ((chunk_idx + 1) * entries_per_chunk).min(entry_count);
+
+            // Record first key of each chunk for TOC hash
+            if let Some(first_entry) = entries.get(start_idx) {
+                toc_keys.push(first_entry.encoding_key.clone());
+            }
 
             // Prepare chunk data
             let mut chunk_data = Vec::with_capacity(0x1000);
@@ -223,10 +231,11 @@ impl ArchiveGroupBuilder {
             writer.write_all(&chunk_data)?;
         }
 
-        // Write footer
+        // Write footer with computed TOC hash
+        let toc_hash = super::index::calculate_toc_hash(&toc_keys);
         let footer = IndexFooter {
-            toc_hash: [0; 8], // No TOC hash for archive-groups
-            version: 1,       // Standard version
+            toc_hash,
+            version: 1, // Standard version
             reserved: [0, 0],
             page_size_kb: 4,
             offset_bytes: 6, // 6-byte offsets for archive-groups!

crates/cascette-formats/src/encoding/file.rs

@@ -341,38 +341,77 @@ impl EncodingFile {
     }
 
     /// Find encoding key for a content key
+    ///
+    /// Uses binary search on the page index to find the candidate page,
+    /// then linear scan within that page.
     pub fn find_encoding(&self, content_key: &ContentKey) -> Option<EncodingKey> {
-        // Binary search through pages to find the right page
-        for page in &self.ckey_pages {
-            for entry in &page.entries {
-                if entry.content_key == *content_key {
-                    return entry.encoding_keys.first().copied();
-                }
+        let key_bytes = *content_key.as_bytes();
+
+        // Binary search through the page index to find the right page.
+        // Each page's first_key is the lowest key in that page, and pages
+        // are sorted. We find the last page whose first_key <= our key.
+        let page_idx = self
+            .ckey_index
+            .partition_point(|idx| idx.first_key <= key_bytes);
+
+        // partition_point returns the first index where first_key > key,
+        // so the candidate page is at page_idx - 1
+        if page_idx == 0 {
+            return None;
+        }
+
+        let page = &self.ckey_pages[page_idx - 1];
+        for entry in &page.entries {
+            if entry.content_key == *content_key {
+                return entry.encoding_keys.first().copied();
             }
         }
         None
     }
 
     /// Find all encoding keys for a given content key
+    ///
+    /// Uses binary search on the page index to find the candidate page,
+    /// then linear scan within that page.
     pub fn find_all_encodings(&self, content_key: &ContentKey) -> Vec<EncodingKey> {
-        for page in &self.ckey_pages {
-            for entry in &page.entries {
-                if entry.content_key == *content_key {
-                    return entry.encoding_keys.clone();
-                }
+        let key_bytes = *content_key.as_bytes();
+
+        let page_idx = self
+            .ckey_index
+            .partition_point(|idx| idx.first_key <= key_bytes);
+
+        if page_idx == 0 {
+            return Vec::new();
+        }
+
+        let page = &self.ckey_pages[page_idx - 1];
+        for entry in &page.entries {
+            if entry.content_key == *content_key {
+                return entry.encoding_keys.clone();
             }
         }
         Vec::new()
     }
 
     /// Find `ESpec` for an encoding key
+    ///
+    /// Uses binary search on the page index to find the candidate page,
+    /// then linear scan within that page.
     pub fn find_espec(&self, encoding_key: &EncodingKey) -> Option<&str> {
-        // Search through EKey pages
-        for page in &self.ekey_pages {
-            for entry in &page.entries {
-                if entry.encoding_key == *encoding_key {
-                    return self.espec_table.get(entry.espec_index);
-                }
+        let key_bytes = *encoding_key.as_bytes();
+
+        let page_idx = self
+            .ekey_index
+            .partition_point(|idx| idx.first_key <= key_bytes);
+
+        if page_idx == 0 {
+            return None;
+        }
+
+        let page = &self.ekey_pages[page_idx - 1];
+        for entry in &page.entries {
+            if entry.encoding_key == *encoding_key {
+                return self.espec_table.get(entry.espec_index);
             }
         }
         None