improve locking

README.md

···
 # bindle-file
 
-`bindle` is a general purpose, binary archive format designed for efficient reads and writes.
+[bindle](https://en.wikipedia.org/wiki/Bindle) is a general purpose binary archive
+format for collecting files.

SPEC.md

···
 - **Shadowing:** New versions of existing files are simply appended to the end of the data segment. The file remains append-only until a vacuum operation is performed.
 
 ### 2.3 Index Entry
-The index is a series of entries. Each entry consists of a fixed metadata block followed by a variable-length filename.
+The index is a series of entries. Each entry consists of a fixed metadata block followed by a variable-length filename. All multi-byte integers are stored in little-endian byte order.
 
 | Field | Size | Type | Description |
 | :--- | :--- | :--- | :--- |
 | `offset` | 8 bytes | u64 | Absolute file offset to the data blob |
 | `c_size` | 8 bytes | u64 | Compressed size on disk |
 | `u_size` | 8 bytes | u64 | Original uncompressed size |
-| `crc32` | 4 bytes | u32 | Checksum of the stored data |
+| `crc32` | 4 bytes | u32 | CRC32 checksum of the uncompressed data |
 | `name_len` | 2 bytes | u16 | Length of the filename string |
-| `comp_type` | 1 byte | u8 | `0` = Raw, `1` = Zstandard |
+| `comp_type` | 1 byte | u8 | `0` = None, `1` = Zstd |
 | `reserved` | 1 byte | u8 | Alignment padding |
 | `filename` | Variable | UTF-8 | The entry name |
 
 **Padding:** After the filename, the file MUST be padded with null bytes (`\0`) to the next 8-byte boundary before the next entry begins.
 
 ### 2.4 Footer
-The last 16 bytes of the file are used to locate the index. Both fields are stored in little-endian format.
+The last 16 bytes of the file are used to locate the index. All fields are stored in little-endian format.
 
 | Field | Size | Type | Description |
 | :--- | :--- | :--- | :--- |
 | `index_offset` | 8 bytes | u64 | Absolute offset to the start of the index |
 | `entry_count` | 4 bytes | u32 | Total number of unique entries in the index |
-| `magic`       | 4 bytes | u32 | Magic sentinel value `62 62 62 62` (ASCII: `bbbb`).
+| `magic`       | 4 bytes | u32 | Magic sentinel value `0x62626262` (ASCII: `bbbb`)
 
 ---
 
···
 ### 3.2 Vacuuming
 To reclaim space used by shadowed data:
 1. Create a temporary file and write the `BINDL001` header.
-2. Iterate through the **live** index entries only.
-3. Copy the referenced data blobs to the new file, updating their offsets in a new in-memory index.
-4. Write the new Index and Footer to the temporary file.
-5. Atomically replace the old file with the new one.
+2. Iterate through the **live** index entries only, copying referenced data from the original.
+3. Write the new Index and Footer to the temporary file.
+4. Atomically replace the original file with the temporary file.
+5. On failure, delete the temporary file.
 
 ---
 

src/bindle.rs

···
     }
 
     pub fn vacuum(&mut self) -> io::Result<()> {
-        let backup_path = self.path.with_extension("backup");
+        let temp_path = self.path.with_extension("tmp");
 
-        // Release locks and close current file
-        drop(self.mmap.take());
-        let _ = self.file.unlock();
-
-        // Rename original to backup
-        std::fs::rename(&self.path, &backup_path)?;
-
-        // Open backup for reading
-        let mut backup_file = File::open(&backup_path)?;
-
-        // Create new file at original path
+        // Create and lock temp file
         let result = {
-            let mut new_file = OpenOptions::new()
+            let mut temp_file = OpenOptions::new()
                 .write(true)
                 .read(true)
                 .create(true)
                 .truncate(true)
-                .open(&self.path)?;
+                .open(&temp_path)?;
 
-            new_file.write_all(BNDL_MAGIC)?;
+            temp_file.lock_exclusive()?;
+            temp_file.write_all(BNDL_MAGIC)?;
             let mut current_offset = HEADER_SIZE as u64;
 
-            // Copy only live entries from backup to new file
+            // Copy only live entries from original to temp
             for entry in self.index.values_mut() {
                 let mut buf = vec![0u8; entry.compressed_size() as usize];
-                backup_file.seek(SeekFrom::Start(entry.offset()))?;
-                backup_file.read_exact(&mut buf)?;
+                self.file.seek(SeekFrom::Start(entry.offset()))?;
+                self.file.read_exact(&mut buf)?;
 
-                new_file.seek(SeekFrom::Start(current_offset))?;
-                new_file.write_all(&buf)?;
+                temp_file.seek(SeekFrom::Start(current_offset))?;
+                temp_file.write_all(&buf)?;
 
                 entry.set_offset(current_offset);
                 let pad = pad::<8, u64>(entry.compressed_size());
                 if pad > 0 {
-                    write_padding(&mut new_file, pad as usize)?;
+                    write_padding(&mut temp_file, pad as usize)?;
                 }
                 current_offset += entry.compressed_size() + pad;
             }
···
             // Write the index and footer
             let index_start = current_offset;
             for (name, entry) in &self.index {
-                new_file.write_all(entry.as_bytes())?;
-                new_file.write_all(name.as_bytes())?;
+                temp_file.write_all(entry.as_bytes())?;
+                temp_file.write_all(name.as_bytes())?;
                 let pad = pad::<BNDL_ALIGN, usize>(ENTRY_SIZE + name.len());
                 if pad > 0 {
-                    write_padding(&mut new_file, pad)?;
+                    write_padding(&mut temp_file, pad)?;
                 }
             }
 
             let footer = Footer::new(index_start, self.index.len() as u32, FOOTER_MAGIC);
-            new_file.write_all(footer.as_bytes())?;
-            new_file.sync_all()?;
+            temp_file.write_all(footer.as_bytes())?;
+            temp_file.sync_all()?;
 
             Ok(())
         };
 
         // Handle result
-        match result {
-            Ok(()) => {
-                // Success - delete backup
-                std::fs::remove_file(&backup_path).ok();
-            }
-            Err(e) => {
-                // Failure - restore from backup
-                std::fs::remove_file(&self.path).ok();
-                std::fs::rename(&backup_path, &self.path).ok();
-                return Err(e);
-            }
+        if let Err(e) = result {
+            std::fs::remove_file(&temp_path).ok();
+            return Err(e);
         }
+
+        // Acquire exclusive lock just before rename to prevent concurrent access
+        self.file.lock_exclusive()?;
+
+        // Release locks and close current file
+        drop(self.mmap.take());
+        let _ = self.file.unlock();
+
+        // Atomically replace original with temp
+        std::fs::rename(&temp_path, &self.path)?;
 
         // Re-open the new file
         let file = OpenOptions::new().read(true).write(true).open(&self.path)?;
···
     }
 
     pub fn writer<'a>(&'a mut self, name: &str, compress: Compress) -> io::Result<Writer<'a>> {
+        self.file.lock_exclusive()?;
         self.file.seek(SeekFrom::Start(self.data_end))?;
         let compress = self.should_auto_compress(compress, 0);
         let f = self.file.try_clone()?;

src/writer.rs

···
 
         self.bindle.index.insert(self.name.clone(), entry);
         self.name.clear(); // Mark as closed
+
+        // Downgrade to shared lock after write completes
+        self.bindle.file.lock_shared()?;
         Ok(())
     }