tensorfs 0.3.60__tar.gz → 0.3.62__tar.gz

{tensorfs-0.3.60 → tensorfs-0.3.62}/Cargo.lock

@@ -439,7 +439,7 @@ checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tensorfs-core"
-version = "0.3.60"
+version = "0.3.62"
 dependencies = [
  "fs2",
  "libc",
@@ -454,7 +454,7 @@ dependencies = [
 
 [[package]]
 name = "tensorfs-py"
-version = "0.3.60"
+version = "0.3.62"
 dependencies = [
  "pyo3",
  "tensorfs-core",

{tensorfs-0.3.60 → tensorfs-0.3.62}/Cargo.toml

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

{tensorfs-0.3.60 → tensorfs-0.3.62}/PKG-INFO

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

{tensorfs-0.3.60 → tensorfs-0.3.62}/crates/tensorfs-core/src/asset_update.rs

@@ -11,7 +11,7 @@ use crate::checkpoint;
 use crate::err::{refuse, Code, Refusal, Result};
 use crate::header::Asset;
 use crate::ids::ObjectRef;
-use crate::manifest::{Entry, Manifest};
+use crate::manifest::Manifest;
 use crate::store::Store;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -42,13 +42,7 @@ fn source_object(manifest: &Manifest, path: &str) -> Result<ObjectRef> {
         .entries()
         .iter()
         .find_map(|(candidate, entry)| {
-            (candidate == path).then(|| match entry {
-                Entry::File(object) => Ok(object.clone()),
-                Entry::CozyTensors(_) => Err(Refusal {
-                    code: Code::WRONG_TYPE,
-                    detail: format!("asset source {path:?} is a CozyTensors header, not a file"),
-                }),
-            })
+            (candidate == path).then(|| entry.materializable(path).cloned())
         })
         .unwrap_or_else(|| {
             Err(Refusal {
@@ -187,6 +181,7 @@ mod tests {
     use crate::checkpoint;
     use crate::header::{Body, Header, Part, Tensor};
     use crate::manifest::Draft;
+    use crate::manifest::Entry;
     use crate::store::Fault;
     use crate::{dtype::Dtype, registry};
 

{tensorfs-0.3.60 → tensorfs-0.3.62}/crates/tensorfs-core/src/bin/tfs/fetch.rs

@@ -273,7 +273,8 @@ fn pull_with_budget(
     let mut request = PullRequest::new(&store, base, refspec, &credential, &policy);
     request.lane = flag(flags, "lane").unwrap_or("");
     request.session = flag(flags, "session").unwrap_or("");
-    request.streams = crate::flag_num(flags, "streams", transport::STREAMS);
+    request.streams = crate::flag_num(flags, "streams", transport::PULL_STREAMS);
+    request.streams_start = crate::flag_num(flags, "streams-start", transport::STREAMS);
     request.deadline = deadline_of(flags);
     request.download_budget = budget;
     // THE WALK REPORTS WHILE IT WALKS.
@@ -300,7 +301,11 @@ fn pull_with_budget(
     let observe = |_object: &ObjectRef, moved: u64, door: ObjectSource| progress.saw(moved, door);
     request.on_plan = Some(&planned);
     request.on_object = Some(&observe);
+    let before = tensorfs_core::stats::snapshot();
+    let started = std::time::Instant::now();
     let report = ok!(transport::pull(&request));
+    let seconds = started.elapsed().as_secs_f64();
+    let after = tensorfs_core::stats::snapshot();
     progress.settle();
     if !tensorfs_core::repo_cache::finish_optional_backfills() {
         eprintln!("repo cache replication incomplete; local fetch remains complete");
@@ -313,6 +318,32 @@ fn pull_with_budget(
         quoted(&report.model), quoted(&report.manifest), quoted(&report.scope),
         report.cache_writes.bytes(), report.bytes_cached, report.bytes_total,
     );
+    // What each stream level bought, so a slow pull says whether more streams helped
+    // (one GET was the limit) or not (the link, disk or origin was).
+    let levels: Vec<String> = report
+        .levels
+        .iter()
+        .map(|level| {
+            format!(
+                "[{},{}]",
+                level.streams,
+                level.bytes_per_second.round() as u64
+            )
+        })
+        .collect();
+    // And what admitting them cost: a pull whose streams stop growing while its batches
+    // take most of the wall time is held by the disk, not the link.
+    eprintln!(
+        "{{\"event\":\"pull.streams\",\"model\":{},\"seconds\":{:.3},\"bytes_moved\":{},\"streams\":{},\"levels\":[{}],\"admission\":{{\"objects\":{},\"batches\":{},\"seconds\":{:.3}}}}}",
+        quoted(&report.model),
+        seconds,
+        report.bytes_moved,
+        report.streams,
+        levels.join(","),
+        after.admitted_objects - before.admitted_objects,
+        after.admission_batches - before.admission_batches,
+        (after.admission_nanos - before.admission_nanos) as f64 / 1e9,
+    );
     println!(
         "model        {}@{} lane {}",
         report.model, report.release, report.lane

{tensorfs-0.3.60 → tensorfs-0.3.62}/crates/tensorfs-core/src/bin/tfs/main.rs

@@ -42,7 +42,9 @@
 //! The ONE transport (tfs-048/tfs-049/tfs-050). The credential is `--credential-file` or
 //! TFS_CREDENTIAL (`bearer <token>`, or empty for anonymous), never bare argv; a
 //! URL of `-` arrives on stdin. Flags: --hub <base> --lane --session --streams <n>
-//! --timeout <s> --allow-hosts a,b,.c --allow-local --max-redirects <n>.
+//! --streams-start <n> --timeout <s> --allow-hosts a,b,.c --allow-local --max-redirects <n>.
+//! `--streams` is the most objects in flight (default 128, memory-bounded); the walk starts
+//! at `--streams-start` (default 16) and doubles while measured goodput follows.
 //! `tfs fetch` reads and backfills the Store's bound repo cache between the local Store
 //! and the origin. It is bound by `tfs store ensure --repo-cache` and never by a flag here.
 //!
@@ -2205,16 +2207,17 @@ fn build_corpus() -> TfsResult<(Vec<Case>, Vec<EncodingSpec>)> {
         "carrier no longer equals the logical dtype",
     ));
 
-    // --- location-typed Manifest reds
+    // A kind a newer TensorFS wrote is opaque here: it parses, and only materializing refuses.
     let manifest_bytes = snap2.canonical_bytes();
-    cases.push(red_case(
-        "manifest-red",
-        "entry-kind-symlink",
+    cases.push(ok_case(
+        "manifest",
+        "entry-kind-future",
         "manifest",
         sub(&manifest_bytes, "\"kind\":\"file\"", "\"kind\":\"symlink\""),
-        "UNKNOWN_FIELD",
-        "only file and cozytensors entries exist",
+        "an entry kind from a newer TensorFS is carried opaquely",
     ));
+
+    // --- location-typed Manifest reds
     let mut draft = Draft::of(&snap);
     draft.entries.clear();
     cases.push(red_case(
@@ -2257,6 +2260,7 @@ fn build_corpus() -> TfsResult<(Vec<Case>, Vec<EncodingSpec>)> {
     // --- the border's own documents (tfs-003)
     let g = "ingest";
     let session = tensorfs_core::ingest::transaction::IngestSession {
+        tensorfs: None,
         session: "e3b0c44298fc1c14".to_string(),
         tenant: "acme".to_string(),
         candidates: vec![ObjectRef::of(b"a candidate header")],

{tensorfs-0.3.60 → tensorfs-0.3.62}/crates/tensorfs-core/src/bin/tfs/repo.rs

@@ -9,7 +9,7 @@ use tensorfs_core::err::{Code, Refusal};
 use tensorfs_core::gc;
 use tensorfs_core::header::{Body, Header};
 use tensorfs_core::ids::{hex64, prefixed, Doc, ObjectRef};
-use tensorfs_core::manifest::{Entry, Manifest};
+use tensorfs_core::manifest::Manifest;
 use tensorfs_core::reclaim;
 use tensorfs_core::repository::{self, Mutation, Repository};
 use tensorfs_core::storage::{
@@ -738,13 +738,7 @@ pub fn cmd_manifest_inspect(path: &Path, flags: &Flags) -> ExitCode {
         .iter()
         .map(|(path, entry)| {
             tensorfs_core::canon::write(&Value::obj(vec![
-                (
-                    "kind",
-                    Value::str(match entry {
-                        Entry::File(_) => "file",
-                        Entry::CozyTensors(_) => "cozytensors",
-                    }),
-                ),
+                ("kind", Value::str(entry.kind())),
                 ("length", Value::uint(entry.blob().length)),
                 ("path", Value::str(path.clone())),
                 ("sha256", Value::str(entry.blob().sha256.clone())),
@@ -855,7 +849,7 @@ fn closure_refs(
     // Runtime roles precede ordinary snapshot paths so an aliased README/sample path cannot
     // relabel a required config, model asset, or tensor part as an ignorable file.
     for (_, entry) in manifest.entries() {
-        if let Entry::File(object) = entry {
+        if let Some(object) = entry.content() {
             insert(&mut refs, "file", object)?;
         }
     }
@@ -1206,7 +1200,7 @@ pub fn cmd_reclaim_run(root: &Path, flags: &Flags) -> ExitCode {
 mod tests {
     use super::*;
     use std::collections::HashSet;
-    use tensorfs_core::manifest::Draft;
+    use tensorfs_core::manifest::{Draft, Entry};
 
     #[test]
     fn inspect_closure_preserves_runtime_roles_over_aliased_files() {
@@ -1246,10 +1240,7 @@ mod tests {
         let file_ids: HashSet<&str> = manifest
             .entries()
             .iter()
-            .filter_map(|(_, entry)| match entry {
-                Entry::File(object) => Some(object.sha256.as_str()),
-                Entry::CozyTensors(_) => None,
-            })
+            .filter_map(|(_, entry)| entry.content().map(|object| object.sha256.as_str()))
             .collect();
 
         assert!(header.assets.iter().any(|(_, asset)| asset
@@ -1268,11 +1259,11 @@ mod tests {
             .filter(|(kind, _)| *kind != "file")
             .map(|(_, object)| object.sha256.as_str())
             .collect();
-        assert!(manifest.entries().iter().any(|(_, entry)| match entry {
-            Entry::File(object) => {
+        assert!(manifest
+            .entries()
+            .iter()
+            .any(|(_, entry)| entry.content().is_some_and(|object| {
                 !runtime_ids.contains(object.sha256.as_str()) && refs[&object.sha256].0 == "file"
-            }
-            Entry::CozyTensors(_) => false,
-        }));
+            })));
     }
 }

{tensorfs-0.3.60 → tensorfs-0.3.62}/crates/tensorfs-core/src/bin/tfs/snap.rs

@@ -104,7 +104,7 @@ fn referenced_blobs(header: &Header, draft: &Draft) -> Result<BTreeMap<String, u
         }
     }
     for (_, entry) in &draft.entries {
-        if let Entry::File(object) = entry {
+        if let Some(object) = entry.content() {
             add_ref(&mut refs, object, "manifest file")?;
         }
     }
@@ -257,6 +257,9 @@ pub fn cmd_show(root: &Path, hex: &str) -> ExitCode {
                 blob.id(),
                 blob.length
             ),
+            Entry::Other { kind, blob } => {
+                println!("    {kind:<12} {path}  {} ({} B)", blob.id(), blob.length)
+            }
         }
     }
     ExitCode::SUCCESS

{tensorfs-0.3.60 → tensorfs-0.3.62}/crates/tensorfs-core/src/canon.rs

@@ -456,6 +456,31 @@ impl<'a> Fields<'a> {
         }
     }
 
+    /// End a record whose unread field could keep bytes alive (a GC root): refuse, naming the
+    /// newer TensorFS that wrote it, rather than drop what that version may rely on.
+    pub fn done_written_by(self, writer: Option<&str>) -> Result<()> {
+        let Some((k, _)) = self.left.first() else {
+            return Ok(());
+        };
+        let by = writer.map_or_else(
+            || "a newer TensorFS".to_string(),
+            |writer| format!("TensorFS {writer}"),
+        );
+        let upgrade = writer.map_or_else(
+            || "upgrade TensorFS".to_string(),
+            |writer| format!("upgrade to tensorfs>={writer}"),
+        );
+        refuse(
+            Code::UNKNOWN_FIELD,
+            format!(
+                "{}: field {k:?} was written by {by}; this is TensorFS {} — {upgrade}. It is \
+                 refused rather than dropped because it may keep bytes alive",
+                self.what,
+                crate::VERSION
+            ),
+        )
+    }
+
     /// End a document that tolerates additive fields, keeping them for re-emission.
     pub fn rest(self) -> Extra {
         Extra(

{tensorfs-0.3.60 → tensorfs-0.3.62}/crates/tensorfs-core/src/catalog.rs

@@ -903,8 +903,9 @@ impl Catalog {
         hold_on(&self.connection()?, operation, key, length)
     }
 
-    /// The object's existing hold and verification become durable together. Filesystem
-    /// publication still precedes its verification record, with FULL synchronization.
+    /// A HELD admission: the hold is written before the object is published, so an
+    /// operation that cannot hold it publishes nothing. Unheld admissions, which is every
+    /// pull, take `record_grouped` instead.
     pub(crate) fn admit_blob(
         &self,
         operation: Option<&str>,
@@ -914,7 +915,7 @@ impl Catalog {
         // One admission at a time per catalog in this process, holding the write lock from
         // before publication: streams landing objects together queue here instead of in
         // SQLite's busy timeout, where a lost race refused bytes already verified.
-        let turn = admissions(&self.path);
+        let turn = held_admissions(&self.path);
         let _turn = turn.lock().unwrap_or_else(|error| error.into_inner());
         let mut connection = self.connection()?;
         let transaction = connection
@@ -941,6 +942,117 @@ impl Catalog {
         Ok(verified.is_some())
     }
 
+    /// The object's existing hold and verification become durable together. Filesystem
+    /// publication has already happened, on the caller's thread, and precedes this record,
+    /// which is written with FULL synchronization.
+    ///
+    /// Records queue per catalog in this process, and whichever arrives while no batch is
+    /// committing leads the next one: one immediate transaction and one commit make every
+    /// waiting record durable. One object alone costs what it always did. Before this,
+    /// directory creation, link, directory fsync and commit ran for one object at a time
+    /// under one lock, several fsyncs each, and on a disk busy flushing those same objects'
+    /// bodies that queue, not the network, set a pull's rate.
+    pub(crate) fn record_grouped(&self, recording: Recording) -> Result<()> {
+        let group = admission_group(&self.path);
+        let mut state = group
+            .state
+            .lock()
+            .unwrap_or_else(|error| error.into_inner());
+        let ticket = state.next;
+        state.next += 1;
+        state.queue.push((ticket, recording));
+        loop {
+            if let Some(result) = state.done.remove(&ticket) {
+                return result;
+            }
+            if state.leading {
+                state = group
+                    .turned
+                    .wait(state)
+                    .unwrap_or_else(|error| error.into_inner());
+                continue;
+            }
+            state.leading = true;
+            let batch = std::mem::take(&mut state.queue);
+            let mut lead = Lead {
+                group: &group,
+                tickets: batch.iter().map(|(ticket, _)| *ticket).collect(),
+                results: Vec::new(),
+            };
+            drop(state);
+            let started = std::time::Instant::now();
+            let objects = batch.len();
+            lead.results = self.record_batch(batch);
+            crate::stats::admission_batch(objects, started.elapsed());
+            drop(lead);
+            state = group
+                .state
+                .lock()
+                .unwrap_or_else(|error| error.into_inner());
+        }
+    }
+
+    fn record_batch(&self, batch: Vec<(u64, Recording)>) -> Vec<(u64, Result<()>)> {
+        let fail_all = |batch: Vec<(u64, Recording)>, error: Refusal| {
+            batch
+                .into_iter()
+                .map(|(ticket, _)| (ticket, Err(error.clone())))
+                .collect::<Vec<_>>()
+        };
+        let mut connection = match self.connection() {
+            Ok(connection) => connection,
+            Err(error) => return fail_all(batch, error),
+        };
+        let mut transaction =
+            match connection.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate) {
+                Ok(transaction) => transaction,
+                Err(error) => return fail_all(batch, sql("begin blob admission", error)),
+            };
+        let mut results = Vec::with_capacity(batch.len());
+        let mut written = Vec::with_capacity(batch.len());
+        // Each object's row sits behind its own savepoint: one refused row refuses that
+        // object, as it did when every object had a transaction of its own.
+        for (ticket, recording) in batch {
+            let outcome = transaction
+                .savepoint()
+                .map_err(|error| sql("begin object admission", error))
+                .and_then(|savepoint| {
+                    if let Some(row) = &recording.record {
+                        write_verification_on(&savepoint, row)?;
+                    }
+                    savepoint
+                        .commit()
+                        .map_err(|error| sql("record object admission", error))
+                });
+            match outcome {
+                Ok(()) => written.push((ticket, recording.record)),
+                Err(error) => results.push((ticket, Err(error))),
+            }
+        }
+        match transaction
+            .commit()
+            .map_err(|error| sql("commit blob admission", error))
+        {
+            Ok(()) => {
+                let trust = Trust::live(&self.path);
+                for (ticket, record) in written {
+                    if let (Some(row), Some(trust)) = (&record, &trust) {
+                        trust.remember(row);
+                    }
+                    results.push((ticket, Ok(())));
+                }
+            }
+            Err(error) => {
+                results.extend(
+                    written
+                        .into_iter()
+                        .map(|(ticket, _)| (ticket, Err(error.clone()))),
+                );
+            }
+        }
+        results
+    }
+
     pub fn held_keys(&self) -> Result<Vec<crate::storage::HeldKey>> {
         let connection = self.connection()?;
         let mut statement = connection
@@ -1084,7 +1196,7 @@ impl Catalog {
     }
 }
 
-fn admissions(path: &Path) -> Arc<Mutex<()>> {
+fn held_admissions(path: &Path) -> Arc<Mutex<()>> {
     static TURNS: OnceLock<Mutex<HashMap<PathBuf, Arc<Mutex<()>>>>> = OnceLock::new();
     TURNS
         .get_or_init(Default::default)
@@ -1095,6 +1207,73 @@ fn admissions(path: &Path) -> Arc<Mutex<()>> {
         .clone()
 }
 
+/// One published object's catalog rows, handed to the admission group.
+pub(crate) struct Recording {
+    /// The verification row, when this call installed the object.
+    pub record: Option<crate::store::VRecord>,
+}
+
+#[derive(Default)]
+struct AdmissionGroup {
+    state: Mutex<GroupState>,
+    turned: std::sync::Condvar,
+}
+
+#[derive(Default)]
+struct GroupState {
+    next: u64,
+    leading: bool,
+    queue: Vec<(u64, Recording)>,
+    done: HashMap<u64, Result<()>>,
+}
+
+fn admission_group(path: &Path) -> Arc<AdmissionGroup> {
+    static GROUPS: OnceLock<Mutex<HashMap<PathBuf, Arc<AdmissionGroup>>>> = OnceLock::new();
+    GROUPS
+        .get_or_init(Default::default)
+        .lock()
+        .unwrap_or_else(|error| error.into_inner())
+        .entry(path.to_path_buf())
+        .or_default()
+        .clone()
+}
+
+/// A leader hands its batch's results back however it leaves, so a panic inside one batch
+/// cannot strand the admissions queued behind it.
+struct Lead<'a> {
+    group: &'a AdmissionGroup,
+    tickets: Vec<u64>,
+    results: Vec<(u64, Result<()>)>,
+}
+
+impl Drop for Lead<'_> {
+    fn drop(&mut self) {
+        let mut state = self
+            .group
+            .state
+            .lock()
+            .unwrap_or_else(|error| error.into_inner());
+        state.leading = false;
+        let mut answered = std::collections::HashSet::new();
+        for (ticket, result) in self.results.drain(..) {
+            answered.insert(ticket);
+            state.done.insert(ticket, result);
+        }
+        for ticket in &self.tickets {
+            if !answered.contains(ticket) {
+                state.done.insert(
+                    *ticket,
+                    Err(Refusal {
+                        code: Code::IO_FAILED,
+                        detail: "the admission batch holding this object did not finish".into(),
+                    }),
+                );
+            }
+        }
+        self.group.turned.notify_all();
+    }
+}
+
 fn hold_on(connection: &Connection, operation: &str, key: &str, length: u64) -> Result<()> {
     let kind = if key.starts_with("blobs/") {
         "blob"

{tensorfs-0.3.60 → tensorfs-0.3.62}/crates/tensorfs-core/src/checkpoint.rs

@@ -523,17 +523,14 @@ pub fn walk(store: &Store, snap: &Manifest) -> Result<Walk> {
         .map(|r| (r.obj.sha256.clone(), r.obj.length))
         .collect();
     for (path, e) in snap.entries() {
-        match e {
-            crate::manifest::Entry::File(o) => {
-                if !accounted.contains(&(o.sha256.clone(), o.length)) {
-                    w.siblings.push(path.clone());
-                    w.objects.push(Reached {
-                        kind: "asset",
-                        obj: o.clone(),
-                    });
-                }
+        if let Some(o) = e.content() {
+            if !accounted.contains(&(o.sha256.clone(), o.length)) {
+                w.siblings.push(path.clone());
+                w.objects.push(Reached {
+                    kind: "asset",
+                    obj: o.clone(),
+                });
             }
-            crate::manifest::Entry::CozyTensors(_) => {}
         }
     }
     Ok(w)

{tensorfs-0.3.60 → tensorfs-0.3.62}/crates/tensorfs-core/src/checkpoint_root.rs

@@ -22,6 +22,8 @@ pub struct CheckpointRoot {
     pub repository: RepositoryName,
     pub manifest: ObjectRef,
     pub released: bool,
+    /// The newest TensorFS that wrote this root.
+    pub tensorfs: Option<String>,
 }
 
 impl Plain for CheckpointRoot {
@@ -36,11 +38,18 @@ impl Plain for CheckpointRoot {
             Value::Bool(value) => *value,
             _ => return refuse(Code::WRONG_TYPE, "checkpoint root release must be boolean"),
         };
-        fields.done()?;
+        let tensorfs = fields
+            .opt("tensorfs")
+            .map(|value| {
+                crate::canon::as_str("CheckpointRoot", "tensorfs", value).map(str::to_string)
+            })
+            .transpose()?;
+        fields.done_written_by(tensorfs.as_deref())?;
         if manifest.length == 0 || manifest.length > crate::limits::INT_MAX as u64 {
             return refuse(Code::LENGTH_MISMATCH, "checkpoint root manifest is empty");
         }
         Ok(Self {
+            tensorfs,
             owner,
             repository,
             manifest,
@@ -49,7 +58,7 @@ impl Plain for CheckpointRoot {
     }
 
     fn to_value(&self) -> Value {
-        Value::obj(vec![
+        let mut fields = vec![
             ("owner", Value::str(self.owner.clone())),
             (
                 "repository",
@@ -57,7 +66,11 @@ impl Plain for CheckpointRoot {
             ),
             ("manifest", self.manifest.to_value()),
             ("released", Value::Bool(self.released)),
-        ])
+        ];
+        if let Some(tensorfs) = &self.tensorfs {
+            fields.push(("tensorfs", Value::str(tensorfs.clone())));
+        }
+        Value::obj(fields)
     }
 }
 
@@ -126,6 +139,10 @@ fn lock(store: &Store, owner: &str) -> Result<File> {
 }
 
 fn write(store: &Store, root: &CheckpointRoot) -> Result<()> {
+    let root = &CheckpointRoot {
+        tensorfs: Some(crate::VERSION.into()),
+        ..root.clone()
+    };
     let path = path(store, &root.owner)?;
     let temporary = path.with_extension(format!("tmp-{}", crate::meta::now_nanos_unique()));
     let result = (|| {
@@ -159,6 +176,7 @@ fn identity(owner: &str, source: &str, manifest: ObjectRef) -> Result<Checkpoint
         return refuse(Code::LENGTH_MISMATCH, "checkpoint root manifest is empty");
     }
     Ok(CheckpointRoot {
+        tensorfs: Some(crate::VERSION.into()),
         owner: prefixed("checkpoint root owner", owner)?,
         repository: repository(source)?,
         manifest,

{tensorfs-0.3.60 → tensorfs-0.3.62}/crates/tensorfs-core/src/derived/companion_tests.rs

@@ -191,7 +191,7 @@ fn ordinary_companions_survive_derivation_without_copying_tensor_backing_files()
         .push(("LICENSE".into(), b"explicit licence".to_vec()));
     assert_eq!(
         companion_files(&d, &sources).unwrap()["LICENSE"],
-        ObjectRef::of(b"explicit licence")
+        Entry::File(ObjectRef::of(b"explicit licence"))
     );
     std::fs::remove_dir_all(store.root()).unwrap();
 }