Method execute

src/map.rs:82–145

(&self, _: &[ChildRef])

    V: Serialize + Sync + ParcodeVisitor,
{
    fn execute(&self, _: &[ChildRef]) -> Result<Vec<u8>> {
        let count = self.items.len();
        if count == 0 {
            return Ok(Vec::new());
        }

        // Temporary buffers for SOA components
        let mut data_blob = Vec::new();
        let mut offsets = Vec::with_capacity(count * 4);
        let mut hashes = Vec::with_capacity(count * 8);

        let mut cursor = std::io::Cursor::new(&mut data_blob);

        for (k, v) in &self.items {
            // 1. Compute and store hash (for fast lookup)
            hashes.extend_from_slice(&hash_key(k).to_le_bytes());

            // 2. Record current offset in data blob (for random access)
            let pos = u32::try_from(cursor.position())
                .map_err(|_| ParcodeError::Serialization("Data blob exceeds 4GB".into()))?;
            offsets.extend_from_slice(&pos.to_le_bytes());

            // 3. Serialize (K, V) tuple to data blob
            //    Both key and value are stored to enable collision resolution
            //    We serialize K using standard bincode, and V using serialize_shallow
            //    to respect chunkable fields.
            bincode::serde::encode_into_std_write(k, &mut cursor, bincode::config::standard())
                .map_err(|e| ParcodeError::Serialization(e.to_string()))?;

            v.serialize_shallow(&mut cursor)?;
        }

        // 4. Assemble final buffer with proper alignment
        // Header: Count (4 bytes)
        // Alignment target for Hashes is 8 bytes
        // Current size: 4. Padding needed: 4

        let hashes_size = count * 8;
        let offsets_size = count * 4;
        let total_size = 8 + hashes_size + offsets_size + data_blob.len();

        let mut final_buf = Vec::with_capacity(total_size);

        // Write Count (u32 LE)
        final_buf.extend_from_slice(
            &u32::try_from(count)
                .map_err(|_| ParcodeError::Serialization("Shard count exceeds u32".into()))?
                .to_le_bytes(),
        );

        // Write Padding (4 bytes of zeros for 8-byte alignment)
        final_buf.extend_from_slice(&[0u8; 4]);

        // Write Hashes (Aligned at offset 8)
        final_buf.extend_from_slice(&hashes);

        // Write Offsets
        final_buf.extend_from_slice(&offsets);