tensorfs 0.3.39__tar.gz → 0.3.41__tar.gz

{tensorfs-0.3.39 → tensorfs-0.3.41}/Cargo.lock

@@ -421,7 +421,7 @@ checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tensorfs-core"
-version = "0.3.39"
+version = "0.3.41"
 dependencies = [
  "fs2",
  "minicbor",
@@ -434,7 +434,7 @@ dependencies = [
 
 [[package]]
 name = "tensorfs-py"
-version = "0.3.39"
+version = "0.3.41"
 dependencies = [
  "pyo3",
  "tensorfs-core",

{tensorfs-0.3.39 → tensorfs-0.3.41}/Cargo.toml

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

{tensorfs-0.3.39 → tensorfs-0.3.41}/PKG-INFO

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

{tensorfs-0.3.39 → tensorfs-0.3.41}/crates/tensorfs-core/src/derived/resume_tests.rs

@@ -918,3 +918,153 @@ fn source_free_restore_holds_survive_gc_until_begin_or_explicit_abandon() {
     release(&source_meta, writer);
     std::fs::remove_dir_all(source.root()).unwrap();
 }
+
+/// Opt-in generated-data profile. Payloads are tiny so metadata scaling is visible.
+/// Run in release mode; elapsed time is evidence, never a flaky unit-test threshold.
+#[test]
+#[ignore]
+fn profile_derived_transaction_scaling() {
+    use std::time::Instant;
+    let scenarios = [
+        (219, 1, 1),
+        (219, 1, 10),
+        (219, 4, 10),
+        (219, 32, 10),
+        (219, 128, 10),
+        (3968, 1, 10),
+        (3968, 4, 10),
+        (219, 1, 219),
+    ];
+    for (keys, histories, writes) in scenarios {
+        let (store, meta, id, _) = fixture("row-profile");
+        let mut declaration = super::tests::created_declaration();
+        let prototype = declaration.components[0].add[0].clone();
+        declaration.components[0].add = (0..keys)
+            .map(|index| {
+                let mut tensor = prototype.clone();
+                tensor.key = format!("weight_{index:04}");
+                tensor.shape = vec![4];
+                tensor.parts[0].shape = vec![4];
+                tensor
+            })
+            .collect();
+        declaration.order = declaration.components[0]
+            .add
+            .iter()
+            .map(|tensor| ("model".into(), tensor.key.clone()))
+            .collect();
+        declaration.max_new_bytes = (keys * 16) as u64;
+        let writer = begin(&store, &meta, &id, 1, declaration, None).unwrap();
+        // Populate representative unrelated transactions without timing fixture creation.
+        let mut txn = meta.txn().unwrap();
+        let prototype = txn.rows[0].clone();
+        let row_bytes = crate::canon::write(&prototype.to_value()).len();
+        for index in 1..histories {
+            let mut row = prototype.clone();
+            row.id = ObjectRef::of(format!("history-{index}").as_bytes()).id();
+            txn.rows.push(row);
+        }
+        txn.commit().unwrap();
+        let started = Instant::now();
+        for _ in 0..20 {
+            check_writer(&meta, &id, 1).unwrap();
+        }
+        let fence_ms = started.elapsed().as_secs_f64() * 1000.0;
+        let mut part_ms = 0.0;
+        let mut checkpoint_ms = 0.0;
+        let mut prior = None;
+        for index in 0..writes {
+            let key = format!("weight_{index:04}");
+            let started = Instant::now();
+            add_part(
+                &store,
+                &meta,
+                &id,
+                1,
+                ("model", &key, "value"),
+                &mut [index as u8; 16].as_slice(),
+            )
+            .unwrap();
+            part_ms += started.elapsed().as_secs_f64() * 1000.0;
+            let started = Instant::now();
+            let (_, head) =
+                checkpoint_progress(&store, &meta, &id, 1, "profile", "model", prior.as_ref())
+                    .unwrap();
+            prior = head.head;
+            checkpoint_ms += started.elapsed().as_secs_f64() * 1000.0;
+        }
+        eprintln!("PROFILE {{\"keys\":{keys},\"histories\":{histories},\"writes\":{writes},\"row_bytes\":{row_bytes},\"fence20_ms\":{fence_ms:.3},\"add_ms\":{part_ms:.3},\"checkpoint_ms\":{checkpoint_ms:.3}}}");
+        fence(&meta, &id, 1).unwrap();
+        release(&meta, writer);
+        std::fs::remove_dir_all(store.root()).unwrap();
+    }
+}
+
+#[test]
+fn named_writer_operations_leave_other_rows_and_writer_lock_alone() {
+    use rusqlite::{params, Connection};
+    let (store, meta, first_id, declaration) = fixture("scoped-row");
+    let second_id = ObjectRef::of(b"independent writer").id();
+    let first = begin(&store, &meta, &first_id, 1, declaration.clone(), None).unwrap();
+    let second = begin(&store, &meta, &second_id, 1, declaration.clone(), None).unwrap();
+    let connection = Connection::open(crate::catalog::Catalog::path(store.root())).unwrap();
+    let untouched: Vec<u8> = connection
+        .query_row(
+            "SELECT bytes FROM tensorfs_derived_transactions WHERE id=?1",
+            [&second_id],
+            |row| row.get(0),
+        )
+        .unwrap();
+    // Corrupt unrelated history makes an accidental whole-table read fail, while
+    // a scoped mutation must preserve it byte-for-byte and mutate only this writer.
+    let damaged = ObjectRef::of(b"unrelated damaged history").id();
+    connection
+        .execute(
+            "INSERT INTO tensorfs_derived_transactions(id,bytes) VALUES(?1,?2)",
+            params![damaged, b"broken".as_slice()],
+        )
+        .unwrap();
+    data(&store, &meta, &first_id, 1, 0x31);
+    let after: Vec<u8> = connection
+        .query_row(
+            "SELECT bytes FROM tensorfs_derived_transactions WHERE id=?1",
+            [&second_id],
+            |row| row.get(0),
+        )
+        .unwrap();
+    assert_eq!(untouched, after);
+    // A read fence must succeed while an unrelated SQLite writer is active. The old
+    // BEGIN IMMEDIATE observation instead hit the five-second busy timeout.
+    connection.execute_batch("BEGIN IMMEDIATE").unwrap();
+    check_writer(&meta, &second_id, 1).unwrap();
+    assert!(completed(&meta, &second_id, 1).unwrap().0.is_empty());
+    connection.execute_batch("ROLLBACK").unwrap();
+    // A named operation does not parse unrelated history. Global inventory still
+    // reports the damaged row rather than silently skipping it.
+    check_writer(&meta, &first_id, 1).unwrap();
+    assert!(meta.derived_rows().is_err());
+    connection
+        .execute(
+            "DELETE FROM tensorfs_derived_transactions WHERE id=?1",
+            [&damaged],
+        )
+        .unwrap();
+    assert!(fence(&meta, &first_id, 1).unwrap());
+    assert_eq!(
+        check_writer(&meta, &first_id, 1).unwrap_err().code,
+        Code::WRITER_FENCED
+    );
+    check_writer(&meta, &second_id, 1).unwrap();
+    release(&meta, first);
+    let resumed = begin(&store, &meta, &first_id, 2, declaration, None).unwrap();
+    assert_eq!(completed(&meta, &first_id, 2).unwrap().0.len(), 1);
+    assert_eq!(
+        check_writer(&meta, &first_id, 1).unwrap_err().code,
+        Code::WRITER_FENCED
+    );
+    fence(&meta, &first_id, 2).unwrap();
+    fence(&meta, &second_id, 1).unwrap();
+    release(&meta, resumed);
+    release(&meta, second);
+    std::fs::remove_dir_all(store.root()).unwrap();
+}

{tensorfs-0.3.39 → tensorfs-0.3.41}/crates/tensorfs-core/src/derived.rs

@@ -2005,6 +2005,19 @@ fn inspect_retained_source(
         code: Code::ROOT_ABSENT,
         detail: "source inspection resolved no source".into(),
     })?;
+    for component in &component_names {
+        if !source
+            .header
+            .components
+            .iter()
+            .any(|(name, _)| name == component)
+        {
+            return refuse(
+                Code::MISSING_FIELD,
+                format!("source has no component {component:?}"),
+            );
+        }
+    }
     let configs = config_names
         .iter()
         .map(|name| {
@@ -2188,10 +2201,7 @@ pub fn begin(
     };
     // Byte verification can update the verification catalog. Keep it outside the SQL
     // writer transaction, then compare the observed row before assigning this epoch.
-    let initial = meta
-        .derived_rows()?
-        .into_iter()
-        .find(|row| row.id == transaction);
+    let initial = meta.derived_row(&transaction)?;
     let mut row = match planned_row(
         initial.as_ref(),
         &transaction,
@@ -2220,7 +2230,7 @@ pub fn begin(
         return Err(error);
     }
     let committed = (|| {
-        let mut txn = meta.txn()?;
+        let mut txn = meta.txn_for(&transaction)?;
         let current = txn.rows.iter_mut().find(|row| row.id == transaction);
         if current.as_deref() != initial.as_ref() {
             return refuse(
@@ -2430,8 +2440,8 @@ pub fn completed(
     transaction: &str,
     writer_session: u64,
 ) -> Result<(Vec<(String, String, String)>, Vec<String>)> {
-    let mut txn = meta.txn()?;
-    let row = open_row(&mut txn.rows, transaction, writer_session)?;
+    let mut rows: Vec<_> = meta.derived_row(transaction)?.into_iter().collect();
+    let row = open_row(&mut rows, transaction, writer_session)?;
     Ok((
         row.added_parts
             .iter()
@@ -2451,7 +2461,7 @@ pub fn checkpoint_progress(
     previous: Option<&ObjectRef>,
 ) -> Result<(String, crate::durability::Head)> {
     let progress = {
-        let mut txn = meta.txn()?;
+        let mut txn = meta.txn_for(transaction)?;
         progress_row(open_row(&mut txn.rows, transaction, writer_session)?)
     };
     let plan = progress_plan(&progress);
@@ -2513,7 +2523,7 @@ pub fn checkpoint_progress(
         objects,
         None,
     )?;
-    let mut txn = meta.txn()?;
+    let mut txn = meta.txn_for(transaction)?;
     let row = open_row(&mut txn.rows, transaction, writer_session)?;
     retain_progress(store, row, exported.head.head.as_ref())?;
     Ok((plan, exported.head))
@@ -2581,7 +2591,7 @@ pub(crate) fn retain_restore(
     if let Some(object) = object {
         require_payload_record(store, object, "restored checkpoint object")?;
     }
-    let txn = meta.txn()?;
+    let txn = meta.txn_for(&transaction)?;
     let row = txn.rows.iter().find(|row| row.id == transaction);
     let active = if let Some(row) = row {
         if row.state != TransactionState::Open {
@@ -2704,8 +2714,8 @@ fn open_row<'a>(
 
 pub fn check_writer(meta: &Meta, transaction: &str, writer_session: u64) -> Result<()> {
     let transaction = transaction_id(transaction)?;
-    let mut txn = meta.txn()?;
-    open_row(&mut txn.rows, &transaction, writer_session)?;
+    let mut rows: Vec<_> = meta.derived_row(&transaction)?.into_iter().collect();
+    open_row(&mut rows, &transaction, writer_session)?;
     Ok(())
 }
 
@@ -2716,6 +2726,83 @@ fn declaration(row: &TransactionRow) -> Result<Declaration> {
     })?)
 }
 
+/// The exact native payload limit, checked against the current writer before
+/// an embedding owner admits storage or asks a producer to supply any bytes.
+pub fn part_write_bound(
+    meta: &Meta,
+    transaction: &str,
+    writer_session: u64,
+    value: (&str, &str, &str),
+) -> Result<u64> {
+    let transaction = transaction_id(transaction)?;
+    let mut rows: Vec<_> = meta.derived_row(&transaction)?.into_iter().collect();
+    let row = open_row(&mut rows, &transaction, writer_session)?;
+    let part = declared_addition(&declaration(row)?, value)?;
+    checked_bytes("derived part write", &part.shape, part.dtype)
+}
+
+pub fn config_write_bound(
+    meta: &Meta,
+    transaction: &str,
+    writer_session: u64,
+    name: &str,
+) -> Result<u64> {
+    let transaction = transaction_id(transaction)?;
+    let mut rows: Vec<_> = meta.derived_row(&transaction)?.into_iter().collect();
+    let row = open_row(&mut rows, &transaction, writer_session)?;
+    let declaration = declaration(row)?;
+    require_added_config(&declaration, name)?;
+    Ok(declaration.max_new_bytes.min(limits::DOC_MAX_BYTES as u64))
+}
+
+fn declared_addition(
+    declaration: &Declaration,
+    (component, tensor_key, role): (&str, &str, &str),
+) -> Result<PartDeclaration> {
+    let part = declaration
+        .components
+        .iter()
+        .find(|candidate| candidate.target == component)
+        .and_then(|candidate| {
+            candidate
+                .add
+                .iter()
+                .find(|candidate| candidate.key == tensor_key)
+        })
+        .and_then(|candidate| {
+            candidate
+                .parts
+                .iter()
+                .find(|candidate| candidate.role == role)
+        })
+        .cloned()
+        .ok_or_else(|| Refusal {
+            code: Code::MISSING_FIELD,
+            detail: format!("{component}/{tensor_key}#{role} is not a declared addition"),
+        })?;
+    if part.source.is_some() {
+        return refuse(
+            Code::TRANSACTION_CONFLICT,
+            "grafted part cannot receive byte writes",
+        );
+    }
+    Ok(part)
+}
+
+fn require_added_config(declaration: &Declaration, name: &str) -> Result<()> {
+    if declaration.configs.iter().any(|config| {
+        matches!(config, ConfigDeclaration::Add { target }
+            | ConfigDeclaration::Derive { target, .. } if target == name)
+    }) {
+        Ok(())
+    } else {
+        refuse(
+            Code::MISSING_FIELD,
+            format!("{name:?} is not a declared added config"),
+        )
+    }
+}
+
 pub fn add_part<R: Read>(
     store: &Store,
     meta: &Meta,
@@ -2726,40 +2813,11 @@ pub fn add_part<R: Read>(
 ) -> Result<crate::checkpoint::Written> {
     let (component, tensor_key, role) = value;
     let transaction = transaction_id(transaction)?;
-    let (declaration, expected) = {
-        let mut txn = meta.txn()?;
+    let expected = {
+        let mut txn = meta.txn_for(&transaction)?;
         let row = open_row(&mut txn.rows, &transaction, writer_session)?;
-        let declaration = declaration(row)?;
-        let expected = declaration
-            .components
-            .iter()
-            .find(|candidate| candidate.target == component)
-            .and_then(|candidate| {
-                candidate
-                    .add
-                    .iter()
-                    .find(|candidate| candidate.key == tensor_key)
-            })
-            .and_then(|candidate| {
-                candidate
-                    .parts
-                    .iter()
-                    .find(|candidate| candidate.role == role)
-            })
-            .cloned()
-            .ok_or_else(|| Refusal {
-                code: Code::MISSING_FIELD,
-                detail: format!("{component}/{tensor_key}#{role} is not a declared addition"),
-            })?;
-        (declaration, expected)
+        declared_addition(&declaration(row)?, value)?
     };
-    let _ = declaration;
-    if expected.source.is_some() {
-        return refuse(
-            Code::TRANSACTION_CONFLICT,
-            "grafted part cannot receive byte writes",
-        );
-    }
 
     let written = checkpoint::objectize(
         store,
@@ -2791,7 +2849,7 @@ pub fn add_part<R: Read>(
         }
     }
 
-    let mut txn = meta.txn()?;
+    let mut txn = meta.txn_for(&transaction)?;
     let row = open_row(&mut txn.rows, &transaction, writer_session)?;
     if let Some(existing) = row
         .added_parts
@@ -2825,39 +2883,31 @@ pub fn add_config<R: Read>(
     reader: &mut R,
 ) -> Result<()> {
     let transaction = transaction_id(transaction)?;
-    {
-        let mut txn = meta.txn()?;
+    let maximum = {
+        let mut txn = meta.txn_for(&transaction)?;
         let row = open_row(&mut txn.rows, &transaction, writer_session)?;
         let declaration = declaration(row)?;
-        if !declaration.configs.iter().any(|config| {
-            matches!(
-                config,
-                ConfigDeclaration::Add { target }
-                    | ConfigDeclaration::Derive { target, .. }
-                    if target == config_name
-            )
-        }) {
-            return refuse(
-                Code::MISSING_FIELD,
-                format!("{config_name:?} is not a declared added config"),
-            );
-        }
-    }
+        require_added_config(&declaration, config_name)?;
+        declaration.max_new_bytes.min(limits::DOC_MAX_BYTES as u64)
+    };
 
     let mut input = Vec::new();
     reader
-        .take(limits::DOC_MAX_BYTES as u64 + 1)
+        .take(maximum + 1)
         .read_to_end(&mut input)
         .map_err(|error| Refusal {
             code: Code::IO_FAILED,
             detail: format!("read config: {error}"),
         })?;
-    if input.len() > limits::DOC_MAX_BYTES {
-        return refuse(Code::SIZE_CAP, "config exceeds the document byte cap");
+    if input.len() as u64 > maximum {
+        return refuse(
+            Code::SIZE_CAP,
+            "config exceeds the output or document byte cap",
+        );
     }
     let config = crate::header::canonical_config(&format!("config {config_name:?}"), &input)?;
 
-    let mut txn = meta.txn()?;
+    let mut txn = meta.txn_for(&transaction)?;
     let row = open_row(&mut txn.rows, &transaction, writer_session)?;
     if let Some(existing) = row
         .added_configs
@@ -3006,7 +3056,7 @@ pub fn commit(
 ) -> Result<ReceiptFacts> {
     let transaction = transaction_id(transaction)?;
     let row_before = {
-        let mut txn = meta.txn()?;
+        let mut txn = meta.txn_for(&transaction)?;
         open_row(&mut txn.rows, &transaction, writer_session)?.clone()
     };
     let declaration = declaration(&row_before)?;
@@ -3028,7 +3078,7 @@ pub fn commit(
     let (inherited_payload_objects, inherited_payload_bytes) =
         inherit_observation(&header, &row_before)?;
 
-    let mut txn = meta.txn()?;
+    let mut txn = meta.txn_for(&transaction)?;
     let row = open_row(&mut txn.rows, &transaction, writer_session)?;
     if row.added_parts != row_before.added_parts || row.added_configs != row_before.added_configs {
         return refuse(
@@ -3058,8 +3108,7 @@ pub enum Lookup {
 
 pub fn lookup(store: &Store, meta: &Meta, transaction: &str) -> Result<Lookup> {
     let transaction = transaction_id(transaction)?;
-    let rows = meta.derived_rows()?;
-    let Some(row) = rows.iter().find(|row| row.id == transaction) else {
+    let Some(ref row) = meta.derived_row(&transaction)? else {
         return Ok(Lookup::Absent);
     };
     match row.state {
@@ -3079,7 +3128,7 @@ pub fn lookup(store: &Store, meta: &Meta, transaction: &str) -> Result<Lookup> {
 
 pub fn fence(meta: &Meta, transaction: &str, writer_session: u64) -> Result<bool> {
     let transaction = transaction_id(transaction)?;
-    let mut txn = meta.txn()?;
+    let mut txn = meta.txn_for(&transaction)?;
     let row = txn
         .rows
         .iter_mut()
@@ -3098,7 +3147,7 @@ pub fn fence(meta: &Meta, transaction: &str, writer_session: u64) -> Result<bool
 
 pub fn abandon(store: &Store, meta: &Meta, transaction: &str) -> Result<Option<ReceiptFacts>> {
     let transaction = transaction_id(transaction)?;
-    let mut txn = meta.txn()?;
+    let mut txn = meta.txn_for(&transaction)?;
     let result = match txn.rows.iter_mut().find(|row| row.id == transaction) {
         None => {
             txn.rows.push(TransactionRow {
@@ -3270,7 +3319,7 @@ fn effective_disposition(
 
 pub fn dispose(store: &Store, meta: &Meta, transaction: &str) -> Result<DispositionResult> {
     let transaction = transaction_id(transaction)?;
-    let mut txn = meta.txn()?;
+    let mut txn = meta.txn_for(&transaction)?;
     let index = txn
         .rows
         .iter()

{tensorfs-0.3.39 → tensorfs-0.3.41}/crates/tensorfs-core/src/meta.rs

@@ -8,7 +8,7 @@ use std::path::PathBuf;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use fs2::FileExt;
-use rusqlite::{params, Connection};
+use rusqlite::{params, Connection, OptionalExtension};
 
 use crate::err::{refuse, Code, Refusal, Result};
 use crate::ids::ascii_name;
@@ -92,7 +92,33 @@ impl Meta {
             .execute_batch("BEGIN IMMEDIATE")
             .map_err(|error| sql("begin derived transaction", error))?;
         let rows = read_derived(&connection)?;
-        Ok(Txn { connection, rows })
+        Ok(Txn {
+            connection,
+            rows,
+            selected: None,
+        })
+    }
+
+    /// A writer mutates its own primary-key row; unrelated writers and retained history
+    /// must neither be decoded nor rewritten. The existing write lock still serializes
+    /// epoch changes, roots and accepted parts against global lifecycle operations.
+    pub(crate) fn txn_for(&self, id: &str) -> Result<Txn> {
+        let connection = self.connection()?;
+        connection
+            .execute_batch("BEGIN IMMEDIATE")
+            .map_err(|error| sql("begin derived transaction", error))?;
+        let rows = read_derived_row(&connection, id)?.into_iter().collect();
+        Ok(Txn {
+            connection,
+            rows,
+            selected: Some(id.to_string()),
+        })
+    }
+
+    /// Observations do not acquire SQLite's writer lock. Source reads check this both
+    /// before and after I/O, so a concurrent fence still invalidates the read.
+    pub(crate) fn derived_row(&self, id: &str) -> Result<Option<crate::derived::TransactionRow>> {
+        read_derived_row(&self.connection()?, id)
     }
 
     pub(crate) fn derived_rows(&self) -> Result<Vec<crate::derived::TransactionRow>> {
@@ -162,6 +188,7 @@ impl Meta {
 pub(crate) struct Txn {
     connection: Connection,
     pub(crate) rows: Vec<crate::derived::TransactionRow>,
+    selected: Option<String>,
 }
 
 impl Txn {
@@ -176,9 +203,24 @@ impl Txn {
                 "duplicate derived transaction id",
             );
         }
-        self.connection
-            .execute("DELETE FROM tensorfs_derived_transactions", [])
-            .map_err(|error| sql("clear derived transactions", error))?;
+        if let Some(id) = &self.selected {
+            if self.rows.len() > 1 || self.rows.iter().any(|row| &row.id != id) {
+                return refuse(
+                    Code::TRANSACTION_CONFLICT,
+                    "scoped transaction changed another writer",
+                );
+            }
+            self.connection
+                .execute(
+                    "DELETE FROM tensorfs_derived_transactions WHERE id=?1",
+                    [id],
+                )
+                .map_err(|error| sql("replace derived transaction", error))?;
+        } else {
+            self.connection
+                .execute("DELETE FROM tensorfs_derived_transactions", [])
+                .map_err(|error| sql("clear derived transactions", error))?;
+        }
         for row in &self.rows {
             let bytes = crate::canon::write(&row.to_value());
             self.connection
@@ -194,6 +236,33 @@ impl Txn {
     }
 }
 
+fn read_derived_row(
+    connection: &Connection,
+    id: &str,
+) -> Result<Option<crate::derived::TransactionRow>> {
+    let bytes = connection
+        .query_row(
+            "SELECT bytes FROM tensorfs_derived_transactions WHERE id=?1",
+            [id],
+            |row| row.get::<_, Vec<u8>>(0),
+        )
+        .optional()
+        .map_err(|error| sql("read derived transaction", error))?;
+    bytes
+        .map(|bytes| {
+            let value = crate::canon::parse_canonical(&bytes, limits::DOC_MAX_BYTES)?;
+            let row = crate::derived::TransactionRow::from_value(&value)?;
+            if row.id != id {
+                return refuse(
+                    Code::TRANSACTION_CONFLICT,
+                    "derived row differs from its primary key",
+                );
+            }
+            Ok(row)
+        })
+        .transpose()
+}
+
 fn read_derived(connection: &Connection) -> Result<Vec<crate::derived::TransactionRow>> {
     let mut statement = connection
         .prepare("SELECT bytes FROM tensorfs_derived_transactions ORDER BY id")

{tensorfs-0.3.39 → tensorfs-0.3.41}/crates/tensorfs-py/src/store.rs

@@ -1864,7 +1864,12 @@ impl PyStore {
         let identity = source_facts(py, std::slice::from_ref(&inspection.view))?;
         out.set_item("source", identity.get_item(0)?)?;
         let component_rows = PyList::empty(py);
-        for component in &inspection.view.fact.components {
+        // The selected fact is a normalized set. Author inspection must retain
+        // the header's construction traversal, including nonlexical components.
+        for (component, _) in &inspection.view.header.components {
+            if !inspection.view.fact.components.contains(component) {
+                continue;
+            }
             let row = PyDict::new(py);
             row.set_item("name", component)?;
             row.set_item(
@@ -2338,6 +2343,36 @@ impl PyDerivedWriter {
 
 #[pymethods]
 impl PyDerivedWriter {
+    fn part_write_bound(
+        &self,
+        py: Python<'_>,
+        component: &str,
+        key: &str,
+        role: &str,
+    ) -> PyResult<u64> {
+        py.detach(|| {
+            derived::part_write_bound(
+                &self.meta,
+                &self.transaction_id,
+                self.writer_session_id,
+                (component, key, role),
+            )
+        })
+        .or_refuse(py)
+    }
+
+    fn config_write_bound(&self, py: Python<'_>, name: &str) -> PyResult<u64> {
+        py.detach(|| {
+            derived::config_write_bound(
+                &self.meta,
+                &self.transaction_id,
+                self.writer_session_id,
+                name,
+            )
+        })
+        .or_refuse(py)
+    }
+
     /// Effective exact sources after TensorFS has checked installed identity and closure.
     fn sources<'p>(&self, py: Python<'p>) -> PyResult<Bound<'p, PyList>> {
         source_facts(py, &self.source_views)