tensorfs 0.3.70__tar.gz → 0.3.71__tar.gz

{tensorfs-0.3.70 → tensorfs-0.3.71}/Cargo.lock

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

{tensorfs-0.3.70 → tensorfs-0.3.71}/Cargo.toml

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

{tensorfs-0.3.70 → tensorfs-0.3.71}/PKG-INFO

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

{tensorfs-0.3.70 → tensorfs-0.3.71}/crates/tensorfs-core/src/bin/tfs/ingest.rs

@@ -445,7 +445,7 @@ pub fn cmd_bank(dialect: &str, converter: &str, f: &Flags) -> ExitCode {
     let mut reviewed = Vec::new();
     for (component, path) in &srcs {
         let (full, raw) = ok!(source_core::read_carrier_at(path));
-        let h = if conv.name == "single_file.identity/1" {
+        let h = if conv.dialect == "safetensors.single_file" {
             ok!(convert::single_file_component(component, &full))
         } else {
             full
@@ -584,11 +584,11 @@ pub fn cmd_bank(dialect: &str, converter: &str, f: &Flags) -> ExitCode {
             .collect::<Vec<_>>()
             .join(",");
         let variant = flag(f, "spec-variant").and_then(|value| value.parse().ok());
-        let mut prepared = match source_core::prepare_with_registry(
+        let mut prepared = match source_core::prepare(
             &target,
             &unnamed(&srcs),
             &CarrierSet::default(),
-            &reg,
+            Some(&reg),
             variant,
         ) {
             Ok(prepared) => prepared,
@@ -849,17 +849,22 @@ fn prepare_closed_source_plan(
     if closed.registry != BUILTIN_REGISTRY {
         flags.push(("registry".to_string(), closed.registry.clone()));
     }
+    let as_is = closed.converter == convert::IDENTITY;
+    if as_is {
+        flags.push(("source-profile".to_string(), source_core::AS_IS.to_string()));
+    }
     for (component, source) in &closed.sources {
         flags.push((
             "source".to_string(),
             format!("{component}={}", source.path.to_string_lossy()),
         ));
     }
-    let mut prepared = source_core::prepare_with_registry(
+    // The plan was re-derived above, so its converter is the planner's: as-is has no registry.
+    let mut prepared = source_core::prepare(
         &closed.target,
         &closed.sources,
         &closed.set,
-        &registry,
+        (!as_is).then_some(&registry),
         None,
     )
     .map_err(bail)?;
@@ -989,15 +994,17 @@ pub(crate) fn construction_order(f: &Flags) -> Result<Vec<(String, String)>, Exi
 
 /// Headers in, plan out. The one function `plan`, `run` and the worker all go through, so
 /// a preview and a run cannot disagree about what was going to happen.
+/// `--source-profile as-is/1` stores the sources as they are, unclassified.
 fn prepare(f: &Flags, target: &str) -> Result<Prepared, ExitCode> {
     let sources = sources(f)?;
     let registry = load_registry(f)?;
     let variant = flag(f, "spec-variant").and_then(|value| value.parse().ok());
-    source_core::prepare_with_registry(
+    let as_is = flag(f, "source-profile") == Some(source_core::AS_IS);
+    source_core::prepare(
         target,
         &unnamed(&sources),
         &CarrierSet::default(),
-        &registry,
+        (!as_is).then_some(&registry),
         variant,
     )
     .map_err(bail)
@@ -1206,6 +1213,7 @@ pub fn cmd_run(root: &Path, target: &str, f: &Flags) -> ExitCode {
                 | "tenant"
                 | "isolation-tier"
                 | "checkpoint-bytes"
+                | "source-profile"
         ) {
             argv.push(format!("--{k}"));
             argv.push(v.clone());

{tensorfs-0.3.70 → tensorfs-0.3.71}/crates/tensorfs-core/src/derived/companion_tests.rs

@@ -196,6 +196,50 @@ fn ordinary_companions_survive_derivation_without_copying_tensor_backing_files()
     std::fs::remove_dir_all(store.root()).unwrap();
 }
 
+#[test]
+fn a_verified_store_object_is_a_companion_by_reference_and_never_a_new_byte() {
+    let (store, meta, id) = fixture();
+    let vocab = vec![0x7b; 256 << 10]; // over the inline bound: references have none
+    let object = store
+        .put_stream(
+            &mut vocab.as_slice(),
+            Some(&ObjectRef::of(&vocab)),
+            &Fault::default(),
+        )
+        .unwrap()
+        .obj;
+    let mut d = super::tests::created_declaration();
+    d.objects = vec![("tokenizer/vocab.json".into(), object.clone())];
+    let encoded = d.canonical_work_bytes().unwrap();
+    assert_eq!(
+        Declaration::parse_text(std::str::from_utf8(&encoded).unwrap()).unwrap(),
+        d
+    );
+    let writer = begin(&store, &meta, &id, 1, d.clone(), None).unwrap();
+    write_weight(&store, &meta, &id);
+    let receipt = commit(&store, &meta, &id, 1).unwrap();
+    release(&meta, writer);
+    assert!(!receipt.added_objects.contains(&object));
+    let header = checkpoint::load_header(&store, &receipt.header).unwrap();
+    let (name, asset) = &header.assets[0];
+    assert_eq!(
+        (name.as_str(), &asset.segments),
+        ("tokenizer/vocab.json", &vec![object])
+    );
+    let mut read = Vec::new();
+    checkpoint::read_asset(&store, name, asset, &mut read).unwrap();
+    assert_eq!(read, vocab);
+
+    // An object this Store does not hold is refused at commit, never published.
+    let next = format!("sha256:{}", "c3".repeat(32));
+    d.objects = vec![("tokenizer/vocab.json".into(), ObjectRef::of(b"absent"))];
+    let writer = begin(&store, &meta, &next, 1, d, None).unwrap();
+    write_weight(&store, &meta, &next);
+    assert!(commit(&store, &meta, &next, 1).is_err());
+    release(&meta, writer);
+    std::fs::remove_dir_all(store.root()).unwrap();
+}
+
 #[test]
 fn companion_paths_size_count_and_quotas_are_native_refusals() {
     for path in [

{tensorfs-0.3.70 → tensorfs-0.3.71}/crates/tensorfs-core/src/derived.rs

@@ -181,6 +181,9 @@ pub struct Declaration {
     pub configs: Vec<ConfigDeclaration>,
     /// Bounded immutable ordinary companion files, locked into the work intent.
     pub files: Vec<(String, Vec<u8>)>,
+    /// Companion files that are already verified Store objects (a pinned tokenizer), named
+    /// by reference: no bytes in the intent, none new in the output.
+    pub objects: Vec<(String, ObjectRef)>,
     pub order: Vec<(String, String)>,
     pub max_new_bytes: u64,
 }
@@ -248,6 +251,19 @@ impl Declaration {
         }
 
         validate_files(&mut self.files)?;
+        self.objects.sort_by(|a, b| a.0.cmp(&b.0));
+        let mut paths: Vec<String> = self
+            .files
+            .iter()
+            .map(|(path, _)| path.clone())
+            .chain(std::iter::once("model.cozytensors".to_string()))
+            .collect();
+        for (path, object) in &self.objects {
+            crate::manifest::check_path(path)?;
+            crate::ids::hex64("companion object", &object.sha256)?;
+            paths.push(path.clone());
+        }
+        validate_companion_paths(&mut paths)?;
 
         for source in &self.sources {
             name("source alias", &source.alias)?;
@@ -563,6 +579,15 @@ impl Declaration {
                 ));
             }
         }
+        let mut objects = Vec::new();
+        if let Some(value) = f.opt("objects") {
+            for (path, value) in as_obj("DerivedDeclaration", "objects", value)? {
+                objects.push((
+                    path.clone(),
+                    ObjectRef::from_value("companion object", value)?,
+                ));
+            }
+        }
         let work_fingerprint = f
             .opt("work_fingerprint")
             .map(|value| {
@@ -710,6 +735,7 @@ impl Declaration {
             components,
             configs,
             files,
+            objects,
             order,
             max_new_bytes,
         })
@@ -873,6 +899,17 @@ impl Declaration {
                 ),
             ));
         }
+        if !self.objects.is_empty() {
+            fields.push((
+                "objects",
+                Value::map(
+                    self.objects
+                        .iter()
+                        .map(|(path, object)| (path.clone(), object.to_value()))
+                        .collect(),
+                ),
+            ));
+        }
         if let Some(fingerprint) = &self.work_fingerprint {
             fields.push(("work_fingerprint", Value::str(fingerprint.clone())));
         }
@@ -947,6 +984,7 @@ fn companion_files(
         .files
         .iter()
         .map(|(path, _)| path.as_str())
+        .chain(declaration.objects.iter().map(|(path, _)| path.as_str()))
         .collect();
     for source in sources {
         let mut backing: HashSet<_> = source
@@ -989,6 +1027,12 @@ fn companion_files(
             .iter()
             .map(|(path, data)| (path.clone(), Entry::File(ObjectRef::of(data)))),
     );
+    files.extend(
+        declaration
+            .objects
+            .iter()
+            .map(|(path, object)| (path.clone(), Entry::File(object.clone()))),
+    );
     let mut paths: Vec<_> = files
         .keys()
         .cloned()
@@ -2197,6 +2241,7 @@ fn inspect_retained_source(
     let alias = "source".to_string();
     let mut declaration = Declaration {
         files: Vec::new(),
+        objects: Vec::new(),
         work_fingerprint: None,
         sources: vec![Source {
             alias: alias.clone(),
@@ -3932,6 +3977,7 @@ mod tests {
             .object_id();
         Declaration {
             files: Vec::new(),
+            objects: Vec::new(),
             work_fingerprint: Some(format!("sha256:{}", "44".repeat(32))),
             sources: Vec::new(),
             components: vec![ComponentDeclaration {
@@ -3961,6 +4007,7 @@ mod tests {
     fn inherited_declaration(manifest: ObjectRef) -> Declaration {
         Declaration {
             files: Vec::new(),
+            objects: Vec::new(),
             work_fingerprint: Some(format!("sha256:{}", "44".repeat(32))),
             sources: vec![Source {
                 alias: "source".into(),
@@ -4574,6 +4621,7 @@ mod tests {
             1,
             Declaration {
                 files: Vec::new(),
+                objects: Vec::new(),
                 work_fingerprint: Some(format!("sha256:{}", "44".repeat(32))),
                 sources: vec![Source {
                     alias: "source".into(),

{tensorfs-0.3.70 → tensorfs-0.3.71}/crates/tensorfs-core/src/fill.rs

@@ -109,6 +109,13 @@ pub enum Xform {
         /// Bytes in one share unit — derived from the source run, never assumed.
         unit_bytes: u64,
     },
+    /// A row-major `[rows, cols]` matrix becomes `[cols, rows]`. Every element moves on its
+    /// own, so this is gather-class by construction: it is applied buffered, never as runs.
+    Transpose {
+        rows: u64,
+        cols: u64,
+        elem_bytes: u64,
+    },
 }
 
 impl Xform {
@@ -122,6 +129,11 @@ impl Xform {
                 unit_bytes,
                 ..
             } => groups * (shares[0] + shares[1] + shares[2]) * unit_bytes,
+            Xform::Transpose {
+                rows,
+                cols,
+                elem_bytes,
+            } => rows * cols * elem_bytes,
         }
     }
 
@@ -135,6 +147,36 @@ impl Xform {
                 take,
                 unit_bytes,
             } => groups * shares[*take as usize] * unit_bytes,
+            Xform::Transpose { .. } => self.in_bytes(),
+        }
+    }
+
+    /// Whether the transform streams its source runs straight out of the carrier. A
+    /// transpose reads its bounded source once and reorders it in memory instead.
+    pub fn streams(&self) -> bool {
+        !matches!(self, Xform::Transpose { .. })
+    }
+
+    /// `(bytes, runs, class)` of the decomposition, without materializing element runs.
+    pub fn census(&self) -> (u64, usize, Class) {
+        match self {
+            Xform::Transpose {
+                rows,
+                cols,
+                elem_bytes,
+            } => (
+                rows * cols * elem_bytes,
+                (rows * cols) as usize,
+                if *elem_bytes >= GATHER_FLOOR_BYTES {
+                    Class::LongRun
+                } else {
+                    Class::Gather
+                },
+            ),
+            _ => {
+                let d = self.runs();
+                (d.bytes, d.runs.len(), d.class)
+            }
         }
     }
 
@@ -175,6 +217,21 @@ impl Xform {
                         .collect(),
                 )
             }
+            Xform::Transpose {
+                rows,
+                cols,
+                elem_bytes,
+            } => Decomposition::of(
+                (0..*cols)
+                    .flat_map(|j| {
+                        (0..*rows).map(move |i| Run {
+                            src_off: (i * cols + j) * elem_bytes,
+                            dest_off: (j * rows + i) * elem_bytes,
+                            len: *elem_bytes,
+                        })
+                    })
+                    .collect(),
+            ),
         }
     }
 
@@ -206,6 +263,24 @@ impl Xform {
                 ),
             );
         }
+        if let Xform::Transpose {
+            rows,
+            cols,
+            elem_bytes,
+        } = *self
+        {
+            let (rows, cols, e) = (rows as usize, cols as usize, elem_bytes as usize);
+            for (i, row) in src.chunks_exact(cols * e).enumerate() {
+                for (j, value) in row.chunks_exact(e).enumerate() {
+                    dest[(j * rows + i) * e..][..e].copy_from_slice(value);
+                }
+            }
+            return Ok(Decomposition {
+                runs: Vec::new(),
+                class: Class::Gather,
+                bytes: self.out_bytes(),
+            });
+        }
         let d = self.runs();
         for r in &d.runs {
             let (s, o, n) = (r.src_off as usize, r.dest_off as usize, r.len as usize);
@@ -229,6 +304,26 @@ impl Xform {
     /// indexing and the three members must reassemble the source bit-for-bit.
     pub fn reassembles(&self, src: &[u8]) -> Result<bool> {
         match self {
+            Xform::Transpose {
+                rows,
+                cols,
+                elem_bytes,
+            } => {
+                let mut once = Vec::new();
+                self.apply(src, &mut once)?;
+                let mut back = Vec::new();
+                Xform::Transpose {
+                    rows: *cols,
+                    cols: *rows,
+                    elem_bytes: *elem_bytes,
+                }
+                .apply(&once, &mut back)?;
+                Ok(back == src
+                    && self.runs().runs.iter().all(|r| {
+                        once[r.dest_off as usize..][..r.len as usize]
+                            == src[r.src_off as usize..][..r.len as usize]
+                    }))
+            }
             Xform::SwapHalves { .. } => {
                 let mut swapped = Vec::new();
                 self.apply(src, &mut swapped)?;

{tensorfs-0.3.70 → tensorfs-0.3.71}/crates/tensorfs-core/src/ingest/convert.rs

@@ -51,9 +51,25 @@ pub struct Converter {
     /// Quarry-derived geometry that has NOT yet met the real bytes it describes (tfs-010).
     /// Stated in the type so a receipt cannot quietly claim more than the evidence supports.
     pub validated_on_real_bytes: bool,
+    /// `(state, dialect of the stored keys)` for the output's `normalization` config:
+    /// `raw` keys need a consumer that reads that dialect, `normalized` ones are canonical.
+    /// `None` records nothing (reviewed outputs that predate the record).
+    pub normalization: Option<(&'static str, &'static str)>,
+    /// The one declared value change a converter may make: floating sources narrow to this
+    /// dtype, IEEE round-to-nearest-even, and a finite value it cannot hold refuses
+    /// NUMBER_RANGE. `None` moves bytes only.
+    pub lane: Option<Dtype>,
+    /// The pinned repository (`hf://org/repo@<commit>`, a Diffusers pipeline) whose index,
+    /// configs, scheduler and tokenizers the output needs when its source carries none.
+    pub reference: Option<&'static str>,
 }
 
-pub const CONVERTERS: [Converter; 5] = [
+/// The header config an output's [`Converter::normalization`] is recorded under.
+pub const NORMALIZATION: &str = "normalization";
+/// The converter for a source no reviewed profile recognizes: its keys, stored as they are.
+pub const IDENTITY: &str = "identity/1";
+
+pub const CONVERTERS: [Converter; 7] = [
     Converter {
         name: "diffusers.identity/1",
         dialect: "safetensors.diffusers",
@@ -62,6 +78,9 @@ pub const CONVERTERS: [Converter; 5] = [
               becomes one logical tensor; `.weight_scale` siblings fold into their base as \
               encoding ROLES; marker tensors are dropped. Bytes stream through untouched.",
         validated_on_real_bytes: true,
+        normalization: None,
+        lane: None,
+        reference: None,
     },
     Converter {
         name: "single_file.identity/1",
@@ -70,6 +89,9 @@ pub const CONVERTERS: [Converter; 5] = [
         doc: "One file carrying several components, split on the reviewed component prefix \
               map. Same byte path as the diffusers converter — packaging is not identity.",
         validated_on_real_bytes: true,
+        normalization: None,
+        lane: None,
+        reference: None,
     },
     Converter {
         name: "cozytensors.inherit/1",
@@ -78,6 +100,9 @@ pub const CONVERTERS: [Converter; 5] = [
         doc: "An already-canonical source. Every untouched tensor carries by OBJECT \
               REFERENCE; nothing is re-hashed and nothing is re-uploaded.",
         validated_on_real_bytes: true,
+        normalization: None,
+        lane: None,
+        reference: None,
     },
     Converter {
         name: "h3.lora/1",
@@ -85,6 +110,9 @@ pub const CONVERTERS: [Converter; 5] = [
         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.",
         validated_on_real_bytes: false,
+        normalization: None,
+        lane: None,
+        reference: None,
     },
     Converter {
         name: "h3.native/2",
@@ -106,9 +134,59 @@ pub const CONVERTERS: [Converter; 5] = [
         // pinned official converter requires. The complete trained Ref2VA block0
         // fc1 (308281344 B) converted to e7cf97ae...3b19; fc2 stayed byte-identical.
         validated_on_real_bytes: true,
+        normalization: None,
+        lane: None,
+        reference: None,
+    },
+    Converter {
+        name: IDENTITY,
+        dialect: "safetensors",
+        class: Class::Identity,
+        doc: "An unrecognized source, stored as it is: every key becomes one plain tensor \
+              under its own name and dtype. Nothing is folded, dropped or renamed, so a \
+              consumer that needs another spelling normalizes it.",
+        validated_on_real_bytes: true,
+        normalization: Some(("raw", "safetensors")),
+        lane: None,
+        reference: None,
+    },
+    Converter {
+        name: super::routes::SDXL,
+        dialect: "safetensors.single_file",
+        class: Class::Permutation,
+        doc: "An SDXL single-file checkpoint becomes the Diffusers constructor's checkpoint: \
+              the generated route table rekeys every tensor into constructor order, splits \
+              OpenCLIP's fused in_proj into q|k|v runs, transposes its text_projection, \
+              squeezes 1x1-conv attention to linear and drops CLIP position IDs and \
+              logit_scale. bf16/f32 sources narrow to f16. Pipeline index, configs and \
+              tokenizers come from the pinned SDXL base reference.",
+        // The generated table equals packages-v2 sdxl normalization.json route for route, the
+        // mapping the sdxl normalize job served real Civitai checkpoints with.
+        validated_on_real_bytes: true,
+        normalization: Some(("normalized", "diffusers")),
+        lane: Some(Dtype::F16),
+        reference: Some(
+            "hf://stabilityai/stable-diffusion-xl-base-1.0@462165984030d82259a11f4367a4eed129e94a7b",
+        ),
     },
 ];
 
+/// The `normalization` config the output of `converter` carries, if it records one.
+pub fn normalization_config(converter: &str) -> Option<(String, Vec<u8>)> {
+    let converter_row = CONVERTERS.iter().find(|c| c.name == converter)?;
+    let (state, dialect) = converter_row.normalization?;
+    let mut fields = vec![
+        ("converter", crate::canon::Value::str(converter)),
+        ("dialect", crate::canon::Value::str(dialect)),
+        ("state", crate::canon::Value::str(state)),
+    ];
+    if let Some(reference) = converter_row.reference {
+        fields.push(("reference", crate::canon::Value::str(reference)));
+    }
+    let record = crate::canon::Value::obj(fields);
+    Some((NORMALIZATION.to_string(), crate::canon::write(&record)))
+}
+
 pub fn converter(name: &str) -> Result<&'static Converter> {
     match CONVERTERS.iter().find(|c| c.name == name) {
         Some(c) => Ok(c),
@@ -359,11 +437,11 @@ impl Plan {
         for o in &self.ops {
             for r in &o.roles {
                 if let Bytes::Permute { xform, .. } = &r.bytes {
-                    let d = xform.runs();
+                    let (moved, count, class) = xform.census();
                     ops += 1;
-                    bytes += d.bytes;
-                    runs += d.runs.len();
-                    gather |= d.class == crate::fill::Class::Gather;
+                    bytes += moved;
+                    runs += count;
+                    gather |= class == crate::fill::Class::Gather;
                 }
             }
         }
@@ -968,6 +1046,12 @@ fn plan_carrier(
         }
         return super::h3_lora::plan(component, file, h, cands.plain, p);
     }
+    if conv.name == IDENTITY {
+        return plan_as_is(component, file, h, allowed, cands.plain, p);
+    }
+    if let Some(table) = super::routes::table(conv.name) {
+        return super::routes::plan(conv, table, component, file, h, allowed, cands.plain, p);
+    }
     let alias = Allowed(allowed);
     p.header_bytes += h.header_bytes;
     let plain_map = role_map("plain/1")?;
@@ -1232,6 +1316,46 @@ fn plan_carrier(
     Ok(())
 }
 
+/// Every key, its own plain tensor: no role folds, no marker drops, no rename.
+fn plan_as_is(
+    component: &str,
+    file: usize,
+    h: &SourceHeader,
+    allowed: &[&str],
+    plain: &EncodingSpec,
+    p: &mut Plan,
+) -> Result<()> {
+    if allowed != ["plain/1"] {
+        return refuse(
+            Code::UNKNOWN_ENCODING,
+            format!("{IDENTITY} stores an unrecognized source in plain/1 only"),
+        );
+    }
+    p.header_bytes += h.header_bytes;
+    let (data, id) = (role_map("plain/1")?.data, plain.object_id());
+    for t in &h.tensors {
+        p.ops.push(Op {
+            component: component.to_string(),
+            out_key: t.key.clone(),
+            encoding: "plain/1".into(),
+            encoding_id: id.clone(),
+            logical_dtype: t.dtype,
+            logical_shape: t.shape.clone(),
+            roles: vec![RolePlan {
+                role: data.into(),
+                dtype: t.dtype,
+                shape: t.shape.clone(),
+                bytes: Bytes::Stream {
+                    file,
+                    key: t.key.clone(),
+                },
+            }],
+            effect: Effect::Recontain,
+        });
+    }
+    Ok(())
+}
+
 /// The original H3 MLP consumes [gate; value], while Diffusers SwiGLU consumes
 /// [value; gate]. The sibling fc2 projection proves the gate width, for main and
 /// token-refiner blocks alike. Only source runs move; no tensor value changes.
@@ -1776,6 +1900,25 @@ pub fn golden_cases(c: &Converter) -> Vec<(&'static str, Xform)> {
                 },
             ),
         ],
+        name if name == super::routes::SDXL => vec![
+            (
+                "OpenCLIP in_proj_bias, row block 2 of 3 (1280 x f16)",
+                Xform::QkvSplit {
+                    groups: 1,
+                    shares: [2, 1, 0],
+                    take: 1,
+                    unit_bytes: 1280 * 2,
+                },
+            ),
+            (
+                "OpenCLIP text_projection 3 x 5 x f32 transpose",
+                Xform::Transpose {
+                    rows: 3,
+                    cols: 5,
+                    elem_bytes: 4,
+                },
+            ),
+        ],
         "h3.native/2" => vec![
             (
                 "h3-swiglu gate/value rows",

{tensorfs-0.3.70 → tensorfs-0.3.71}/crates/tensorfs-core/src/ingest/fingerprint.rs

@@ -1,4 +1,6 @@
-//! Classification: what IS this carrier, and does a reviewed registry entry authorize it?
+//! Classification: what IS this carrier, and which reviewed converter and profile fit it?
+//! The registry is a HINT: a source it does not recognize is stored as it is
+//! (`source::AS_IS`), never refused for being unknown.
 //!
 //! Three separations this file exists to keep:
 //!
@@ -417,7 +419,8 @@ impl FingerprintRegistry {
                 Code::UNREGISTERED_FINGERPRINT,
                 format!(
                     "{what}: key set {} ({} logical keys) matches no reviewed registry entry. \
-                     A filename never authorizes; bank the fingerprint under review first.",
+                     A filename never authorizes: bank the fingerprint under review, or plan \
+                     the source as-is.",
                     fp.keyset_digest, fp.logical_keys
                 ),
             ),

{tensorfs-0.3.70 → tensorfs-0.3.71}/crates/tensorfs-core/src/ingest/journal.rs

@@ -237,6 +237,16 @@ pub fn plan_digest(plan: &Plan, headers: &[(PathBuf, &SourceHeader)]) -> String
                             field(&mut hash, b"swap-halves");
                             field(&mut hash, &half_bytes.to_le_bytes());
                         }
+                        Xform::Transpose {
+                            rows,
+                            cols,
+                            elem_bytes,
+                        } => {
+                            field(&mut hash, b"transpose");
+                            for n in [rows, cols, elem_bytes] {
+                                field(&mut hash, &n.to_le_bytes());
+                            }
+                        }
                     }
                 }
             }