Struct BundleManifest 

pub struct BundleManifest {
    pub schema_version: u32,
    pub name: String,
    pub runtime: BundleRuntime,
    pub requires_contract: ContractVersion,
    pub content: BTreeMap<String, BundleHash>,
}

The parsed manifest.toml at a bundle’s root — the bundle’s identity plus the per-file content map that makes it content-addressed.

Fields

schema_version: u32

Wire-format version. Always SCHEMA_VERSION today.

name: String

Human-readable bundle name, e.g. "yah-marketing". Not part of the content-address surface beyond the digest — two bundles with the same bytes but different names have different digests.

runtime: BundleRuntime

Runtime selection ("self" / "mesofact/<ver>").

requires_contract: ContractVersion

The bundle↔runtime contract version this bundle was built against (R746-F6). Whatever serves it must advertise this version; see contract for what the four clauses of version 1 are.

Defaulted rather than required so a bundle published before the field existed still parses — and parses as exactly what it is, since every such bundle was assembled against contract 1. That default is also what keeps their digests intact; see BundleManifest::digest.

Declared before content because TOML puts a table’s keys after it — a scalar field serialized after [content] would land inside the table.

content: BTreeMap<String, BundleHash>

Every file the bundle carries, keyed by its path within the bundle (e.g. "app/dist/index.html", "bins/x86_64-unknown-linux-musl/serve") mapped to its BLAKE3 content hash. Sorted (BTreeMap) so the manifest serialization — and therefore the digest — is deterministic.

Implementations

impl BundleManifest

pub fn from_toml_str(s: &str) -> Result<Self, BundleError>

Parse a manifest.toml string, rejecting an unknown schema version.

pub fn to_toml_string(&self) -> Result<String, BundleError>

Serialize back to manifest.toml form.

pub fn digest(&self) -> BundleHash

The bundle’s content-address: a BLAKE3 digest over the manifest’s identity + content map.

Computed over a canonical, order-stable byte encoding (not the TOML text, which whitespace/comments could perturb): schema_version, name, the runtime wire string, then every (path, hash) pair in sorted path order. Any change to any file’s bytes (its hash), the name, the runtime, or the file set flips the digest — that immutability is what makes rollback a pointer flip and eviction a no-invalidation affair (W272 §1).

requires_contract is fed only when it is not 1 (R746-F6). It is identity-affecting — two bundles differing only in the interface they demand are different bundles — but feeding it unconditionally would re-hash every already published manifest to a new value, and [fetch_manifest] verifies a fetched manifest against the digest it was stored under. Every such manifest defaults to 1, so skipping the default leaves their encoding byte-identical while any bundle requiring contract ≥ 2 still gets a distinct digest. The skip is not a place-holder to tidy up later: the manifests it protects are immutable and permanent.

Trait Implementations

impl Clone for BundleManifest

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BundleManifest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BundleManifest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for BundleManifest

impl PartialEq for BundleManifest

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for BundleManifest

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 BundleManifest