Struct UnsavedFs 

pub struct UnsavedFs {
    pub meta: WorldMeta,
    pub worlds: HashMap<usize, UnsavedWorld>,
    pub prefabs: IndexMap<String, Vec<u8>>,
}

All of the dynamic data needed to serialize a world

Fields

meta: WorldMeta

Meta/

worlds: HashMap<usize, UnsavedWorld>

World/

prefabs: IndexMap<String, Vec<u8>>

Prefabs/ - embedded prefab archives, root-relative path → raw bytes.

Implementations

impl UnsavedFs

pub fn to_pending(self) -> Result<BrPendingFs, BrError>

Examples found in repository

examples/write_fixtures.rs (line 380)

fn spawner_world() -> World {
    // Prefab-embedding fixture: an outer prefab whose spawner gate references
    // an inner single-brick prefab embedded at Prefabs/Uploads/<BLAKE3>.brz.
    // Single grid, single chunk, one insertion-ordered prefab map entry —
    // fully deterministic. The inner archive is written raw (no zstd) so the
    // embedded bytes are cross-language reproducible.
    let mut inner = World::new();
    inner.meta.bundle.description = "Inner prefab".to_string();
    inner.bricks.push(Brick {
        position: (0, 0, 6).into(),
        color: (255, 0, 0).into(),
        ..Default::default()
    });
    inner.make_prefab();
    let inner_bytes = {
        let pending = inner.to_unsaved().unwrap().to_pending().unwrap();
        let mut buf = Vec::new();
        pending
            .to_brz_data(None)
            .unwrap()
            .write(&mut buf, None)
            .unwrap();
        buf
    };

    let mut world = World::new();
    world.register_all_components();
    world.meta.bundle.description = "Spawner fixture".to_string();
    let prefab_path = world.add_prefab(inner_bytes);
    world.bricks.push(
        Brick {
            asset: brdb::BrickType::str("B_1x1_Gate_Exec_PrefabSpawner"),
            position: (0, 0, 1).into(),
            ..Default::default()
        }
        .with_component(
            assets::LiteralComponent::new("BrickComponentType_WireGraph_Exec_PrefabSpawner")
                .with_data([(
                    "Prefab",
                    Box::new(prefab_path) as Box<dyn AsBrdbValue>,
                )]),
        ),
    );
    world.make_prefab();
    world
}

fn hash_archive(path: &PathBuf) -> Result<BTreeMap<String, serde_json::Value>, Box<dyn std::error::Error>> {
    fn collect(fs: &BrFs, prefix: &str, out: &mut Vec<(String, Option<i64>)>) {
        match fs {
            BrFs::Root(children) => for (n, c) in children { collect(c, n, out); },
            BrFs::Folder(_, children) => for (n, c) in children {
                collect(c, &format!("{prefix}/{n}"), out);
            },
            BrFs::File(f) => out.push((prefix.to_string(), f.content_id)),
        }
    }
    let reader = Brz::open(path)?.into_reader();
    let reader = &*reader;
    let mut files = Vec::new();
    collect(&reader.get_fs()?, "", &mut files);
    let mut out = BTreeMap::new();
    for (p, content_id) in files {
        let content = match content_id {
            Some(id) => reader.find_blob(id)?.read()?,
            None => Vec::new(),
        };
        out.insert(p, serde_json::json!({
            "blake3": blake3::hash(&content).to_hex().to_string(),
            "len": content.len(),
        }));
    }
    Ok(out)
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("fixtures");
    fs::create_dir_all(dir.join("schemas"))?;

    let mut hashes = BTreeMap::new();
    for (name, world) in [
        ("brick", brick_world()),
        ("features", features_world()),
        ("chunks", chunks_world()),
        ("wires", wires_world()),
        ("components", components_world()),
        ("entities", entities_world()),
        ("spawner", spawner_world()),
    ] {
        let pending = world.to_unsaved()?.to_pending()?;
        // raw variant: no zstd anywhere — byte-comparable across languages
        let raw_path = dir.join(format!("{name}_raw.brz"));
        let mut f = fs::File::create(&raw_path)?;
        pending.clone().to_brz_data(None)?.write(&mut f, None)?;
        // compressed variant: zstd level 14 (matches Brz::save)
        let mut f = fs::File::create(dir.join(format!("{name}.brz")))?;
        pending.to_brz_data(Some(14))?.write(&mut f, Some(14))?;

        // .brdb variant: content parity only (the .brdb container is not
        // byte-deterministic across runs).
        let db_path = dir.join(format!("{name}.brdb"));
        let _ = fs::remove_file(&db_path);
        Brdb::create(&db_path)?.save("Fixture", &world)?;

        hashes.insert(name.to_string(), hash_archive(&raw_path)?);
    }
    fs::write(dir.join("hashes.json"), serde_json::to_string_pretty(&hashes)?)?;

    // The nine embedded schemas as binary msgpack (the exact bytes the
    // writer embeds as *.schema files inside archives).
    for (name, schema) in [
        ("BRSavedGlobalDataSoA", schemas::global_data_schema()),
        ("BRSavedOwnerTableSoA", schemas::owners_schema()),
        ("BRSavedBrickChunkIndexSoA", schemas::bricks_chunk_index_schema()),
        ("BRSavedBrickChunkSoA", schemas::bricks_chunks_schema()),
        ("BRSavedWireChunkSoA", schemas::bricks_wires_schema()),
        ("BRSavedComponentChunkSoA", schemas::bricks_components_schema_min()),
        ("BRSavedComponentChunkSoA_max", schemas::bricks_components_schema_max()),
        ("BRSavedEntityChunkIndexSoA", schemas::entities_chunk_index_schema()),
        ("BRSavedEntityChunkSoA", schemas::entities_chunks_schema()),
    ] {
        fs::write(dir.join(format!("schemas/{name}.bin")), schema.to_bytes()?)?;
    }
    eprintln!("fixtures written to {}", dir.display());
    Ok(())
}