tensorfs 0.3.8__tar.gz → 0.3.10__tar.gz

{tensorfs-0.3.8 → tensorfs-0.3.10}/Cargo.lock

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

{tensorfs-0.3.8 → tensorfs-0.3.10}/Cargo.toml

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

{tensorfs-0.3.8 → tensorfs-0.3.10}/PKG-INFO

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

{tensorfs-0.3.8 → tensorfs-0.3.10}/crates/tensorfs-core/src/derived.rs

@@ -143,6 +143,20 @@ pub struct Declaration {
 }
 
 impl Declaration {
+    /// The native declaration encoder shared by Runtime intents and writers.
+    pub fn canonical_bytes(&mut self) -> Result<Vec<u8>> {
+        self.normalize_and_validate()?;
+        self.require_order()?;
+        let bytes = crate::canon::write(&self.to_value());
+        if bytes.len() > limits::DOC_MAX_BYTES / 2 {
+            return refuse(
+                Code::SIZE_CAP,
+                "derived declaration is over its metadata budget",
+            );
+        }
+        Ok(bytes)
+    }
+
     fn require_order(&self) -> Result<()> {
         if self.order.is_empty() {
             return refuse(
@@ -1324,22 +1338,28 @@ fn require_payload_record(store: &Store, object: &ObjectRef, what: &str) -> Resu
     }
 }
 
-fn resolve_sources(
-    store: &Store,
-    meta: &Meta,
-    declaration: &Declaration,
-) -> Result<Vec<SourceData>> {
-    let mut out = Vec::new();
+fn require_source_roots(store: &Store, declaration: &Declaration) -> Result<()> {
+    if declaration.sources.is_empty() {
+        return Ok(());
+    }
+    let retained = crate::gc::retained_manifests(store)?;
     for declared in &declaration.sources {
-        if !meta.manifest_is_released(&declared.manifest.sha256)? {
+        if !retained.contains(&declared.manifest) {
             return refuse(
                 Code::ROOT_ABSENT,
                 format!(
-                    "source {} is not referenced by a repository release",
+                    "source {} has no exact retained filesystem root",
                     declared.manifest.id()
                 ),
             );
         }
+    }
+    Ok(())
+}
+
+fn load_sources(store: &Store, declaration: &Declaration) -> Result<Vec<SourceData>> {
+    let mut out = Vec::new();
+    for declared in &declaration.sources {
         let manifest = checkpoint::load_manifest(store, &declared.manifest)?;
         if manifest.manifest_id() != declared.manifest.id() {
             return refuse(
@@ -1777,6 +1797,18 @@ pub fn inspect_source(
     manifest: ObjectRef,
     component_names: Vec<String>,
     config_names: Vec<String>,
+) -> Result<SourceInspection> {
+    let hold = meta.acquire_hold("derived-source-inspect")?;
+    let result = inspect_retained_source(store, manifest, component_names, config_names);
+    let released = hold.release(meta);
+    result.and_then(|inspection| released.map(|()| inspection))
+}
+
+fn inspect_retained_source(
+    store: &Store,
+    manifest: ObjectRef,
+    component_names: Vec<String>,
+    config_names: Vec<String>,
 ) -> Result<SourceInspection> {
     let alias = "source".to_string();
     let mut declaration = Declaration {
@@ -1806,7 +1838,8 @@ pub fn inspect_source(
         max_new_bytes: 0,
     };
     declaration.normalize_and_validate()?;
-    let mut sources = resolve_sources(store, meta, &declaration)?;
+    require_source_roots(store, &declaration)?;
+    let mut sources = load_sources(store, &declaration)?;
     let source = sources.pop().ok_or_else(|| Refusal {
         code: Code::ROOT_ABSENT,
         detail: "source inspection resolved no source".into(),
@@ -1862,20 +1895,15 @@ pub fn begin(
             "WriterSessionId must be positive and inside the canonical integer range",
         );
     }
-    declaration.normalize_and_validate()?;
-    declaration.require_order()?;
-    let declaration_text = declaration.canonical_text();
-    if declaration_text.len() > limits::DOC_MAX_BYTES / 2 {
-        return refuse(
-            Code::SIZE_CAP,
-            "derived declaration is over its metadata budget",
-        );
-    }
+    let declaration_text =
+        String::from_utf8(declaration.canonical_bytes()?).expect("canonical JSON is UTF-8");
 
     // The writer hold is registered before source metadata is touched. It is the live
     // process proof that keeps exclusive GC out even for a source-free create.
     let writer_hold = meta.acquire_hold("derived-writer")?;
-    let sources = match resolve_sources(store, meta, &declaration) {
+    let sources = match require_source_roots(store, &declaration)
+        .and_then(|()| load_sources(store, &declaration))
+    {
         Ok(sources) => sources,
         Err(error) => {
             release_guards(meta, Some(writer_hold), Vec::new());
@@ -2323,6 +2351,9 @@ fn receipt_from(_store: &Store, row: &TransactionRow) -> Result<ReceiptFacts> {
     })
 }
 
+/// The caller retains Begin's writer hold and source leases through this call.
+/// Root membership was admitted at begin; the live hold now protects those exact
+/// bytes even if their original repository/session/private root is released.
 pub fn commit(
     store: &Store,
     meta: &Meta,
@@ -2335,7 +2366,7 @@ pub fn commit(
         open_row(&mut txn.rows, &transaction, writer_session)?.clone()
     };
     let declaration = declaration(&row_before)?;
-    let sources = resolve_sources(store, meta, &declaration)?;
+    let sources = load_sources(store, &declaration)?;
     let (header, closure, registry_adoptions) = build_header(
         &declaration,
         &sources,
@@ -2693,6 +2724,235 @@ mod tests {
         }
     }
 
+    fn inherited_declaration(manifest: ObjectRef) -> Declaration {
+        Declaration {
+            sources: vec![Source {
+                alias: "source".into(),
+                manifest,
+            }],
+            components: vec![ComponentDeclaration {
+                target: "inherited".into(),
+                source: Some("source".into()),
+                source_component: Some("model".into()),
+                drop: Vec::new(),
+                add: Vec::new(),
+            }],
+            configs: Vec::new(),
+            order: vec![("inherited".into(), "weight".into())],
+            max_new_bytes: 0,
+        }
+    }
+
+    #[test]
+    fn retained_source_admission_and_writer_hold_share_the_gc_roots() {
+        let root = std::env::temp_dir().join(format!(
+            "tensorfs-retained-source-{}",
+            crate::meta::now_nanos_unique()
+        ));
+        let store = Store::init(&root).unwrap();
+        let meta = Meta::open(&store).unwrap();
+        let source_id = format!("sha256:{}", "81".repeat(32));
+        let source_writer = begin(&store, &meta, &source_id, 1, created_declaration()).unwrap();
+        let bytes = vec![0x21; 2048];
+        add_part(
+            &store,
+            &meta,
+            &source_id,
+            1,
+            ("model", "weight", "value"),
+            &mut bytes.as_slice(),
+        )
+        .unwrap();
+        let source = commit(&store, &meta, &source_id, 1).unwrap();
+        release_guards(
+            &meta,
+            Some(source_writer.writer_hold),
+            source_writer.source_leases,
+        );
+        let preview = || {
+            inspect_source(
+                &store,
+                &meta,
+                source.manifest.clone(),
+                vec!["model".into()],
+                Vec::new(),
+            )
+        };
+
+        // Committed pending output and owner-adopted output have real filesystem roots.
+        preview().unwrap();
+        adopt(&store, &meta, &source_id, "source-private").unwrap();
+        preview().unwrap();
+        dispose(&store, &meta, &source_id).unwrap();
+        assert_eq!(preview().unwrap_err().code, Code::ROOT_ABSENT);
+        let target_id = format!("sha256:{}", "82".repeat(32));
+        assert_eq!(
+            begin(
+                &store,
+                &meta,
+                &target_id,
+                1,
+                inherited_declaration(source.manifest.clone())
+            )
+            .err()
+            .unwrap()
+            .code,
+            Code::ROOT_ABSENT
+        );
+        assert!(matches!(
+            lookup(&store, &meta, &target_id).unwrap(),
+            Lookup::Absent
+        ));
+
+        // The coordinator's actual prepared-source lifecycle names a private candidate.
+        let operation = "prepared-source";
+        let request_digest = format!("sha256:{}", "83".repeat(32));
+        let catalog = crate::catalog::Catalog::open(&root).unwrap();
+        let crate::catalog::SourcePreparation::Open(source_guard) = catalog
+            .begin_source_preparation(operation, &request_digest)
+            .unwrap()
+        else {
+            panic!("source operation already prepared")
+        };
+        crate::ingest::transaction::ensure_session_root(&root, operation, "_tensorfs").unwrap();
+        crate::ingest::transaction::name_candidates(
+            &root,
+            operation,
+            std::slice::from_ref(&source.manifest),
+        )
+        .unwrap();
+        // An actual candidate is retained even before the rebuildable result row is written.
+        preview().unwrap();
+        catalog
+            .commit_source_preparation(
+                operation,
+                &request_digest,
+                &[crate::catalog::SourcePreparationResult {
+                    slot: "source".into(),
+                    profile: "proof".into(),
+                    manifest_sha256: source.manifest.sha256.clone(),
+                    manifest_length: source.manifest.length,
+                }],
+            )
+            .unwrap();
+        drop(source_guard);
+        crate::gc::collect(&root, false).unwrap();
+        preview().unwrap();
+        let mut wrong = inherited_declaration(source.manifest.clone());
+        wrong.sources[0].manifest.length += 1;
+        assert_eq!(
+            begin(&store, &meta, &target_id, 1, wrong)
+                .err()
+                .unwrap()
+                .code,
+            Code::ROOT_ABSENT
+        );
+
+        let writer = begin(
+            &store,
+            &meta,
+            &target_id,
+            1,
+            inherited_declaration(source.manifest.clone()),
+        )
+        .unwrap();
+        crate::ingest::source::release_model_source(&store, operation).unwrap();
+        assert_eq!(preview().unwrap_err().code, Code::ROOT_ABSENT);
+        writer.writer_hold.still_registered(&meta).unwrap();
+        assert_eq!(
+            crate::gc::collect(&root, false).unwrap_err().code,
+            Code::STORE_BUSY
+        );
+        let inherited = commit(&store, &meta, &target_id, 1).unwrap();
+        assert_eq!(inherited.inherited_payload_bytes, 2048);
+        assert!(inherited.added_objects.is_empty());
+        release_guards(&meta, Some(writer.writer_hold), writer.source_leases);
+        crate::gc::collect(&root, false).unwrap();
+        store.read_manifest(&inherited.manifest).unwrap();
+        inspect_source(
+            &store,
+            &meta,
+            inherited.manifest.clone(),
+            vec!["inherited".into()],
+            Vec::new(),
+        )
+        .unwrap();
+        dispose(&store, &meta, &target_id).unwrap();
+        assert_eq!(
+            inspect_source(
+                &store,
+                &meta,
+                inherited.manifest,
+                vec!["inherited".into()],
+                Vec::new()
+            )
+            .unwrap_err()
+            .code,
+            Code::ROOT_ABSENT
+        );
+        let _ = std::fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn retained_source_still_refuses_corrupt_payload_and_abandoned_writer() {
+        let root = std::env::temp_dir().join(format!(
+            "tensorfs-retained-source-refusal-{}",
+            crate::meta::now_nanos_unique()
+        ));
+        let store = Store::init(&root).unwrap();
+        let meta = Meta::open(&store).unwrap();
+        let source_id = format!("sha256:{}", "84".repeat(32));
+        let source_writer = begin(&store, &meta, &source_id, 1, created_declaration()).unwrap();
+        let bytes = vec![0x31; 2048];
+        let part = add_part(
+            &store,
+            &meta,
+            &source_id,
+            1,
+            ("model", "weight", "value"),
+            &mut bytes.as_slice(),
+        )
+        .unwrap();
+        let source = commit(&store, &meta, &source_id, 1).unwrap();
+        release_guards(
+            &meta,
+            Some(source_writer.writer_hold),
+            source_writer.source_leases,
+        );
+        let target_id = format!("sha256:{}", "85".repeat(32));
+        let writer = begin(
+            &store,
+            &meta,
+            &target_id,
+            1,
+            inherited_declaration(source.manifest.clone()),
+        )
+        .unwrap();
+        assert!(fence(&meta, &target_id, 1).unwrap());
+        abandon(&store, &meta, &target_id).unwrap();
+        assert_eq!(
+            commit(&store, &meta, &target_id, 1).unwrap_err().code,
+            Code::TRANSACTION_CLOSED
+        );
+        release_guards(&meta, Some(writer.writer_hold), writer.source_leases);
+        let path = store.blob_path(&part.part.segments()[0].sha256);
+        std::fs::remove_file(&path).unwrap();
+        std::fs::write(path, vec![0x32; 2048]).unwrap();
+        assert_eq!(
+            inspect_source(
+                &store,
+                &meta,
+                source.manifest,
+                vec!["model".into()],
+                Vec::new()
+            )
+            .unwrap_err()
+            .code,
+            Code::OBJECT_CORRUPT
+        );
+        let _ = std::fs::remove_dir_all(root);
+    }
+
     #[test]
     fn private_adoption_retains_real_payload_until_dispose_without_a_repository() {
         let root = std::env::temp_dir().join(format!(
@@ -2939,6 +3199,15 @@ mod tests {
             )
             .unwrap()
             .unwrap();
+        // An owner-retained checkpoint is a GC root before any public release exists.
+        inspect_source(
+            &store,
+            &meta,
+            manifest_ref.clone(),
+            vec!["model".into()],
+            Vec::new(),
+        )
+        .unwrap();
         store
             .apply_repository(
                 Some(&checkpointed.canonical_bytes()),

{tensorfs-0.3.8 → tensorfs-0.3.10}/crates/tensorfs-core/src/durability.rs

@@ -185,21 +185,34 @@ pub fn canonical_refs(mut refs: Vec<ObjectRef>) -> Vec<ObjectRef> {
 /// Read an admitted link from the local Store. Unlike `chain`, this does not require an
 /// NFS binding: the ordinary transfer plane may have obtained it from the hub.
 pub fn local_link(store: &Store, object: &ObjectRef) -> Result<Link> {
-    if object.length > Link::MAX_BYTES as u64 {
+    Link::parse(&read_document(store, object, Link::MAX_BYTES)?)
+}
+
+/// Bound the actual pinned file before allocation, not only the untrusted claimed length.
+/// Source and derived progress use the same exact ObjectRef admission contract as links.
+pub(crate) fn read_document(store: &Store, object: &ObjectRef, cap: usize) -> Result<Vec<u8>> {
+    if object.length > cap as u64 {
+        return refuse(Code::COUNT_CAP, "checkpoint document exceeds its byte cap");
+    }
+    let mut file = store.open_verified(&object.sha256)?;
+    if file.len() != object.length {
         return refuse(
-            Code::COUNT_CAP,
-            "checkpoint link exceeds the document byte cap",
+            Code::LENGTH_MISMATCH,
+            "checkpoint document differs from its ObjectRef length",
         );
     }
-    let mut bytes = Vec::with_capacity(object.length as usize);
-    store.read_into(&object.sha256, &mut bytes)?;
+    let mut bytes = vec![0; object.length as usize];
+    std::io::Read::read_exact(&mut file, &mut bytes).map_err(|error| crate::err::Refusal {
+        code: Code::IO_FAILED,
+        detail: format!("read checkpoint document: {error}"),
+    })?;
     if ObjectRef::of(&bytes) != *object {
         return refuse(
             Code::OBJECT_ID_MISMATCH,
-            "checkpoint link differs from its ObjectRef",
+            "checkpoint document differs from its ObjectRef",
         );
     }
-    Link::parse(&bytes)
+    Ok(bytes)
 }
 
 /// Each call reads one link and returns a bounded window, so a caller can fetch links and
@@ -1030,6 +1043,40 @@ pub fn restore_conversion(
 mod tests {
     use super::*;
 
+    #[test]
+    fn checkpoint_documents_refuse_wrong_lengths_before_reading_into_memory() {
+        let root = std::env::temp_dir().join(format!(
+            "tensorfs-document-bound-{}",
+            crate::meta::now_nanos_unique()
+        ));
+        let store = Store::init(&root).unwrap();
+        let bytes = b"a verified resident object";
+        let object = store
+            .put_stream(
+                &mut bytes.as_slice(),
+                Some(&ObjectRef::of(bytes)),
+                &Default::default(),
+            )
+            .unwrap()
+            .obj;
+        let mut short = object.clone();
+        short.length = 1;
+        assert_eq!(
+            local_link(&store, &short).unwrap_err().code,
+            Code::LENGTH_MISMATCH
+        );
+        assert_eq!(
+            read_document(&store, &short, 1).unwrap_err().code,
+            Code::LENGTH_MISMATCH
+        );
+        assert_eq!(
+            read_document(&store, &object, 1).unwrap_err().code,
+            Code::COUNT_CAP
+        );
+        assert_eq!(read_document(&store, &object, bytes.len()).unwrap(), bytes);
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
     fn object(byte: &str, length: u64) -> ObjectRef {
         ObjectRef {
             sha256: byte.repeat(32),

{tensorfs-0.3.8 → tensorfs-0.3.10}/crates/tensorfs-core/src/gc.rs

@@ -154,6 +154,32 @@ pub fn session_holds(store: &Store) -> Result<(Vec<HeldKey>, Vec<String>)> {
     Ok((holds, sessions))
 }
 
+/// The same exact manifest roots used by reclamation, without a payload census.
+/// Membership is retention, not caller authorization. A consumer must acquire its
+/// live hold before checking roots so GC cannot remove bytes during admission.
+pub(crate) fn retained_manifests(store: &Store) -> Result<Vec<crate::ids::ObjectRef>> {
+    let mut roots = Vec::new();
+    for (repository, _) in storage::read_repositories(store.root())? {
+        roots.extend(
+            repository
+                .checkpoints
+                .into_iter()
+                .map(|checkpoint| checkpoint.manifest),
+        );
+    }
+    let (holds, _) = session_holds(store)?;
+    roots.extend(
+        holds
+            .into_iter()
+            .filter(|hold| hold.kind == "manifest")
+            .map(|hold| crate::ids::ObjectRef {
+                sha256: hold.sha256,
+                length: hold.length,
+            }),
+    );
+    Ok(roots)
+}
+
 /// One complete pass: exclusivity, orphan temps, census, plan, delete, catalog repair.
 pub fn collect(root: &Path, dry_run: bool) -> Result<Report> {
     let store = Store::open(root)?;

{tensorfs-0.3.8 → tensorfs-0.3.10}/crates/tensorfs-core/src/ingest/source.rs

@@ -1207,11 +1207,51 @@ fn prepare_model_source_with_registry(
             for source in &sources {
                 validate_prepared_result(store, source)?;
             }
+            // The final response can be lost after its catalog commit. Its existing local
+            // cursors must remain discoverable without converting or reading source bodies.
+            let mut checkpoints = Vec::new();
+            let dir = transaction::candidate_dir(store.root(), &request.operation_id);
+            for (requested, (plan_hex, _)) in request.profiles.iter().zip(&plans) {
+                let plan_digest = format!("sha256:{plan_hex}");
+                let chain = format!("{}/{}", request.operation_id, requested.slot);
+                let journal = super::journal::Journal::open(&dir, plan_hex)?;
+                let local = journal.local_head()?.ok_or_else(|| Refusal {
+                    code: Code::DURABILITY_UNPROVEN,
+                    detail: "completed source has no local checkpoint cursor".into(),
+                })?;
+                let supplied = request
+                    .checkpoints
+                    .iter()
+                    .find(|(slot, _)| slot == &requested.slot)
+                    .map(|(_, head)| head);
+                let head = durability::checkpoint_predecessor(
+                    store,
+                    &durability::Policy {
+                        chain: &chain,
+                        operation: &request.operation_id,
+                        plan: &plan_digest,
+                        interval: durability::INTERVAL_BYTES,
+                    },
+                    Some(&local),
+                    supplied,
+                )?
+                .expect("a local cursor was supplied");
+                let held = durability::local_chain(store, &head, &plan_digest)?;
+                checkpoints.push(SourceCheckpoint {
+                    slot: requested.slot.clone(),
+                    plan_digest,
+                    head: durability::Head {
+                        head: Some(head),
+                        links: held.links,
+                        bytes: held.bytes,
+                    },
+                });
+            }
             return Ok(PreparedModelSources {
                 replayed: true,
                 complete: true,
                 sources,
-                checkpoints: Vec::new(),
+                checkpoints,
                 spent: request
                     .roster
                     .iter()
@@ -1257,20 +1297,8 @@ fn prepare_model_source_with_registry(
             durability::retain_local_chain(store, head, &request.operation_id)?;
             if journal.is_empty() {
                 if let Some(progress) = held.progress.last() {
-                    if progress.length > crate::limits::DOC_MAX_BYTES as u64 {
-                        return refuse(
-                            Code::COUNT_CAP,
-                            "checkpoint progress exceeds the document byte cap",
-                        );
-                    }
-                    let mut bytes = Vec::with_capacity(progress.length as usize);
-                    store.read_into(&progress.sha256, &mut bytes)?;
-                    if ObjectRef::of(&bytes) != *progress {
-                        return refuse(
-                            Code::OBJECT_ID_MISMATCH,
-                            "checkpoint progress differs from its ObjectRef",
-                        );
-                    }
+                    let bytes =
+                        durability::read_document(store, progress, crate::limits::DOC_MAX_BYTES)?;
                     drop(journal);
                     super::journal::install(&dir, &plan_hex, &bytes)?;
                     journal = super::journal::Journal::open(&dir, &plan_hex)?;
@@ -1583,6 +1611,19 @@ mod tests {
                 .unwrap();
         assert!(replay.replayed);
         assert_eq!(replay.sources, first.sources);
+        assert_eq!(replay.checkpoints, first.checkpoints);
+        let mut bodies_gone = request.clone();
+        bodies_gone.landed.clear();
+        for row in &bodies_gone.roster {
+            fs::remove_file(&row.path).unwrap();
+        }
+        let recovered_heads =
+            prepare_model_source_with_registry(&store, &bodies_gone, "fixture:registry", &registry)
+                .unwrap();
+        assert_eq!(recovered_heads.checkpoints, first.checkpoints);
+        // Remaining arms need their original carriers again.
+        carrier(&request.roster[0].path, "weight", [1, 2, 3, 4]);
+        carrier(&request.roster[1].path, "weight", [5, 6, 7, 8]);
 
         let mut changed = request.clone();
         changed.roster[0].object_id = format!("sha256:{}", "33".repeat(32));
@@ -2239,6 +2280,10 @@ mod tests {
         )
         .unwrap();
         assert!(replay.replayed && replay.complete);
+        assert_eq!(
+            replay.checkpoints, resumed.checkpoints,
+            "a lost final response replays even with an old ACK"
+        );
         let mut unrelated = registry.clone();
         unrelated.entries[0]
             .provenance

{tensorfs-0.3.8 → tensorfs-0.3.10}/crates/tensorfs-core/src/meta.rs

@@ -11,7 +11,7 @@ use fs2::FileExt;
 use rusqlite::{params, Connection};
 
 use crate::err::{refuse, Code, Refusal, Result};
-use crate::ids::{ascii_name, hex64};
+use crate::ids::ascii_name;
 use crate::limits;
 use crate::store::Store;
 
@@ -82,19 +82,6 @@ impl Meta {
         self.lease_dir.join(format!("{id}.lease"))
     }
 
-    pub fn manifest_is_released(&self, digest: &str) -> Result<bool> {
-        hex64("manifest", digest)?;
-        let count: u64 = self
-            .connection()?
-            .query_row(
-                "SELECT count(*) FROM tensorfs_released_manifests WHERE manifest_sha256=?1",
-                [digest],
-                |row| row.get(0),
-            )
-            .map_err(|error| sql("query released manifest", error))?;
-        Ok(count != 0)
-    }
-
     pub(crate) fn txn(&self) -> Result<Txn> {
         let connection = self.connection()?;
         connection

{tensorfs-0.3.8 → tensorfs-0.3.10}/crates/tensorfs-core/src/storage.rs

@@ -1223,7 +1223,7 @@ impl GcDelete {
     }
 }
 
-fn read_repositories(root: &Path) -> Result<Vec<(Repository, Vec<u8>)>> {
+pub(crate) fn read_repositories(root: &Path) -> Result<Vec<(Repository, Vec<u8>)>> {
     let mut result = Vec::new();
     for org_path in read_dir(&root.join("repos"))? {
         if !org_path.is_dir() {

{tensorfs-0.3.8 → tensorfs-0.3.10}/crates/tensorfs-py/src/store.rs

@@ -1437,6 +1437,24 @@ impl PyStore {
         Ok(out)
     }
 
+    /// Canonical TensorFS declaration bytes for the current producer intent.
+    #[allow(clippy::too_many_arguments)]
+    #[pyo3(signature = (sources, targets, configs, order, max_new_bytes))]
+    fn derived_declaration<'p>(
+        &self,
+        py: Python<'p>,
+        sources: &Bound<'_, PyDict>,
+        targets: &Bound<'_, PyDict>,
+        configs: &Bound<'_, PyDict>,
+        order: Vec<(String, String)>,
+        max_new_bytes: u64,
+    ) -> PyResult<Bound<'p, PyBytes>> {
+        let mut declaration =
+            parse_declaration(py, sources, targets, configs, order, max_new_bytes)?;
+        let bytes = declaration.canonical_bytes().or_refuse(py)?;
+        Ok(PyBytes::new(py, &bytes))
+    }
+
     /// Open one exact tfs-019 transaction. Python supplies typed plain values; canonical
     /// declaration bytes are constructed and locked only by the compiled core.
     // PyO3 exposes these as six named boundary fields. Packing them into an opaque dict
@@ -1874,6 +1892,12 @@ impl PyDerivedWriter {
     fn commit<'p>(&self, py: Python<'p>) -> PyResult<Bound<'p, PyAny>> {
         let value = py
             .detach(|| {
+                let guards = self.guards.lock().expect("writer hold mutex poisoned");
+                let guards = guards.as_ref().ok_or_else(|| Refusal {
+                    code: Code::LEASE_REVOKED,
+                    detail: "derived writer holds were released".into(),
+                })?;
+                guards.writer_hold.still_registered(&self.meta)?;
                 derived::commit(
                     &self.store,
                     &self.meta,

{tensorfs-0.3.8 → tensorfs-0.3.10}/pyproject.toml

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

{tensorfs-0.3.8 → tensorfs-0.3.10}/python/tensorfs/_ext.pyi

@@ -481,6 +481,10 @@ class Store:
         components: Sequence[str],
         configs: Sequence[str],
     ) -> dict[str, Any]: ...
+    def derived_declaration(
+        self, sources: dict[str, Any], targets: dict[str, Any], configs: dict[str, Any],
+        order: Sequence[tuple[str, str]], max_new_bytes: int,
+    ) -> bytes: ...
     def begin_derived(
         self,
         transaction_id: str,