Remove irrelevant footer

Author: bbqsrc

Cargo.lock

@@ -748,45 +748,35 @@ The FST maps full paths (using `\x1F` unit separator between components, as desc
 
 ```
 +------------------+  Offset = trailer_end
-|     Header       |  16 bytes
+|     Header       |  24 bytes
 +------------------+
 |    Node Index    |  node_count × 8 bytes
 +------------------+
 |   Hot Section    |  Variable size (compact node headers)
 +------------------+
 |   Cold Section   |  Variable size (edge data)
-+------------------+
-|     Footer       |  16 bytes
 +------------------+  EOF
 ```
 
 ### 14.3 Header
 
-The FST Header is 16 bytes and located at the start of the FST section.
+The FST Header is 24 bytes and located at the start of the FST section.
 
 | Offset | Size | Field | Description |
 |--------|------|-------|-------------|
 | 0x00 | 4 | `magic` | Magic bytes: `BFST` (0x42 0x46 0x53 0x54) |
 | 0x04 | 1 | `version` | Format version (currently 1) |
-| 0x05 | 3 | `reserved` | Reserved bytes (must be 0) |
-| 0x08 | 8 | `entry_count` | Number of paths indexed (`u64`) |
-
-Implementations MUST reject FST data where magic bytes do not match or version is unsupported.
-
-### 14.4 Footer
+| 0x05 | 1 | `flags` | Reserved flags (must be 0) |
+| 0x06 | 2 | `reserved` | Reserved bytes (must be 0) |
+| 0x08 | 4 | `node_count` | Total number of nodes (`u32`) |
+| 0x0C | 8 | `entry_count` | Number of paths indexed (`u64`) |
+| 0x14 | 4 | `cold_offset` | Cold section start offset (`u32`) |
 
-The FST Footer is 16 bytes and located at the end of the FST section (last 16 bytes of the file).
+The Hot Section starts at offset `24 + node_count × 8` (immediately after the Node Index). The root node is always node 0.
 
-| Offset | Size | Field | Description |
-|--------|------|-------|-------------|
-| 0x00 | 4 | `root_id` | Root node ID (`u32`, always 0) |
-| 0x04 | 4 | `node_count` | Total number of nodes (`u32`) |
-| 0x08 | 4 | `hot_offset` | Hot section start offset (`u32`) |
-| 0x0C | 4 | `cold_offset` | Cold section start offset (`u32`) |
-
-The `hot_offset` and `cold_offset` are absolute byte offsets from the start of the FST section.
+Implementations MUST reject FST data where magic bytes do not match or version is unsupported.
 
-### 14.5 Node Index
+### 14.4 Node Index
 
 The Node Index is an array of `node_count` entries, with each entry being 8 bytes.
 
@@ -799,7 +789,7 @@ The Node Index is an array of `node_count` entries, with each entry being 8 byte
 
 Offsets are relative to the start of their respective sections. Node IDs are indices into this array (node 0 = first entry, node 1 = second entry, etc.).
 
-### 14.6 Hot Section
+### 14.5 Hot Section
 
 The Hot Section contains compact node headers optimized for cache efficiency. Each node's hot data has the following structure:
 
@@ -830,7 +820,7 @@ The lookup data format depends on the `INDEXED` flag:
 
 Array of `edge_count` entries, each a `u16`. Each offset points to the corresponding edge's data within this node's cold section data block.
 
-### 14.7 Cold Section
+### 14.6 Cold Section
 
 The Cold Section contains edge data and final output values. Each node's cold data has the following structure:
 
@@ -858,7 +848,7 @@ If IS_FINAL flag is set:
 
 If the `IS_FINAL` flag is set, the final output value is stored at the end of the node's cold data block. This value is added to the accumulated output when the traversal terminates at this node.
 
-### 14.8 Path Encoding in FST
+### 14.7 Path Encoding in FST
 
 Paths stored in the FST use the same encoding as BoxPath (Section 9):
 
@@ -872,7 +862,7 @@ Paths stored in the FST use the same encoding as BoxPath (Section 9):
 - Duplicate keys are not permitted
 - Values are `u64` record indices (as returned by `RecordIndex.get()`)
 
-### 14.9 Output Value Accumulation
+### 14.8 Output Value Accumulation
 
 The FST stores output values along edges and at final nodes. The final lookup value is computed by:
 
@@ -882,7 +872,7 @@ The FST stores output values along edges and at final nodes. The final lookup va
 
 The result is the `RecordIndex` value for the path.
 
-### 14.10 Implementation Notes
+### 14.9 Implementation Notes
 
 **Adaptive Node Format:**
 
@@ -903,13 +893,12 @@ Implementations MAY use SIMD instructions for compact node lookups:
 - x86_64: SSE2 `_mm_cmpeq_epi8` for 16-byte parallel comparison
 - aarch64: NEON `vceqq_u8` for similar parallel comparison
 
-### 14.11 Constants
+### 14.10 Constants
 
 | Constant | Value | Description |
 |----------|-------|-------------|
 | Magic | `BFST` | FST section identifier |
-| Version | 3 | Current format version |
-| Header size | 16 bytes | Fixed header size |
-| Footer size | 16 bytes | Fixed footer size |
+| Version | 1 | Current format version |
+| Header size | 24 bytes | Fixed header size |
 | Index entry size | 8 bytes | Per-node index entry |
 | Indexed threshold | 17 | Minimum edges for indexed format |

SPEC.md

@@ -1,7 +1,7 @@
 use crate::error::BuildError;
 use crate::node::{
-    EdgeData, FOOTER_SIZE, Footer, HEADER_SIZE, INDEX_ENTRY_SIZE, INDEXED_THRESHOLD, NodeData,
-    NodeIndex, write_footer, write_header, write_node_cold, write_node_hot,
+    EdgeData, HEADER_SIZE, Header, INDEX_ENTRY_SIZE, INDEXED_THRESHOLD, NodeData, NodeIndex,
+    write_header, write_node_cold, write_node_hot,
 };
 use fastvlq::encode_vu64;
 
@@ -74,14 +74,13 @@ impl FstBuilder {
 
         // Step 1: Assign node IDs and collect NodeData (depth-first)
         let mut nodes: Vec<NodeData> = Vec::new();
-        let root_id = self.collect_nodes(&self.root, &mut nodes);
+        let _root_id = self.collect_nodes(&self.root, &mut nodes);
 
         let node_count = nodes.len() as u32;
 
         // Step 2: Calculate layout
-        let index_start = HEADER_SIZE;
         let index_size = node_count as usize * INDEX_ENTRY_SIZE;
-        let hot_start = index_start + index_size;
+        let hot_start = HEADER_SIZE + index_size;
 
         // Step 3: Write hot section, tracking offsets
         let mut hot_buf = Vec::new();
@@ -119,11 +118,16 @@ impl FstBuilder {
         }
 
         // Step 5: Assemble final buffer
-        let total_size = HEADER_SIZE + index_size + hot_buf.len() + cold_buf.len() + FOOTER_SIZE;
+        let total_size = HEADER_SIZE + index_size + hot_buf.len() + cold_buf.len();
         let mut buf = Vec::with_capacity(total_size);
 
-        // Header
-        write_header(self.len, &mut buf);
+        // Header (includes node_count and cold_offset)
+        let header = Header {
+            entry_count: self.len,
+            node_count,
+            cold_offset: cold_start as u32,
+        };
+        write_header(&header, &mut buf);
 
         // Index
         for i in 0..nodes.len() {
@@ -140,15 +144,6 @@ impl FstBuilder {
         // Cold section
         buf.extend_from_slice(&cold_buf);
 
-        // Footer
-        let footer = Footer {
-            root_node_id: root_id,
-            node_count,
-            hot_start: hot_start as u32,
-            cold_start: cold_start as u32,
-        };
-        write_footer(&footer, &mut buf);
-
         Ok(buf)
     }
 }

crates/fst/src/builder.rs

@@ -1,8 +1,5 @@
 use crate::error::FstError;
-use crate::node::{
-    FOOTER_SIZE, Footer, HEADER_SIZE, INDEX_ENTRY_SIZE, NodeIndex, NodeRef, read_footer,
-    read_header,
-};
+use crate::node::{HEADER_SIZE, Header, INDEX_ENTRY_SIZE, NodeIndex, NodeRef, read_header};
 
 /// Prefetch memory for read.
 #[inline(always)]
@@ -105,23 +102,21 @@ struct EachState {
 /// Generic over `D: AsRef<[u8]>` to support zero-copy from memory-mapped data.
 pub struct Fst<D> {
     data: D,
-    footer: Footer,
-    len: u64,
+    header: Header,
 }
 
 impl<D: AsRef<[u8]>> Fst<D> {
     /// Open an FST from bytes.
     pub fn new(data: D) -> Result<Self, FstError> {
         let bytes = data.as_ref();
 
-        if bytes.len() < HEADER_SIZE + FOOTER_SIZE {
+        if bytes.len() < HEADER_SIZE {
             return Err(FstError::TooShort);
         }
 
-        let len = read_header(bytes)?;
-        let footer = read_footer(bytes).ok_or(FstError::TooShort)?;
+        let header = read_header(bytes)?;
 
-        Ok(Self { data, footer, len })
+        Ok(Self { data, header })
     }
 
     /// Get node index entry by node ID.
@@ -138,8 +133,8 @@ impl<D: AsRef<[u8]>> Fst<D> {
         let bytes = self.data.as_ref();
         let idx = self.get_node_index(node_id);
 
-        let hot_start = self.footer.hot_start as usize + idx.hot_offset as usize;
-        let cold_start = self.footer.cold_start as usize + idx.cold_offset as usize;
+        let hot_start = self.header.hot_offset() + idx.hot_offset as usize;
+        let cold_start = self.header.cold_offset as usize + idx.cold_offset as usize;
 
         let hot_data = &bytes[hot_start..];
         let cold_data = &bytes[cold_start..];
@@ -150,7 +145,7 @@ impl<D: AsRef<[u8]>> Fst<D> {
     /// Get the value for an exact key match.
     pub fn get(&self, key: &[u8]) -> Option<u64> {
         let bytes = self.data.as_ref();
-        let mut current_node_id = self.footer.root_node_id;
+        let mut current_node_id = 0u32; // Root is always node 0
         let mut remaining = key;
         let mut output_sum: u64 = 0;
 
@@ -165,7 +160,7 @@ impl<D: AsRef<[u8]>> Fst<D> {
             prefetch_read(
                 bytes
                     .as_ptr()
-                    .wrapping_add(self.footer.hot_start as usize + next_idx.hot_offset as usize),
+                    .wrapping_add(self.header.hot_offset() + next_idx.hot_offset as usize),
             );
 
             // Check if edge label matches
@@ -198,12 +193,12 @@ impl<D: AsRef<[u8]>> Fst<D> {
 
     /// Number of entries in the FST.
     pub fn len(&self) -> u64 {
-        self.len
+        self.header.entry_count
     }
 
     /// Check if the FST is empty.
     pub fn is_empty(&self) -> bool {
-        self.len == 0
+        self.header.entry_count == 0
     }
 
     /// Iterate all entries with a given prefix.
@@ -269,9 +264,9 @@ impl<D: AsRef<[u8]>> Fst<D> {
                 // Prefetch child node
                 let child_idx = self.get_node_index(child_node_id);
                 prefetch_read(
-                    bytes.as_ptr().wrapping_add(
-                        self.footer.hot_start as usize + child_idx.hot_offset as usize,
-                    ),
+                    bytes
+                        .as_ptr()
+                        .wrapping_add(self.header.hot_offset() + child_idx.hot_offset as usize),
                 );
 
                 key_buffer.extend_from_slice(edge.label);
@@ -296,7 +291,7 @@ impl<D: AsRef<[u8]>> Fst<D> {
     /// Navigate to prefix node.
     fn navigate_to_prefix(&self, prefix: &[u8], key_buffer: &mut Vec<u8>) -> Option<(u32, u64)> {
         let bytes = self.data.as_ref();
-        let mut current_node_id = self.footer.root_node_id;
+        let mut current_node_id = 0u32; // Root is always node 0
         let mut remaining = prefix;
         let mut output_sum: u64 = 0;
 
@@ -324,7 +319,7 @@ impl<D: AsRef<[u8]>> Fst<D> {
             prefetch_read(
                 bytes
                     .as_ptr()
-                    .wrapping_add(self.footer.hot_start as usize + next_idx.hot_offset as usize),
+                    .wrapping_add(self.header.hot_offset() + next_idx.hot_offset as usize),
             );
 
             if match_len >= remaining.len() {
@@ -387,7 +382,7 @@ impl<'a, D: AsRef<[u8]>> PrefixIter<'a, D> {
 
     fn navigate_to_prefix(&mut self, prefix: &[u8]) -> Option<(u32, u64)> {
         let bytes = self.fst.data.as_ref();
-        let mut current_node_id = self.fst.footer.root_node_id;
+        let mut current_node_id = 0u32; // Root is always node 0
         let mut remaining = prefix;
         let mut output_sum: u64 = 0;
 
@@ -413,9 +408,9 @@ impl<'a, D: AsRef<[u8]>> PrefixIter<'a, D> {
             // Prefetch next node
             let next_idx = self.fst.get_node_index(edge.target_node_id);
             prefetch_read(
-                bytes.as_ptr().wrapping_add(
-                    self.fst.footer.hot_start as usize + next_idx.hot_offset as usize,
-                ),
+                bytes
+                    .as_ptr()
+                    .wrapping_add(self.fst.header.hot_offset() + next_idx.hot_offset as usize),
             );
 
             if match_len >= remaining.len() {
@@ -467,9 +462,11 @@ impl<D: AsRef<[u8]>> Iterator for PrefixIter<'_, D> {
 
                 // Prefetch child node
                 let child_idx = self.fst.get_node_index(child_node_id);
-                prefetch_read(bytes.as_ptr().wrapping_add(
-                    self.fst.footer.hot_start as usize + child_idx.hot_offset as usize,
-                ));
+                prefetch_read(
+                    bytes
+                        .as_ptr()
+                        .wrapping_add(self.fst.header.hot_offset() + child_idx.hot_offset as usize),
+                );
 
                 self.key_buffer.extend_from_slice(edge.label);
                 let child_key_len = self.key_buffer.len();