tensorfs 0.3.78__tar.gz → 0.3.80__tar.gz

{tensorfs-0.3.78 → tensorfs-0.3.80}/Cargo.lock

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

{tensorfs-0.3.78 → tensorfs-0.3.80}/Cargo.toml

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

{tensorfs-0.3.78 → tensorfs-0.3.80}/PKG-INFO

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

{tensorfs-0.3.78 → tensorfs-0.3.80}/crates/tensorfs-core/src/bin/tfs/ingest.rs

@@ -574,6 +574,7 @@ pub fn cmd_bank(dialect: &str, converter: &str, f: &Flags) -> ExitCode {
             return ExitCode::FAILURE;
         }
         let profile = SourceProfile {
+            auto_select: true,
             name: name.to_string(),
             components,
         };

tensorfs-0.3.80/crates/tensorfs-core/src/catalog/lock.rs

@@ -0,0 +1,206 @@
+//! Waiting for another process's catalog lock by whether its holder can still release it.
+//!
+//! SQLite's locks are POSIX locks: they die with the process that holds them. A holder
+//! that is alive is committing or about to, so a writer waits for it for as long as it
+//! takes; a flat deadline refused a busy, progressing writer as if it were dead. The only
+//! holder that cannot release is one that is stopped (a debugger or SIGSTOP), and only
+//! then does a statement give up. Dead processes have already released their locks.
+//!
+//! Holders come from `/proc/locks`, matched by the catalog's inode (and its WAL `-shm`).
+//! The catalog file itself is never opened here: closing a second descriptor on it would
+//! drop every POSIX lock this process holds on it.
+
+use std::cell::RefCell;
+use std::path::{Path, PathBuf};
+use std::time::Duration;
+
+use rusqlite::Connection;
+
+use crate::err::Result;
+
+thread_local! {
+    /// The catalog this thread's statements wait on. A connection is opened for each
+    /// operation just before it is used, on the thread that uses it, so the one opened last
+    /// here is the one a busy statement belongs to.
+    static WAITING_ON: RefCell<Option<PathBuf>> = const { RefCell::new(None) };
+}
+
+/// Install the waiting handler on one connection.
+pub(crate) fn wait_for_live_holders(connection: &Connection, path: &Path) -> Result<()> {
+    WAITING_ON.with(|waiting| *waiting.borrow_mut() = Some(path.to_path_buf()));
+    connection
+        .busy_handler(Some(busy))
+        .map_err(|error| super::sql("install catalog lock wait", error))
+}
+
+fn busy(attempt: i32) -> bool {
+    let path = WAITING_ON.with(|waiting| waiting.borrow().clone());
+    if path.is_some_and(|path| holders_cannot_release(&path)) {
+        return false;
+    }
+    std::thread::sleep(Duration::from_millis(attempt.clamp(1, 64) as u64));
+    true
+}
+
+/// Every currently held write lock belongs to a stopped process. Without a current
+/// holder to name (the lock just went, or no `/proc`), keep asking.
+fn holders_cannot_release(path: &Path) -> bool {
+    let files: Vec<(u64, u64)> = [path.to_path_buf(), shm(path)]
+        .iter()
+        .filter_map(|file| std::fs::metadata(file).ok())
+        .map(|metadata| {
+            use std::os::unix::fs::MetadataExt;
+            (metadata.dev(), metadata.ino())
+        })
+        .collect();
+    let Ok(locks) = std::fs::read_to_string("/proc/locks") else {
+        return false;
+    };
+    snapshots_cannot_release(&locks, &files, std::process::id(), stopped, || {
+        std::fs::read_to_string("/proc/locks").ok()
+    })
+}
+
+fn snapshots_cannot_release(
+    observed: &str,
+    files: &[(u64, u64)],
+    own: u32,
+    is_stopped: impl Fn(u32) -> bool,
+    current: impl FnOnce() -> Option<String>,
+) -> bool {
+    let holders = write_holders(observed, files, own);
+    if holders.is_empty() || !holders.iter().all(|pid| is_stopped(*pid)) {
+        return false;
+    }
+    // A holder may unlock or exit between the lock snapshot and its process-state
+    // read. Refuse only if those stopped processes still hold the actual locks.
+    let Some(current) = current() else {
+        return false;
+    };
+    let current = write_holders(&current, files, own);
+    !current.is_empty()
+        && current
+            .iter()
+            .all(|pid| holders.contains(pid) && is_stopped(*pid))
+}
+
+fn shm(path: &Path) -> PathBuf {
+    let mut name = path.as_os_str().to_owned();
+    name.push("-shm");
+    PathBuf::from(name)
+}
+
+/// Other processes' POSIX write locks on these inodes, from `/proc/locks` lines such as
+/// `3: POSIX  ADVISORY  WRITE 167671 103:02:204736108 1073741824 1073742335`.
+fn write_holders(locks: &str, files: &[(u64, u64)], own: u32) -> Vec<u32> {
+    locks
+        .lines()
+        .filter_map(|line| {
+            let fields: Vec<&str> = line.split_whitespace().collect();
+            let at = fields.iter().position(|field| *field == "POSIX")?;
+            if fields[..at].contains(&"->") || fields.get(at + 2) != Some(&"WRITE") {
+                return None;
+            }
+            let pid: u32 = fields.get(at + 3)?.parse().ok()?;
+            let mut file = fields.get(at + 4)?.split(':');
+            let major = u32::from_str_radix(file.next()?, 16).ok()?;
+            let minor = u32::from_str_radix(file.next()?, 16).ok()?;
+            let inode: u64 = file.next()?.parse().ok()?;
+            let device = rustix::fs::makedev(major, minor) as u64;
+            (file.next().is_none() && pid != own && files.contains(&(device, inode))).then_some(pid)
+        })
+        .collect()
+}
+
+/// Only stopped and traced-stopped processes keep locks they cannot release.
+fn stopped(pid: u32) -> bool {
+    std::fs::read_to_string(format!("/proc/{pid}/stat"))
+        .ok()
+        .is_some_and(|stat| process_is_stopped(&stat))
+}
+
+fn process_is_stopped(stat: &str) -> bool {
+    stat.rsplit_once(')')
+        .and_then(|(_, fields)| fields.split_whitespace().next())
+        .is_some_and(|state| matches!(state, "T" | "t"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn only_other_processes_write_locks_on_the_catalog_are_holders() {
+        let locks = "\
+1: POSIX  ADVISORY  WRITE 4242 103:02:77 1073741824 1073742335
+2: POSIX  ADVISORY  READ  5151 103:02:77 1073741826 1073742335
+3: POSIX  ADVISORY  WRITE 6161 103:02:99 120 120
+4: FLOCK  ADVISORY  WRITE 7171 103:02:77 0 EOF
+5: POSIX  ADVISORY  WRITE 1000 103:02:77 0 EOF
+6: -> POSIX  ADVISORY  WRITE 8181 103:02:77 0 EOF
+7: POSIX  ADVISORY  WRITE 9191 104:02:77 0 EOF
+";
+        let device = rustix::fs::makedev(0x103, 2) as u64;
+        assert_eq!(write_holders(locks, &[(device, 77)], 1000), vec![4242]);
+        assert_eq!(
+            write_holders(locks, &[(device, 77), (device, 99)], 1000),
+            vec![4242, 6161]
+        );
+        assert!(write_holders(locks, &[(device, 5)], 1000).is_empty());
+    }
+
+    #[test]
+    fn exited_holder_is_progress_and_never_a_stopped_writer() {
+        for state in ["Z", "X", "R", "S", "D"] {
+            assert!(!process_is_stopped(&format!("4242 (writer) {state} 1 2 3")));
+        }
+        for state in ["T", "t"] {
+            assert!(process_is_stopped(&format!("4242 (writer) {state} 1 2 3")));
+        }
+        assert!(!process_is_stopped("unavailable"));
+    }
+
+    #[test]
+    fn stopped_holder_must_still_own_the_lock_before_refusal() {
+        let held = "1: POSIX ADVISORY WRITE 4242 103:02:77 0 EOF\n";
+        let files = [(rustix::fs::makedev(0x103, 2) as u64, 77)];
+        // Stable SIGSTOP remains a typed refusal, while snapshot -> unlock ->
+        // SIGSTOP must let SQLite retry rather than refuse the old snapshot.
+        assert!(snapshots_cannot_release(
+            held,
+            &files,
+            1000,
+            |_| true,
+            || Some(held.into())
+        ));
+        assert!(!snapshots_cannot_release(
+            held,
+            &files,
+            1000,
+            |_| true,
+            || Some(String::new())
+        ));
+        assert!(!snapshots_cannot_release(
+            held,
+            &files,
+            1000,
+            |_| true,
+            || None
+        ));
+        let replacement = held.replace("4242", "6161");
+        assert!(!snapshots_cannot_release(
+            held,
+            &files,
+            1000,
+            |_| true,
+            || Some(replacement)
+        ));
+        assert!(!snapshots_cannot_release(
+            held,
+            &files,
+            1000,
+            |_| false,
+            || panic!("a live holder must retry")
+        ));
+    }
+}

{tensorfs-0.3.78 → tensorfs-0.3.80}/crates/tensorfs-core/src/catalog.rs

@@ -104,7 +104,14 @@ pub fn connections_opened(root: &Path) -> u64 {
         .unwrap_or(0)
 }
 
-fn connect(path: &Path) -> Result<Connection> {
+pub(crate) fn connect(path: &Path) -> Result<Connection> {
+    // SQLite creates WAL/SHM files before assigning their database owner. Opening
+    // them under root exposes a transient root-owned inode to concurrent owner
+    // connections, which can permanently fall back to read-only WAL access.
+    let _identity = crate::filesystem_identity::FilesystemIdentity::for_store_root(
+        path.parent().unwrap_or(path),
+    )
+    .map_err(|error| io("enter catalog filesystem identity", error))?;
     *opened()
         .lock()
         .unwrap_or_else(|error| error.into_inner())
@@ -253,6 +260,26 @@ impl Trust {
         self.load(&mut kept).map(|_| ())
     }
 
+    /// Finish setup on the already-validated reader connection. The callback is
+    /// synchronous under its mutex; no second setup connection or credential
+    /// lifetime escapes into the returned value.
+    pub(crate) fn with_connection<T>(
+        &self,
+        use_connection: impl FnOnce(&mut Connection) -> Result<T>,
+    ) -> Result<T> {
+        let mut kept = self.kept.lock().unwrap_or_else(|error| error.into_inner());
+        self.load(&mut kept)?;
+        let connection = &mut kept.as_mut().expect("validated connection").connection;
+        // A kept connection can be used by another Runtime thread later. Install
+        // the lock context on the thread actually executing this operation.
+        lock::wait_for_live_holders(connection, &self.path)?;
+        let _identity = crate::filesystem_identity::FilesystemIdentity::for_store_root(
+            self.path.parent().unwrap_or(&self.path),
+        )
+        .map_err(|error| io("enter catalog filesystem identity", error))?;
+        use_connection(connection)
+    }
+
     fn miss(&self, sha256: &str) -> Option<crate::store::VRecord> {
         let mut kept = self.kept.lock().unwrap_or_else(|error| error.into_inner());
         if self.load(&mut kept).ok()? {

tensorfs-0.3.78/crates/tensorfs-core/src/repo_cache/identity.rs → tensorfs-0.3.80/crates/tensorfs-core/src/filesystem_identity.rs

@@ -1,11 +1,10 @@
-//! Scope optional cache writes to the local Store owner on root-squashed NFS.
+//! Scope synchronous filesystem I/O to the trusted local Store owner.
 //!
 //! Only Linux filesystem IDs change, only on the current native thread, and only
-//! while synchronous cache I/O runs. Real/effective IDs, other Runtime threads,
-//! existing cache permissions, and the configured cache path are unchanged.
+//! while Store I/O runs. Real/effective IDs, other Runtime threads, existing
+//! permissions, and configured paths are unchanged.
 
-use super::SoftFailure;
-use crate::store::Store;
+use std::{io, path::Path};
 
 #[cfg(target_os = "linux")]
 mod linux {
@@ -16,7 +15,7 @@ mod linux {
 
     use nix::unistd::{geteuid, setfsgid, setfsuid, Gid, Uid};
 
-    use super::{SoftFailure, Store};
+    use super::{io, Path};
 
     // Linux has no getfsuid/getfsgid. An invalid ID cannot be installed; each
     // setter returns the previous/current ID even when the attempted set fails.
@@ -27,14 +26,14 @@ mod linux {
         )
     }
 
-    pub(in crate::repo_cache) struct CacheIdentity {
+    pub(crate) struct FilesystemIdentity {
         previous: Option<(Uid, Gid)>,
         // A credential guard must be destroyed by the exact thread that made it.
         _thread: PhantomData<Rc<()>>,
     }
 
-    impl CacheIdentity {
-        pub(in crate::repo_cache) fn for_store(store: &Store) -> Result<Self, SoftFailure> {
+    impl FilesystemIdentity {
+        pub(crate) fn for_store_root(root: &Path) -> io::Result<Self> {
             let mut guard = Self {
                 previous: None,
                 _thread: PhantomData,
@@ -44,9 +43,12 @@ mod linux {
             }
             // Authority is the already-open LOCAL Store's owner, never a UID
             // supplied by an artifact, request, or remote cache directory.
-            let owner = fs::symlink_metadata(store.root()).map_err(|_| SoftFailure::Unavailable)?;
+            let owner = fs::symlink_metadata(root)?;
             if !owner.is_dir() || owner.uid() == u32::MAX || owner.gid() == u32::MAX {
-                return Err(SoftFailure::Unavailable);
+                return Err(io::Error::new(
+                    io::ErrorKind::PermissionDenied,
+                    "cannot enter Store filesystem identity",
+                ));
             }
             let desired = (Uid::from_raw(owner.uid()), Gid::from_raw(owner.gid()));
             let previous = filesystem_ids();
@@ -58,14 +60,17 @@ mod linux {
             setfsuid(desired.0);
             if filesystem_ids() != desired {
                 // Drop restores either field that changed before refusing the
-                // optional cache write. The origin/local operation remains valid.
-                return Err(SoftFailure::Unavailable);
+                // synchronous I/O. The caller receives the identity refusal.
+                return Err(io::Error::new(
+                    io::ErrorKind::PermissionDenied,
+                    "cannot enter Store filesystem identity",
+                ));
             }
             Ok(guard)
         }
     }
 
-    impl Drop for CacheIdentity {
+    impl Drop for FilesystemIdentity {
         fn drop(&mut self) {
             let Some((uid, gid)) = self.previous else {
                 return;
@@ -74,7 +79,7 @@ mod linux {
             setfsgid(gid);
             if filesystem_ids() != (uid, gid) {
                 // Continuing a reused Runtime thread under the wrong identity is
-                // unsafe. No cache error can reach here: this is a failed kernel
+                // unsafe. No I/O error can reach here: this is a failed kernel
                 // restoration of credentials that this thread previously held.
                 std::process::abort();
             }
@@ -84,6 +89,7 @@ mod linux {
     #[cfg(test)]
     mod tests {
         use super::*;
+        use crate::store::Store;
         use std::panic::{catch_unwind, AssertUnwindSafe};
         use std::sync::{Arc, Barrier};
         use std::time::{SystemTime, UNIX_EPOCH};
@@ -117,7 +123,7 @@ mod linux {
                     other_observed.wait();
                 });
                 {
-                    let _guard = CacheIdentity::for_store(&store).unwrap();
+                    let _guard = FilesystemIdentity::for_store_root(store.root()).unwrap();
                     assert_eq!(filesystem_ids(), desired);
                     assert!(geteuid().is_root());
                     entered.wait();
@@ -129,14 +135,14 @@ mod linux {
                 }
                 assert_eq!(filesystem_ids(), original);
             });
-            let failure: Result<(), SoftFailure> = (|| {
-                let _guard = CacheIdentity::for_store(&store)?;
-                Err(SoftFailure::Unavailable)
+            let failure: io::Result<()> = (|| {
+                let _guard = FilesystemIdentity::for_store_root(store.root())?;
+                Err(io::Error::other("owned fixture failure"))
             })();
             assert!(failure.is_err());
             assert_eq!(filesystem_ids(), original);
             let panic = catch_unwind(AssertUnwindSafe(|| {
-                let _guard = CacheIdentity::for_store(&store).unwrap();
+                let _guard = FilesystemIdentity::for_store_root(store.root()).unwrap();
                 panic!("cache operation unwind");
             }));
             assert!(panic.is_err());
@@ -148,14 +154,14 @@ mod linux {
 }
 
 #[cfg(target_os = "linux")]
-pub(super) use linux::CacheIdentity;
+pub(crate) use linux::FilesystemIdentity;
 
 #[cfg(not(target_os = "linux"))]
-pub(super) struct CacheIdentity;
+pub(crate) struct FilesystemIdentity;
 
 #[cfg(not(target_os = "linux"))]
-impl CacheIdentity {
-    pub(super) fn for_store(_: &Store) -> Result<Self, SoftFailure> {
+impl FilesystemIdentity {
+    pub(crate) fn for_store_root(_: &Path) -> io::Result<Self> {
         Ok(Self)
     }
 }

{tensorfs-0.3.78 → tensorfs-0.3.80}/crates/tensorfs-core/src/fill.rs

@@ -299,9 +299,9 @@ impl Xform {
         Ok(())
     }
 
-    /// The inverse read-back, which is what makes the wrong split structurally
-    /// unproducible rather than merely documented: slice the source on the transform's own
-    /// indexing and the three members must reassemble the source bit-for-bit.
+    /// The inverse read-back proves that the transform loses or duplicates no bytes.
+    /// It uses the transform's own indexing, so it cannot establish the producer's
+    /// QKV layout: that needs an independent projection-output regression.
     pub fn reassembles(&self, src: &[u8]) -> Result<bool> {
         match self {
             Xform::Transpose {

{tensorfs-0.3.78 → tensorfs-0.3.80}/crates/tensorfs-core/src/ingest/convert.rs

@@ -105,10 +105,10 @@ pub const CONVERTERS: [Converter; 8] = [
         reference: None,
     },
     Converter {
-        name: "h3.lora/1",
+        name: "h3.lora/2",
         dialect: "safetensors.h3_lora",
         class: Class::Permutation,
-        doc: "Native H3 LoRA A/B and Kohya down/up factors: split head-interleaved QKV B rows, swap SwiGLU B halves, preserve A and alpha without arithmetic.",
+        doc: "Trainer H3 LoRA A/B and Kohya down/up factors: split contiguous Q/K/V B thirds, swap SwiGLU B halves, preserve A and alpha without arithmetic. Original base checkpoint head interleaving belongs to h3.native/2, not this adapter state-dict dialect.",
         validated_on_real_bytes: false,
         normalization: None,
         lane: None,
@@ -1057,7 +1057,7 @@ fn plan_carrier(
     cands: &Candidates<'_>,
     p: &mut Plan,
 ) -> Result<()> {
-    if conv.name == "h3.lora/1" {
+    if conv.name == "h3.lora/2" {
         if allowed != ["plain/1"] {
             return refuse(
                 Code::UNKNOWN_ENCODING,
@@ -1913,14 +1913,12 @@ pub fn h3_geometry(
 /// The frozen golden cases for one converter: geometries whose reassembly is checked live,
 /// on real byte patterns, before the converter is allowed to touch an artifact.
 ///
-/// The RED companion is structural rather than a separate fixture: `Xform::reassembles`
-/// slices the source on the transform's own indexing and demands the three members put the
-/// source back bit-for-bit. A flat three-way split of a 56-group source passes every
-/// name/dtype/shape check and FAILS this, which is the whole point — the quarry pinned that
-/// error at ~90% numerically while nothing raised.
+/// `Xform::reassembles` checks that each declared transform preserves the source bytes.
+/// Both a contiguous split and a head-interleaved split can round-trip their own indexing;
+/// the producer's layout needs an independent projected-output test (see `h3_lora`).
 pub fn golden_cases(c: &Converter) -> Vec<(&'static str, Xform)> {
     match c.name {
-        "h3.lora/1" => vec![
+        "h3.lora/2" => vec![
             (
                 "H3 LoRA SwiGLU B rows",
                 Xform::SwapHalves {
@@ -1928,12 +1926,12 @@ pub fn golden_cases(c: &Converter) -> Vec<(&'static str, Xform)> {
                 },
             ),
             (
-                "H3 LoRA QKV B rows",
+                "H3 trainer LoRA contiguous QKV B thirds",
                 Xform::QkvSplit {
-                    groups: H3_HEADS,
+                    groups: 1,
                     shares: [1, 1, 1],
                     take: 0,
-                    unit_bytes: H3_HEAD_DIM * 16 * 2,
+                    unit_bytes: H3_HEADS * H3_HEAD_DIM * 16 * 2,
                 },
             ),
         ],

{tensorfs-0.3.78 → tensorfs-0.3.80}/crates/tensorfs-core/src/ingest/fingerprint.rs

@@ -201,6 +201,9 @@ pub struct FingerprintRegistry {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct SourceProfile {
     pub name: String,
+    /// Whether headers alone may choose this format. False requires the caller
+    /// to declare the reviewed format; shapes cannot prove semantic row layout.
+    pub auto_select: bool,
     pub components: Vec<SourceProfileComponent>,
 }
 
@@ -612,7 +615,7 @@ impl FingerprintRegistry {
                     self.source_profiles
                         .iter()
                         .map(|profile| {
-                            Value::obj(vec![
+                            let mut fields = vec![
                                 (
                                     "components",
                                     Value::arr(
@@ -677,7 +680,11 @@ impl FingerprintRegistry {
                                     ),
                                 ),
                                 ("name", Value::str(profile.name.clone())),
-                            ])
+                            ];
+                            if !profile.auto_select {
+                                fields.push(("auto_select", Value::Bool(false)));
+                            }
+                            Value::obj(fields)
                         })
                         .collect(),
                 ),
@@ -692,6 +699,11 @@ fn parse_source_profiles(value: &Value) -> Result<Vec<SourceProfile>> {
     for value in as_arr("FingerprintRegistry", "source_profiles", value)? {
         let mut fields = Fields::new("SourceProfile", value)?;
         let name = fields.req_str("name")?.to_string();
+        let auto_select = match fields.opt("auto_select") {
+            None => true,
+            Some(Value::Bool(value)) => *value,
+            Some(_) => return refuse(Code::WRONG_TYPE, "SourceProfile.auto_select must be bool"),
+        };
         ascii_name("source profile", &name, limits::MAX_NAME_BYTES)?;
         let mut components = Vec::new();
         for value in as_arr("SourceProfile", "components", fields.req("components")?)? {
@@ -838,7 +850,11 @@ fn parse_source_profiles(value: &Value) -> Result<Vec<SourceProfile>> {
                 format!("source profile {name:?} repeats a component"),
             );
         }
-        profiles.push(SourceProfile { name, components });
+        profiles.push(SourceProfile {
+            name,
+            auto_select,
+            components,
+        });
     }
     let mut names: Vec<&str> = profiles
         .iter()
@@ -1044,10 +1060,12 @@ mod tests {
         let mut registry = registry();
         registry.source_profiles = vec![
             SourceProfile {
+                auto_select: true,
                 name: "profile/a".into(),
                 components: vec![source_component(Some("a/model.index.json"), None)],
             },
             SourceProfile {
+                auto_select: true,
                 name: "profile/b".into(),
                 components: vec![
                     source_component(Some("b/model.safetensors"), None),
@@ -1070,6 +1088,7 @@ mod tests {
     fn exact_source_members_refuses_missing_or_non_exact_profiles() {
         let mut registry = registry();
         registry.source_profiles = vec![SourceProfile {
+            auto_select: true,
             name: "profile/prefix".into(),
             components: vec![source_component(None, Some("weights/"))],
         }];

{tensorfs-0.3.78 → tensorfs-0.3.80}/crates/tensorfs-core/src/ingest/h3_lora.rs

@@ -1,9 +1,12 @@
-//! Reviewed native H3 LoRA dialects -> canonical projection factors.
+//! Reviewed trainer H3 LoRA dialects -> canonical projection factors.
 //!
 //! These adapters omit base Q/K norm tensors, so this dialect declares the exact
 //! H3 geometry (56 heads of 128). Every target shape must agree before a plan is
-//! emitted. This is structural conversion, not permission to apply a FL2VA-trained
-//! adapter to REF2VA. Runtime owns that binding and never parses foreign keys.
+//! emitted. Trainer QKV factors use contiguous Q/K/V thirds: the original base
+//! checkpoint's head interleave is reordered before training, not exported again
+//! in adapter state dictionaries. This is structural conversion, not permission
+//! to apply a FL2VA-trained adapter to REF2VA. Runtime owns that binding and never
+//! parses foreign keys.
 
 use std::collections::BTreeMap;
 
@@ -229,10 +232,14 @@ pub(super) fn plan(
             let transform = if leaf == "attn.qkv_proj" {
                 shape[0] /= 3;
                 Some(Xform::QkvSplit {
-                    groups: H3_HEADS,
+                    groups: 1,
                     shares: [1, 1, 1],
                     take: take as u8,
-                    unit_bytes: checked_bytes(&b.key, &[H3_HEAD_DIM, a.shape[0]], b.dtype)?,
+                    unit_bytes: checked_bytes(
+                        &b.key,
+                        &[H3_HEADS * H3_HEAD_DIM, a.shape[0]],
+                        b.dtype,
+                    )?,
                 })
             } else if leaf == "mlp.fc1" {
                 Some(Xform::SwapHalves {

{tensorfs-0.3.78 → tensorfs-0.3.80}/crates/tensorfs-core/src/ingest/preflight.rs

@@ -340,9 +340,6 @@ pub fn select_members(
             .collect()
     };
     let (own, all) = (carriers(false), carriers(true));
-    if profiles.is_empty() && all.len() == 1 {
-        return Ok(all);
-    }
     let heads = read_heads(&resolution.select(&all)?)?;
     let plan_over = |carriers: &[String]| -> Result<(Vec<String>, bool)> {
         let members = resolution.select(carriers)?.members;