Struct EmbedManifest 

pub struct EmbedManifest {
    pub version: u32,
    pub repo_path: String,
    pub commit_hash: Option<String>,
    pub updated_at: Option<u64>,
    pub settings: EmbedSettings,
    pub chunks: BTreeMap<String, ManifestEntry>,
    pub checksum: Option<String>,
}

Manifest tracking all chunks for incremental updates

Determinism Note

The manifest binary file is not byte-deterministic across saves due to the updated_at timestamp. However, the checksum is deterministic because it excludes the timestamp from its calculation.

For comparing manifests:

• Wrong: Compare raw binary files (will differ due to timestamp)
• Right: Compare checksums via manifest.checksum (deterministic)

This design allows incremental updates while still detecting actual content changes.

CI/CD Integration

If you need byte-deterministic manifests (e.g., for Docker layer caching):

• Compare checksums instead of file hashes
• Or set updated_at = None before saving in test environments

Fields

version: u32

Manifest format version

repo_path: String

Relative repository path (from git root or CWD)

commit_hash: Option<String>

Git commit hash when manifest was created (for reference only) Note: We always serialize Option fields for bincode compatibility

updated_at: Option<u64>

Timestamp of last update (Unix seconds)

Important: This field is excluded from the integrity checksum calculation to allow the checksum to remain stable across re-saves of unchanged content. The binary file will differ byte-for-byte on each save, but the checksum will only change if actual chunk content changes.

settings: EmbedSettings

Settings used to generate chunks (part of integrity)

chunks: BTreeMap<String, ManifestEntry>

All chunks indexed by location key Using BTreeMap for deterministic iteration order (critical for cross-platform consistency)

checksum: Option<String>

Integrity checksum (BLAKE3 of settings + sorted chunk entries) Excluded from serialization, computed on save, verified on load

Implementations

impl EmbedManifest

pub fn new(repo_path: String, settings: EmbedSettings) -> Self

Create a new empty manifest

pub fn location_key(file: &str, symbol: &str, kind: ChunkKind) -> String

Generate deterministic location key for a chunk

Format: file::symbol::kind Uses :: as separator (unlikely in paths/symbols)

pub fn save(&mut self, path: &Path) -> Result<(), EmbedError>

Save manifest to file with integrity checksum

Behavior

This method:

1. Updates updated_at to the current timestamp
2. Computes a new checksum (excluding timestamp)
3. Serializes to bincode format

Determinism

The resulting binary file is not byte-deterministic because the timestamp changes on every save. However, the checksum is deterministic - it only changes when actual chunk content or settings change.

For deterministic testing, set self.updated_at = None before saving.

Note

This method mutates self to set checksum and timestamp. This avoids cloning the entire manifest (which can be large).

pub fn load(path: &Path) -> Result<Self, EmbedError>

Load manifest from file with integrity verification

pub fn load_if_exists(path: &Path) -> Result<Option<Self>, EmbedError>

Load manifest if it exists, otherwise return None

pub fn update(&mut self, chunks: &[EmbedChunk]) -> Result<(), EmbedError>

Update manifest with current chunks, detecting collisions

pub fn diff(&self, current_chunks: &[EmbedChunk]) -> EmbedDiff

Compute diff between current chunks and manifest

pub fn settings_match(&self, settings: &EmbedSettings) -> bool

Check if settings match the manifest settings

pub fn chunk_count(&self) -> usize

Get the number of chunks in the manifest

Trait Implementations

impl Clone for EmbedManifest

fn clone(&self) -> EmbedManifest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EmbedManifest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EmbedManifest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for EmbedManifest

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

where __S: Serializer,

Serialize this value into the given Serde serializer.