tensorfs 0.3.22__tar.gz → 0.3.24__tar.gz

{tensorfs-0.3.22 → tensorfs-0.3.24}/Cargo.lock

@@ -392,7 +392,7 @@ checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tensorfs-core"
-version = "0.3.22"
+version = "0.3.24"
 dependencies = [
  "fs2",
  "minicbor",
@@ -404,7 +404,7 @@ dependencies = [
 
 [[package]]
 name = "tensorfs-py"
-version = "0.3.22"
+version = "0.3.24"
 dependencies = [
  "pyo3",
  "tensorfs-core",

{tensorfs-0.3.22 → tensorfs-0.3.24}/Cargo.toml

@@ -3,5 +3,5 @@ resolver = "2"
 members = ["crates/tensorfs-core", "crates/tensorfs-py"]
 
 [workspace.package]
-version = "0.3.22"
+version = "0.3.24"
 edition = "2021"

{tensorfs-0.3.22 → tensorfs-0.3.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensorfs
-Version: 0.3.22
+Version: 0.3.24
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Rust

{tensorfs-0.3.22 → tensorfs-0.3.24}/crates/tensorfs-core/src/checkpoint.rs

@@ -477,7 +477,11 @@ pub fn walk_cozytensors(store: &Store, snap: &Manifest) -> Result<Walk> {
 /// Repository completeness, checkout, retention, and accounting use this full walk; workers
 /// use `walk_cozytensors` because an optional README or sample image is not a runtime input.
 pub fn walk(store: &Store, snap: &Manifest) -> Result<Walk> {
-    let mut w = walk_cozytensors(store, snap)?;
+    let mut w = if snap.header().is_some() {
+        walk_cozytensors(store, snap)?
+    } else {
+        Walk::default()
+    };
 
     // Anything listed that the header does not account for is a sibling asset — with two
     // audit-driven tightenings (external review, folded in at tfs-003):

{tensorfs-0.3.22 → tensorfs-0.3.24}/crates/tensorfs-core/src/providers.rs

@@ -392,12 +392,18 @@ fn list_observed(
                         format!("member name {name:?} is outside the grammar"),
                     );
                 }
+                let file_id = json_u64(file, "id")
+                    .filter(|id| *id > 0 && *id < (1u64 << 53))
+                    .ok_or_else(|| Refusal {
+                        code: Code::KEY_GRAMMAR,
+                        detail: "a Civitai file requires a positive exact integer id".into(),
+                    })?;
                 let sha256 = json_get(file, "hashes")
                     .and_then(|hashes| json_str(hashes, "SHA256"))
                     .and_then(digest64);
                 let url = match json_str(file, "downloadUrl") {
                     Some(explicit) => explicit.to_string(),
-                    None => format!("{base}/api/download/models/{version}"),
+                    None => format!("{base}/api/download/models/{version}?fileId={file_id}"),
                 };
                 // A Civitai version is a bag of files (weights, a VAE, a config); the
                 // one to take is the `primary` SafeTensors file, exactly as the Go
@@ -413,7 +419,9 @@ fn list_observed(
                 // sizeKB is kilobytes as a float — an approximation, not a length.
                 // The exact length is probed from the origin at pull time.
                 members.push(SourceMember {
-                    member: name.to_string(),
+                    // Display filenames may change; the provider file ID is the reviewed
+                    // profile member identity, shared with Creator and retained source trees.
+                    member: format!("civitai/files/{file_id}"),
                     length: None,
                     sha256,
                     url,
@@ -1040,6 +1048,14 @@ fn is_safetensors(member: &str) -> bool {
     lower_ends_with(member, ".safetensors")
 }
 
+/// Civitai carrier members have provider IDs rather than filename extensions.
+pub(crate) fn is_civitai_member(member: &str) -> bool {
+    member.strip_prefix("civitai/files/").is_some_and(|id| {
+        id.parse::<u64>()
+            .is_ok_and(|value| value > 0 && value < (1u64 << 53) && value.to_string() == id)
+    })
+}
+
 /// Resolve `relative` against the directory of `member`, the way the Go resolver's
 /// `path.Clean(path.Join(path.Dir(member), shard))` does. `None` when the reference walks
 /// above the repository root — an index may not name its way out of its own tree.
@@ -1970,12 +1986,16 @@ mod tests {
     /// so the exact length comes from a ranged probe through the same fence.
     #[test]
     fn resolve_takes_the_one_primary_civitai_safetensors() {
-        let body: Vec<u8> = (0u32..9_000).flat_map(|i| i.to_le_bytes()).collect();
+        let header =
+            br#"{"model.diffusion_model.weight":{"dtype":"F32","shape":[1],"data_offsets":[0,4]}}"#;
+        let mut body = (header.len() as u64).to_le_bytes().to_vec();
+        body.extend_from_slice(header);
+        body.extend_from_slice(&1f32.to_le_bytes());
         let object = ObjectRef::of(&body);
         let listing = format!(
             r#"{{"id":777,"files":[
-               {{"name":"model.safetensors","primary":true,"sizeKB":35.15,"hashes":{{"SHA256":"{}"}},"metadata":{{"format":"SafeTensor"}}}},
-               {{"name":"extra.safetensors","primary":false,"sizeKB":1.0,"hashes":{{"SHA256":"{}"}}}}
+               {{"id":92696,"name":"model.safetensors","primary":true,"sizeKB":35.15,"hashes":{{"SHA256":"{}"}},"metadata":{{"format":"SafeTensor"}}}},
+               {{"id":92697,"name":"extra.safetensors","primary":false,"sizeKB":1.0,"hashes":{{"SHA256":"{}"}}}}
             ]}}"#,
             object.sha256.to_ascii_uppercase(),
             "11".repeat(32)
@@ -1999,12 +2019,101 @@ mod tests {
         };
         let resolved = resolve(&uri, &endpoints, &Anonymous, Deadline::none()).unwrap();
         assert_eq!(resolved.members.len(), 1);
-        assert_eq!(resolved.members[0].member, "model.safetensors");
+        assert_eq!(resolved.members[0].member, "civitai/files/92696");
         assert_eq!(resolved.members[0].object, object);
         assert_eq!(resolved.members[0].provenance, Provenance::Declared);
         assert!(resolved.members[0].carrier);
         assert_eq!(resolved.canonical, "civitai://777");
         handle.join().unwrap();
+
+        // The real source tree must keep the carrier visible to conversion despite its
+        // lack of a filename extension, under the member the reviewed profile selects.
+        let root = temporary("civitai-member");
+        let store = Store::init(&root).unwrap();
+        store
+            .put_stream(&mut body.as_slice(), Some(&object), &Fault::default())
+            .unwrap();
+        let tree = content_manifest(&resolved).unwrap();
+        let owner = ObjectRef::of(b"civitai-member-owner").id();
+        crate::source_artifact::create(&store, &owner, &tree).unwrap();
+        let (_, roster, landed) =
+            crate::source_artifact::conversion_roster(&store, &owner).unwrap();
+        assert_eq!(roster.len(), 1);
+        assert_eq!(roster[0].member, "civitai/files/92696");
+        assert_eq!(roster[0].header, body[..8 + header.len()]);
+        assert_eq!(landed, vec!["civitai/files/92696"]);
+        let registry = crate::ingest::fingerprint::FingerprintRegistry::parse(
+            crate::ingest::source::BUILTIN_REGISTRY_BYTES,
+        )
+        .unwrap();
+        let profile = registry
+            .source_profiles
+            .iter()
+            .find(|profile| profile.name == "civitai/101055/128078/single-file-fp16")
+            .unwrap();
+        assert!(
+            profile
+                .components
+                .iter()
+                .all(|component| component.source_member.as_deref()
+                    == Some(roster[0].member.as_str()))
+        );
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn civitai_refuses_missing_invalid_and_duplicate_file_ids() {
+        for id in ["null", "0", "-1", "1.5", "9007199254740992", "\"92696\""] {
+            let listing = format!(r#"{{"files":[{{"id":{id},"name":"model.safetensors"}}]}}"#);
+            let (base, _, handle) =
+                origin(1, move |_| ok_body(listing.as_bytes(), "application/json"));
+            let endpoints = Endpoints {
+                civitai: base,
+                allow_local: true,
+                ..Endpoints::default()
+            };
+            let refusal = list(
+                &SourceUri::Civitai { version: 777 },
+                &endpoints,
+                &Anonymous,
+                Deadline::none(),
+            )
+            .unwrap_err();
+            let expected = if id == "9007199254740992" {
+                Code::NUMBER_RANGE // The shared JSON decoder refuses before provider parsing.
+            } else {
+                Code::KEY_GRAMMAR
+            };
+            assert_eq!(refusal.code, expected, "{id}");
+            handle.join().unwrap();
+        }
+        for (listing, code) in [
+            (
+                r#"{"files":[{"name":"missing-id.safetensors"}]}"#,
+                Code::KEY_GRAMMAR,
+            ),
+            (
+                r#"{"files":[{"id":92696,"name":"a.safetensors"},{"id":92696,"name":"b.safetensors"}]}"#,
+                Code::DUPLICATE_KEY,
+            ),
+        ] {
+            let (base, _, handle) =
+                origin(1, move |_| ok_body(listing.as_bytes(), "application/json"));
+            let endpoints = Endpoints {
+                civitai: base,
+                allow_local: true,
+                ..Endpoints::default()
+            };
+            let refusal = list(
+                &SourceUri::Civitai { version: 777 },
+                &endpoints,
+                &Anonymous,
+                Deadline::none(),
+            )
+            .unwrap_err();
+            assert_eq!(refusal.code, code);
+            handle.join().unwrap();
+        }
     }
 
     /// The credential is scoped to the host that holds it. A relative redirect stays on
@@ -2065,7 +2174,7 @@ mod tests {
         // No downloadUrl in the fixture: the handler must fall back to the provider's
         // canonical download route under the configured base.
         let listing = format!(
-            r#"{{"id":777,"files":[{{"name":"model.safetensors","sizeKB":273.4,"hashes":{{"SHA256":"{}"}}}}]}}"#,
+            r#"{{"id":777,"files":[{{"id":92696,"name":"model.safetensors","sizeKB":273.4,"hashes":{{"SHA256":"{}"}}}}]}}"#,
             object.sha256.to_ascii_uppercase()
         );
         let payload = body.clone();
@@ -2074,7 +2183,7 @@ mod tests {
         let (base, _, handle) = origin(5, move |request| {
             if request.path == "/api/v1/model-versions/777" {
                 ok_body(listing.as_bytes(), "application/json")
-            } else if request.path == "/api/download/models/777" {
+            } else if request.path == "/api/download/models/777?fileId=92696" {
                 if request.range.as_deref() == Some("bytes=0-0") {
                     format!(
                         "HTTP/1.1 206 Partial Content\r\nContent-Length: 1\r\nContent-Range: bytes 0-0/{length}\r\nETag: \"tag\"\r\nConnection: close\r\n\r\n\0"

{tensorfs-0.3.22 → tensorfs-0.3.24}/crates/tensorfs-core/src/source_artifact.rs

@@ -8,12 +8,13 @@ use crate::{
     ids::{prefixed, Doc, ObjectRef, Plain},
     manifest::Manifest,
     storage::HeldKey,
-    store::Store,
+    store::{Fault, Store},
 };
 use fs2::FileExt;
 use std::{
     fs::{self, File, OpenOptions},
     io::{Read, Write},
+    os::unix::fs::OpenOptionsExt,
     path::PathBuf,
 };
 
@@ -272,6 +273,59 @@ pub fn create(store: &Store, owner: &str, tree: &Manifest) -> Result<TreeRoot> {
     }
     writer.finish(tree)
 }
+
+/// Import an exact ordinary-file roster under durable custody before admitting bytes.
+/// A retry needs local paths only for members without a standing verification record.
+pub fn import_tree(
+    store: &Store,
+    owner: &str,
+    tree: &Manifest,
+    files: &[(String, PathBuf)],
+    fault: &Fault,
+) -> Result<TreeRoot> {
+    check_roster(owner, tree)?;
+    if tree.header().is_some() {
+        return refuse(Code::WRONG_TYPE, "import requires an ordinary-file tree");
+    }
+    let paths: std::collections::BTreeMap<_, _> = files.iter().map(|(k, v)| (k, v)).collect();
+    if paths.len() != files.len()
+        || paths.len() != tree.entries().len()
+        || tree
+            .entries()
+            .iter()
+            .any(|(member, _)| !paths.contains_key(member))
+    {
+        return refuse(
+            Code::TRANSACTION_CONFLICT,
+            "import paths differ from the exact manifest roster",
+        );
+    }
+    let mut writer = Writer::open(store, owner, tree.object_ref())?;
+    if !writer.completed()? {
+        for (member, entry) in tree.entries() {
+            let object = entry.blob();
+            writer.hold_expected(object)?;
+            if !matches!(store.record_valid(&object.sha256), Ok(row) if row.length == object.length)
+            {
+                let path = paths[member];
+                if !fs::symlink_metadata(path).map_err(io)?.is_file() {
+                    return refuse(Code::WRONG_TYPE, "import member must be a regular file");
+                }
+                let mut file = OpenOptions::new()
+                    .read(true)
+                    .custom_flags(crate::store::O_NOFOLLOW)
+                    .open(path)
+                    .map_err(io)?;
+                if !file.metadata().map_err(io)?.is_file() {
+                    return refuse(Code::WRONG_TYPE, "import member must be a regular file");
+                }
+                store.put_stream(&mut file, Some(object), fault)?;
+            }
+            writer.landed(object)?;
+        }
+    }
+    writer.finish(tree)
+}
 /// Adopt only from a still-retained complete owner, before releasing the source owner.
 pub fn retain(store: &Store, source: &str, owner: &str) -> Result<TreeRoot> {
     let _writer = WriterGuard::acquire(store.root())?;
@@ -459,7 +513,7 @@ pub fn conversion_roster(
                 .read_to_end(&mut bytes)
                 .map_err(io)?;
             bytes
-        } else if member.ends_with(".safetensors") {
+        } else if member.ends_with(".safetensors") || crate::providers::is_civitai_member(member) {
             let mut prefix = [0u8; 8];
             file.read_exact(&mut prefix).map_err(io)?;
             let length = u64::from_le_bytes(prefix);

tensorfs-0.3.24/crates/tensorfs-core/tests/import_tree.rs

@@ -0,0 +1,217 @@
+use std::{
+    fs,
+    path::{Path, PathBuf},
+    process::{Command, Stdio},
+    thread,
+    time::Duration,
+};
+use tensorfs_core::{
+    err::Code,
+    gc,
+    ids::{Doc, ObjectRef},
+    manifest::{Draft, Entry, Manifest},
+    source_artifact,
+    store::{Fault, Store},
+};
+
+fn directory(label: &str) -> PathBuf {
+    std::env::temp_dir().join(format!(
+        "tfs-import-{label}-{}-{}",
+        std::process::id(),
+        tensorfs_core::meta::now_nanos_unique()
+    ))
+}
+fn owner() -> String {
+    ObjectRef::of(b"local import").id()
+}
+fn tree() -> Manifest {
+    Manifest::from_files(vec![
+        ("a.json".into(), ObjectRef::of(b"first member")),
+        ("nested/b.bin".into(), ObjectRef::of(b"second member")),
+    ])
+    .unwrap()
+}
+fn files(dir: &Path) -> Vec<(String, PathBuf)> {
+    vec![
+        ("a.json".into(), dir.join("a")),
+        ("nested/b.bin".into(), dir.join("b")),
+    ]
+}
+
+#[test]
+fn refuses_roster_and_typed_header_before_starting_custody() {
+    let dir = directory("roster");
+    let store = Store::init(&dir).unwrap();
+    let paths = files(&dir);
+    for bad in [
+        paths[..1].to_vec(),
+        vec![paths[0].clone(), paths[0].clone()],
+        vec![paths[0].clone(), ("extra".into(), dir.join("extra"))],
+    ] {
+        assert_eq!(
+            source_artifact::import_tree(&store, &owner(), &tree(), &bad, &Fault::default())
+                .unwrap_err()
+                .code,
+            Code::TRANSACTION_CONFLICT
+        );
+        assert!(source_artifact::read(&store, &owner()).unwrap().is_none());
+    }
+    let typed = Draft {
+        entries: vec![(
+            "model.ct".into(),
+            Entry::CozyTensors(ObjectRef::of(b"header")),
+        )],
+    }
+    .seal()
+    .unwrap();
+    assert_eq!(
+        source_artifact::import_tree(&store, &owner(), &typed, &paths, &Fault::default())
+            .unwrap_err()
+            .code,
+        Code::WRONG_TYPE
+    );
+    assert!(source_artifact::read(&store, &owner()).unwrap().is_none());
+    fs::remove_dir_all(dir).unwrap();
+}
+
+#[test]
+fn verifies_bytes_and_resumes_only_missing_members() {
+    let dir = directory("verify");
+    let store = Store::init(&dir).unwrap();
+    fs::write(dir.join("a"), b"first member").unwrap();
+    fs::write(dir.join("b"), b"short").unwrap();
+    assert_eq!(
+        source_artifact::import_tree(&store, &owner(), &tree(), &files(&dir), &Fault::default())
+            .unwrap_err()
+            .code,
+        Code::LENGTH_MISMATCH
+    );
+    fs::write(dir.join("b"), b"wrong! member").unwrap();
+    assert_eq!(
+        source_artifact::import_tree(&store, &owner(), &tree(), &files(&dir), &Fault::default())
+            .unwrap_err()
+            .code,
+        Code::OBJECT_ID_MISMATCH
+    );
+    assert!(
+        !source_artifact::read(&store, &owner())
+            .unwrap()
+            .unwrap()
+            .complete
+    );
+    fs::remove_file(dir.join("a")).unwrap();
+    gc::collect(&dir, false).unwrap();
+    fs::write(dir.join("b"), b"second member").unwrap();
+    let result =
+        source_artifact::import_tree(&store, &owner(), &tree(), &files(&dir), &Fault::default())
+            .unwrap();
+    assert!(result.complete);
+    assert_eq!(result.manifest, tree().object_ref());
+    fs::remove_file(dir.join("b")).unwrap();
+    assert_eq!(
+        source_artifact::import_tree(&store, &owner(), &tree(), &files(&dir), &Fault::default())
+            .unwrap(),
+        result
+    );
+    let changed = Manifest::from_files(vec![("a.json".into(), ObjectRef::of(b"other"))]).unwrap();
+    assert_eq!(
+        source_artifact::import_tree(
+            &store,
+            &owner(),
+            &changed,
+            &files(&dir)[..1],
+            &Fault::default()
+        )
+        .unwrap_err()
+        .code,
+        Code::TRANSACTION_CONFLICT
+    );
+    let recipient = ObjectRef::of(b"recipient").id();
+    source_artifact::retain(&store, &owner(), &recipient).unwrap();
+    source_artifact::release(&store, &owner()).unwrap();
+    gc::collect(&dir, false).unwrap();
+    assert_eq!(store.read_manifest(&result.manifest).unwrap(), tree());
+    for (_, entry) in tree().entries() {
+        assert!(store.contains(&entry.blob().sha256));
+    }
+    assert_eq!(
+        source_artifact::import_tree(&store, &owner(), &tree(), &files(&dir), &Fault::default())
+            .unwrap_err()
+            .code,
+        Code::TRANSACTION_CLOSED
+    );
+    fs::remove_dir_all(dir).unwrap();
+}
+
+#[test]
+fn import_child() {
+    let Some(dir) = std::env::var_os("TFS_IMPORT_TREE_CHILD") else {
+        return;
+    };
+    let dir = PathBuf::from(dir);
+    let store = Store::open(&dir).unwrap();
+    source_artifact::import_tree(
+        &store,
+        &owner(),
+        &tree(),
+        &files(&dir),
+        &Fault {
+            stage: Some("record".into()),
+            ready: Some(dir.join("ready")),
+        },
+    )
+    .unwrap();
+    panic!("fault should wait for the parent to kill this process");
+}
+
+#[test]
+fn symlink_member_is_refused_before_reading_its_target() {
+    let dir = directory("symlink");
+    let store = Store::init(&dir).unwrap();
+    fs::write(dir.join("target"), b"first member").unwrap();
+    std::os::unix::fs::symlink(dir.join("target"), dir.join("a")).unwrap();
+    assert_eq!(
+        source_artifact::import_tree(&store, &owner(), &tree(), &files(&dir), &Fault::default())
+            .unwrap_err()
+            .code,
+        Code::WRONG_TYPE
+    );
+    assert!(!store.contains(&ObjectRef::of(b"first member").sha256));
+    fs::remove_dir_all(dir).unwrap();
+}
+
+#[test]
+fn killed_after_admission_before_landed_keeps_member_live_for_gc_and_resume() {
+    let dir = directory("kill");
+    let store = Store::init(&dir).unwrap();
+    fs::write(dir.join("a"), b"first member").unwrap();
+    fs::write(dir.join("b"), b"second member").unwrap();
+    let mut child = Command::new(std::env::current_exe().unwrap())
+        .args(["--exact", "import_child", "--nocapture"])
+        .env("TFS_IMPORT_TREE_CHILD", &dir)
+        .stdout(Stdio::null())
+        .spawn()
+        .unwrap();
+    for _ in 0..1000 {
+        if dir.join("ready").is_file() {
+            break;
+        }
+        assert!(child.try_wait().unwrap().is_none());
+        thread::sleep(Duration::from_millis(5));
+    }
+    assert!(dir.join("ready").is_file());
+    child.kill().unwrap();
+    child.wait().unwrap();
+    let partial = source_artifact::read(&store, &owner()).unwrap().unwrap();
+    assert!(!partial.complete);
+    assert_eq!(partial.objects, vec![ObjectRef::of(b"first member")]);
+    gc::collect(&dir, false).unwrap();
+    fs::remove_file(dir.join("a")).unwrap();
+    let completed =
+        source_artifact::import_tree(&store, &owner(), &tree(), &files(&dir), &Fault::default())
+            .unwrap();
+    assert!(completed.complete);
+    gc::collect(&dir, false).unwrap();
+    assert_eq!(store.read_manifest(&completed.manifest).unwrap(), tree());
+    fs::remove_dir_all(dir).unwrap();
+}

{tensorfs-0.3.22 → tensorfs-0.3.24}/crates/tensorfs-py/src/store.rs

@@ -592,6 +592,29 @@ impl PyStore {
         tree_root_dict(py, &root)
     }
 
+    /// Import exact manifest members, retaining each member before byte admission.
+    fn import_tree<'p>(
+        &self,
+        py: Python<'p>,
+        owner: &str,
+        manifest_bytes: &[u8],
+        files: Vec<(String, PathBuf)>,
+    ) -> PyResult<Bound<'p, PyDict>> {
+        let tree = Manifest::parse(manifest_bytes).or_refuse(py)?;
+        let root = py
+            .detach(|| {
+                tensorfs_core::source_artifact::import_tree(
+                    &self.store,
+                    owner,
+                    &tree,
+                    &files,
+                    &Fault::default(),
+                )
+            })
+            .or_refuse(py)?;
+        tree_root_dict(py, &root)
+    }
+
     fn retain_tree_root<'p>(
         &self,
         py: Python<'p>,
@@ -1654,13 +1677,13 @@ impl PyStore {
         Ok(PyBytes::new(py, &v))
     }
 
-    /// Canonical manifest bytes and the CozyTensors header selected by its typed entry.
+    /// Canonical manifest bytes and an optional CozyTensors header selected by its typed entry.
     fn manifest<'p>(&self, py: Python<'p>, hex: &str) -> PyResult<Bound<'p, PyDict>> {
         let (m, mb, hb) = self.load(py, hex)?;
         let d = PyDict::new(py);
         d.set_item("manifest_id", m.manifest_id())?;
         d.set_item("manifest", PyBytes::new(py, &mb))?;
-        d.set_item("header", PyBytes::new(py, &hb))?;
+        d.set_item("header", hb.as_deref().map(|bytes| PyBytes::new(py, bytes)))?;
         Ok(d)
     }
 
@@ -2491,7 +2514,7 @@ impl PyDerivedWriter {
 }
 
 impl PyStore {
-    fn load(&self, py: Python<'_>, hex: &str) -> PyResult<(Manifest, Vec<u8>, Vec<u8>)> {
+    fn load(&self, py: Python<'_>, hex: &str) -> PyResult<(Manifest, Vec<u8>, Option<Vec<u8>>)> {
         let hex = hex.trim_start_matches("sha256:").to_string();
         let len = std::fs::metadata(self.store.manifest_path(&hex))
             .map(|m| m.len())
@@ -2501,24 +2524,12 @@ impl PyStore {
             length: len,
         };
         let m = checkpoint::load_manifest(&self.store, &r).or_refuse(py)?;
-        let hr = match m.header() {
-            Some(h) => h.clone(),
-            None => {
-                return Err(to_py(
-                    py,
-                    &Refusal {
-                        code: Code::MISSING_FIELD,
-                        detail: format!("manifest {} attaches no header", m.manifest_id()),
-                    },
-                ))
-            }
-        };
-        let h = checkpoint::load_header(&self.store, &hr).or_refuse(py)?;
-        Ok((
-            m.clone(),
-            m.canonical_bytes(),
-            h.canonical_bytes().or_refuse(py)?,
-        ))
+        let header = m
+            .header()
+            .map(|reference| checkpoint::load_header(&self.store, reference)?.canonical_bytes())
+            .transpose()
+            .or_refuse(py)?;
+        Ok((m.clone(), m.canonical_bytes(), header))
     }
 }
 

{tensorfs-0.3.22 → tensorfs-0.3.24}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "tensorfs"
-version = "0.3.22"
+version = "0.3.24"
 description = "TensorFS — canonical tensor artifact substrate"
 requires-python = ">=3.12"
 classifiers = [

{tensorfs-0.3.22 → tensorfs-0.3.24}/python/tensorfs/_ext.pyi

@@ -112,7 +112,7 @@ class PreparedModelSource(TypedDict):
 class ManifestRow(TypedDict):
     manifest_id: str
     manifest: bytes
-    header: bytes
+    header: bytes | None
 
 class ReleaseRow(TypedDict):
     org: str
@@ -423,6 +423,9 @@ class Store:
     @property
     def implementation_sha256(self) -> str: ...
     def create_tree_root(self, owner: str, manifest_id: str, manifest_length: int) -> TreeRoot: ...
+    def import_tree(
+        self, owner: str, manifest_bytes: bytes, files: Sequence[tuple[str, StrPath]],
+    ) -> TreeRoot: ...
     def retain_tree_root(self, source_owner: str, owner: str) -> TreeRoot: ...
     def tree_root(self, owner: str) -> TreeRoot | None: ...
     def release_tree_root(self, owner: str) -> None: ...