Struct FibCodeV1 

pub struct FibCodeV1 {
    pub schema_version: String,
    pub profile_digest: String,
    pub codebook_digest: String,
    pub rotation_digest: String,
    pub ambient_dim: u32,
    pub block_dim: u32,
    pub norm_format: NormFormat,
    pub norm_payload: Vec<u8>,
    pub wire_index_bits: u8,
    pub block_count: u32,
    pub indices: Vec<u8>,
}

Encoded fixed-rate FibQuant artifact.

Fields

schema_version: String

Stable schema marker.

profile_digest: String

Profile digest.

codebook_digest: String

Codebook digest.

rotation_digest: String

Rotation digest.

ambient_dim: u32

Ambient dimension.

block_dim: u32

Block dimension.

norm_format: NormFormat

Norm payload format.

norm_payload: Vec<u8>

Norm bytes.

wire_index_bits: u8

Bits per fixed-rate index.

block_count: u32

Number of indices.

indices: Vec<u8>

Packed fixed-rate indices.

Implementations

impl FibCodeV1

pub fn to_compact_bytes(&self) -> Vec<u8>

Compact binary wire format. The FibCodeV1 struct carries a lot of metadata for JSON deserialization (schema_version, profile_digest, rotation_digest, ambient_dim, block_dim, etc.) that the decoder either doesn’t need (it has its own profile) or can reconstruct from the manifest (profile_digest/codebook_digest/rotation_digest).

Compact layout (little-endian, packed): [0..3] magic: “FB1” [3] version: 1 [4] wire_index_bits [5..9] block_count (u32) [9..11] norm_payload (length-prefixed, max 65535 bytes) actually: [9..11] norm_len (u16) + norm bytes then indices bytes

The decoder must already know the profile (or have the manifest supply it). It can re-derive the digests from that profile and check them at the manifest level. Per-block we only need wire_index_bits, block_count, norm_payload, and indices.

For fib_k4_n32 with head_dim=64: 16 indices * 5 bits = 10 bytes indices + 2 bytes norm = 12 bytes payload + 11 bytes header = 23 bytes per block vs 474 bytes for JSON = 20.6x smaller.

pub fn from_compact_bytes( bytes: &[u8], profile: &FibQuantProfileV1, ) -> Result<Self>

Decode the compact binary format. The caller must supply the profile so that the profile/codebook digests in the resulting FibCodeV1 match what validate_code_header expects.

The compact format omits the digests because they’re derivable from the profile — there’s no point storing them when the decoder will check them against the profile digest anyway.

pub fn compact_size(&self) -> usize

Compact size in bytes (does not allocate).

pub fn to_compact_v2_bytes(&self, flags: CompactFeatureFlags) -> Vec<u8>

Compact v2 binary wire format with feature flags.

Layout (little-endian, packed): [0..3] magic: “FB2” [3] version: 1 [4] feature_flags [5] wire_index_bits [6..10] block_count (u32) [10..12] norm_len (u16) [12..12+norm_len] norm bytes then indices bytes

The v2 format adds a 1-byte feature flags field at offset 4, enabling forward-compatible extensions. Unknown flags are ignored by the decoder.

pub fn from_compact_v2_bytes( bytes: &[u8], profile: &FibQuantProfileV1, ) -> Result<(Self, CompactFeatureFlags)>

Decode the v2 compact binary format. Accepts any feature flags — unknown flags are silently ignored (forward compatibility). Known flags that alter the payload layout are handled.

Trait Implementations

impl Clone for FibCodeV1

fn clone(&self) -> FibCodeV1

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FibCodeV1

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FibCodeV1

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for FibCodeV1

impl PartialEq for FibCodeV1

fn eq(&self, other: &FibCodeV1) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for FibCodeV1

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for FibCodeV1