tensorfs 0.2.0__tar.gz → 0.2.1__tar.gz

{tensorfs-0.2.0 → tensorfs-0.2.1}/Cargo.lock

@@ -249,7 +249,7 @@ checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tensorfs-core"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "fs2",
  "minicbor",
@@ -258,7 +258,7 @@ dependencies = [
 
 [[package]]
 name = "tensorfs-py"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "pyo3",
  "tensorfs-core",

{tensorfs-0.2.0 → tensorfs-0.2.1}/Cargo.toml

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

{tensorfs-0.2.0 → tensorfs-0.2.1}/PKG-INFO

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

{tensorfs-0.2.0 → tensorfs-0.2.1}/crates/tensorfs-core/src/bin/tfs/layout.rs

@@ -14,7 +14,7 @@ use tensorfs_core::capability::CapabilityRecords;
 use tensorfs_core::checkpoint as ck;
 use tensorfs_core::dtype::Dtype;
 use tensorfs_core::fit::{
-    self, Accepts, CodeTopology, CompatibilityReport, Custody, Fit, Requirement,
+    self, Accepts, CompatibilityReport, Custody, Fit, TensorRequirement, TensorRequirements,
 };
 use tensorfs_core::grade::{self, ConversionRegistration, Grade, GradeDecision, Mapping, Registry};
 use tensorfs_core::header::Header;
@@ -51,10 +51,10 @@ macro_rules! rd {
     };
 }
 
-/// A header's own topology, projected into a code topology. This is the IDENTITY contract:
+/// A header projected into tensor requirements. This is the identity contract:
 /// what a `load()` that constructs exactly this checkpoint would require. It is the
 /// starting point for every real pair — you edit one side and grade the difference.
-pub fn cmd_topology(root: &Path, hex: &str, flags: &Flags) -> ExitCode {
+pub fn cmd_requirements(root: &Path, hex: &str, flags: &Flags) -> ExitCode {
     let store = ok!(Store::open(root));
     let length = match fs::metadata(store.object_path(hex)) {
         Ok(m) => m.len(),
@@ -73,16 +73,16 @@ pub fn cmd_topology(root: &Path, hex: &str, flags: &Flags) -> ExitCode {
     if let Some(p) = flag(flags, "emit-header") {
         let _ = fs::write(p, ok!(header.canonical_bytes()));
     }
-    let code = project(&header, flag(flags, "contract").unwrap_or("local"));
-    emit(&code, flags);
-    println!("contract     {}", code.contract);
-    println!("tensors      {}", code.count());
-    println!("tensor schema {}", code.tensor_schema_digest());
+    let requirements = project(&header, flag(flags, "contract").unwrap_or("local"));
+    emit(&requirements, flags);
+    println!("contract     {}", requirements.contract);
+    println!("tensors      {}", requirements.count());
+    println!("tensor schema {}", requirements.tensor_schema_digest());
     ExitCode::SUCCESS
 }
 
-pub fn project(h: &Header, contract_name: &str) -> CodeTopology {
-    CodeTopology {
+pub fn project(h: &Header, contract_name: &str) -> TensorRequirements {
+    TensorRequirements {
         contract: tensorfs_core::ids::object_id(contract_name.as_bytes()),
         components: h
             .components
@@ -94,7 +94,7 @@ pub fn project(h: &Header, contract_name: &str) -> CodeTopology {
                         .map(|(k, t)| {
                             (
                                 k.clone(),
-                                Requirement {
+                                TensorRequirement {
                                     dtype: t.dtype,
                                     shape: t.shape.clone(),
                                     accepts: Accepts::OneOf(vec![t.encoding.clone()]),
@@ -110,14 +110,14 @@ pub fn project(h: &Header, contract_name: &str) -> CodeTopology {
     }
 }
 
-/// `tfs fit <code-topology.json> <root> <header> [--custody local] [--device <class>
+/// `tfs fit <tensor-requirements.json> <root> <header> [--custody local] [--device <class>
 /// --observations <obs.json>] [--json]` — design §3, the only compatibility verdict.
 ///
 /// `<header>` is a header object id in `<root>` or a path to header bytes. Exit 0 on
 /// `ok`; every refusal has its own exit code so a caller can branch without parsing, and
 /// `--json` prints the total machine document (`machine::fit_json`).
-pub fn cmd_fit(code_p: &Path, root: &Path, header_arg: &str, flags: &Flags) -> ExitCode {
-    let code = ok!(CodeTopology::parse(&rd!(code_p)));
+pub fn cmd_fit(requirements_p: &Path, root: &Path, header_arg: &str, flags: &Flags) -> ExitCode {
+    let requirements = ok!(TensorRequirements::parse(&rd!(requirements_p)));
     let header = match tensorfs_core::ids::hex64("header", header_arg) {
         Ok(_) => {
             let store = ok!(Store::open(root));
@@ -152,7 +152,7 @@ pub fn cmd_fit(code_p: &Path, root: &Path, header_arg: &str, flags: &Flags) -> E
     }
     let t = Instant::now();
     let verdict = ok!(fit::fit(
-        &code,
+        &requirements,
         &header,
         custody,
         device,
@@ -178,7 +178,7 @@ pub fn cmd_fit(code_p: &Path, root: &Path, header_arg: &str, flags: &Flags) -> E
     ExitCode::from(verdict.exit_code())
 }
 
-/// Build a canonical header + code topology out of NEUTRAL measured rows.
+/// Build a canonical header + tensor requirements out of NEUTRAL measured rows.
 ///
 /// The rows carry component, key, logical dtype/shape and the measured role geometry, and
 /// nothing else — no format marks, no canonical bytes. That split is deliberate: the
@@ -219,7 +219,7 @@ pub fn cmd_import(rows_p: &Path, flags: &Flags) -> ExitCode {
 
     let mut closure = tensorfs_core::header::Closure::default();
     let mut out: Vec<(String, tensorfs_core::header::Tensor)> = Vec::new();
-    let mut reqs: Vec<(String, Requirement)> = Vec::new();
+    let mut reqs: Vec<(String, TensorRequirement)> = Vec::new();
     for tv in tensors {
         let mut tf = match tensorfs_core::canon::Fields::new("row", tv) {
             Ok(x) => x,
@@ -327,7 +327,7 @@ pub fn cmd_import(rows_p: &Path, flags: &Flags) -> ExitCode {
         ));
         reqs.push((
             key,
-            Requirement {
+            TensorRequirement {
                 dtype,
                 shape,
                 accepts: Accepts::OneOf(vec![sid]),
@@ -366,7 +366,7 @@ pub fn cmd_import(rows_p: &Path, flags: &Flags) -> ExitCode {
         components: vec![(component.clone(), out)],
     };
     ok!(header.validate(&closure));
-    let code = CodeTopology {
+    let requirements = TensorRequirements {
         contract: tensorfs_core::ids::object_id(provenance.as_bytes()),
         components: vec![(component.clone(), reqs)],
         constructed_components: vec![component],
@@ -374,8 +374,8 @@ pub fn cmd_import(rows_p: &Path, flags: &Flags) -> ExitCode {
     if let Some(p) = flag(flags, "out-header") {
         let _ = fs::write(p, ok!(header.canonical_bytes()));
     }
-    if let Some(p) = flag(flags, "out-code") {
-        let _ = fs::write(p, code.canonical_bytes());
+    if let Some(p) = flag(flags, "out-requirements") {
+        let _ = fs::write(p, requirements.canonical_bytes());
     }
     if let Some(d) = flag(flags, "out-closure") {
         let _ = fs::create_dir_all(d);
@@ -394,7 +394,7 @@ pub fn cmd_import(rows_p: &Path, flags: &Flags) -> ExitCode {
     println!("  parts      PLACEHOLDER object ids: no weight bytes transit this machine");
     println!("header       {}", ok!(header.object_id()));
     println!("tensor schema {}", header.tensor_schema_digest());
-    println!("code         {}", code.object_id());
+    println!("requirements {}", requirements.object_id());
     for (id, s) in &closure.specs {
         println!(
             "  spec       {} roles {:?}",
@@ -497,7 +497,7 @@ fn emit_bytes(bytes: &[u8], flags: &Flags) {
 }
 
 /// `check_compatibility` over two documents on disk. Zero tensor bytes are read: the whole
-/// decision is a function of a code topology, a header and a closure, which is exactly why
+/// decision is a function of tensor requirements, a header and a closure, which is exactly why
 /// it is decidable before a download.
 ///
 /// `--depth` picks the question. The default is `first-mismatch` — PREFLIGHT, "can this
@@ -512,8 +512,8 @@ fn emit_bytes(bytes: &[u8], flags: &Flags) {
 /// be read" and "some card has a qualified implementation for them" are two independent
 /// questions; the second is `tfs capability`, and a caller cannot ask it without knowing
 /// which pairs to ask about.
-pub fn cmd_check(code_p: &Path, header_p: &Path, flags: &Flags) -> ExitCode {
-    let code = ok!(CodeTopology::parse(&rd!(code_p)));
+pub fn cmd_check(requirements_p: &Path, header_p: &Path, flags: &Flags) -> ExitCode {
+    let requirements = ok!(TensorRequirements::parse(&rd!(requirements_p)));
     let header = ok!(Header::parse(&rd!(header_p)));
     let mut closure = tensorfs_core::header::Closure::default();
     for p in flag(flags, "closure").unwrap_or("").split(',') {
@@ -540,10 +540,20 @@ pub fn cmd_check(code_p: &Path, header_p: &Path, flags: &Flags) -> ExitCode {
     ));
     let t = Instant::now();
     let out = ok!(fit::check_compatibility(
-        &code, &header, &closure, &pin, custody, depth
+        &requirements,
+        &header,
+        &closure,
+        &pin,
+        custody,
+        depth
     ));
     let us = t.elapsed().as_secs_f64() * 1e6;
-    let report = ok!(CompatibilityReport::of(&code, &header, custody, &out));
+    let report = ok!(CompatibilityReport::of(
+        &requirements,
+        &header,
+        custody,
+        &out
+    ));
     emit(&report, flags);
 
     // The machine surface (proto-020). A caller that shells out to this command must not
@@ -780,11 +790,11 @@ pub fn cmd_grade(report_p: &Path, flags: &Flags) -> ExitCode {
         Err(c) => return c,
     };
     // Grading over a report ALONE cannot prove a registration closes the whole gap; holding
-    // both documents can. `--code`/`--header` supply them here.
+    // both documents can. `--requirements`/`--header` supply them here.
     let t = Instant::now();
-    let g = match (flag(flags, "code"), flag(flags, "header")) {
+    let g = match (flag(flags, "requirements"), flag(flags, "header")) {
         (Some(c), Some(h)) => {
-            let code = ok!(CodeTopology::parse(&rd!(Path::new(c))));
+            let requirements = ok!(TensorRequirements::parse(&rd!(Path::new(c))));
             let header = ok!(Header::parse(&rd!(Path::new(h))));
             let mut closure = tensorfs_core::header::Closure::default();
             for p in flag(flags, "closure").unwrap_or("").split(',') {
@@ -801,7 +811,7 @@ pub fn cmd_grade(report_p: &Path, flags: &Flags) -> ExitCode {
                     .collect(),
             };
             ok!(grade::resolve(
-                &code,
+                &requirements,
                 &header,
                 &closure,
                 &pin,
@@ -968,14 +978,14 @@ fn stream_in(path: Option<&Path>) -> Result<(Box<dyn BufRead>, bool), ExitCode>
 /// same document — literally the same `grade_json` — so the single-pair form is not a
 /// different surface with a shared name, and a preflight caller is never made to batch.
 ///
-/// The registry is loaded ONCE for the whole stream. `--prove-with` (`--code`/`--header`)
+/// The registry is loaded ONCE for the whole stream. `--prove-with` (`--requirements`/`--header`)
 /// is single-pair only: proving a registration closes the whole gap needs both documents of
 /// THAT pair, and a batch has one registry and many pairs.
 pub fn cmd_grade_stream(path: Option<&Path>, flags: &Flags) -> ExitCode {
-    if flag(flags, "code").is_some() || flag(flags, "header").is_some() {
+    if flag(flags, "requirements").is_some() || flag(flags, "header").is_some() {
         eprintln!(
-            "REFUSED UNKNOWN_FIELD: --prove-with is single-pair only: it holds the code \
-             topology and header of ONE pair, and a batch carries many"
+            "REFUSED UNKNOWN_FIELD: --prove-with is single-pair only: it holds the tensor \
+             requirements and header of ONE pair, and a batch carries many"
         );
         return ExitCode::FAILURE;
     }

{tensorfs-0.2.0 → tensorfs-0.2.1}/crates/tensorfs-core/src/bin/tfs/main.rs

@@ -24,7 +24,7 @@
 //! distinct code per refusal (10..16, see `Fit::exit_code`); `--json` prints the machine
 //! document.
 //!
-//!   tfs fit <code-topology.json> <root> <header> [--custody canonical|local]
+//!   tfs fit <tensor-requirements.json> <root> <header> [--custody canonical|local]
 //!       [--device <class> --observations <obs.json>] [--json]
 //!
 //! Qualification (tfs-008): what an (encoding, device) pair is QUALIFIED to execute.
@@ -95,7 +95,9 @@ use std::time::Instant;
 use tensorfs_core::canon;
 use tensorfs_core::dtype::Dtype;
 use tensorfs_core::err::Refusal;
-use tensorfs_core::fit::{self, Accepts, CodeTopology, CompatibilityReport, Custody, Requirement};
+use tensorfs_core::fit::{
+    self, Accepts, CompatibilityReport, Custody, TensorRequirement, TensorRequirements,
+};
 use tensorfs_core::grade::{self, ConversionRegistration, Mapping};
 use tensorfs_core::header::{Asset, Body, Closure, Header, Part, Tensor};
 use tensorfs_core::ids::{Doc, ObjectRef, Plain};
@@ -248,7 +250,7 @@ fn main() -> ExitCode {
         ["fetch", "admit", r, p, i] => fetch::cmd_admit(Path::new(r), Path::new(p), i, &flags),
         ["fetch", "complete", r, p] => fetch::cmd_complete(Path::new(r), Path::new(p)),
         ["compat", "import", r] => layout::cmd_import(Path::new(r), &flags),
-        ["compat", "topology", r, h] => layout::cmd_topology(Path::new(r), h, &flags),
+        ["compat", "requirements", r, h] => layout::cmd_requirements(Path::new(r), h, &flags),
         ["compat", "check", c, h] => layout::cmd_check(Path::new(c), Path::new(h), &flags),
         ["compat", "release-cut", r] => layout::cmd_release_cut(Path::new(r)),
         ["grade", "decision", d] => layout::cmd_decision(Path::new(d)),
@@ -902,24 +904,24 @@ fn stamp_doc(
 }
 
 /// The layout plane's three frozen documents, all derived from the corpus header so the
-/// vector and the live path cannot describe different things. The code topology is the
-/// header's OWN topology (a contract that asks for exactly what is there is the Satisfied
+/// vector and the live path cannot describe different things. The requirements are the
+/// header's own tensor schema (a contract that asks for exactly what is there is the Satisfied
 /// case), and the registration is run, not asserted.
 #[allow(clippy::type_complexity)]
 /// The layout plane's frozen documents, produced together because every one of them is a
 /// projection of the SAME header and the same base contract — which is what makes the
 /// verdicts they earn comparable.
 struct LayoutPlane {
-    code: CodeTopology,
+    requirements: TensorRequirements,
     report: CompatibilityReport,
     registration: ConversionRegistration,
     worst_full: CompatibilityReport,
     worst_first: CompatibilityReport,
-    recast: CodeTopology,
+    recast: TensorRequirements,
     recast_report: CompatibilityReport,
     /// The planted contract behind `worst_*`: a dtype cast on the first key and a shape
     /// edit on the last, the `tfs fit` shape-mismatch arm.
-    worst: CodeTopology,
+    worst: TensorRequirements,
     /// The CONVERTIBLE arm: every required dtype widened to f32, which the registered
     /// lossless bf16 -> f32 mapping closes. CONVERTIBLE is the only grade that populates
     /// `remedy_registration` and `remedy_mapping`, and tensorhub reads both, so the machine
@@ -928,8 +930,8 @@ struct LayoutPlane {
 }
 
 fn layout_plane_docs(h: &Header, closure: &Closure) -> TfsResult<LayoutPlane> {
-    let code = CodeTopology {
-        contract: tensorfs_core::ids::object_id(b"CodeTopology:corpus"),
+    let requirements = TensorRequirements {
+        contract: tensorfs_core::ids::object_id(b"TensorRequirements:corpus"),
         components: h
             .components
             .iter()
@@ -940,7 +942,7 @@ fn layout_plane_docs(h: &Header, closure: &Closure) -> TfsResult<LayoutPlane> {
                         .map(|(k, t)| {
                             (
                                 k.clone(),
-                                Requirement {
+                                TensorRequirement {
                                     dtype: t.dtype,
                                     shape: t.shape.clone(),
                                     accepts: Accepts::Any,
@@ -956,14 +958,14 @@ fn layout_plane_docs(h: &Header, closure: &Closure) -> TfsResult<LayoutPlane> {
     };
     let pin: Vec<String> = h.encodings.iter().map(EncodingSpec::object_id).collect();
     let out = fit::check_compatibility(
-        &code,
+        &requirements,
         h,
         closure,
         &pin,
         Custody::Canonical,
         fit::Depth::Full,
     )?;
-    let report = CompatibilityReport::of(&code, h, Custody::Canonical, &out)?;
+    let report = CompatibilityReport::of(&requirements, h, Custody::Canonical, &out)?;
     let reg = ConversionRegistration::register(
         "bf16-to-f32",
         Mapping::Widen {
@@ -981,7 +983,7 @@ fn layout_plane_docs(h: &Header, closure: &Closure) -> TfsResult<LayoutPlane> {
     // Graded on the FIRST fact the pair reads PRODUCIBLE and a catalog would offer the
     // conversion; graded on the WHOLE set it is INCOMPATIBLE. Both reports are frozen with
     // their verdicts so the two answers cannot silently become one.
-    let mut worst = code.clone();
+    let mut worst = requirements.clone();
     let keys: usize = worst.components.iter().map(|(_, k)| k.len()).sum();
     if keys < 2 {
         return Err(tensorfs_core::err::Refusal {
@@ -1010,7 +1012,7 @@ fn layout_plane_docs(h: &Header, closure: &Closure) -> TfsResult<LayoutPlane> {
     // The same contract with every required dtype recast and NOTHING else touched. This
     // remains a compact regression for the dtype-remedy path after deleting the old
     // shape-only catalog index.
-    let mut recast = code.clone();
+    let mut recast = requirements.clone();
     for (_, keys) in recast.components.iter_mut() {
         for (_, r) in keys.iter_mut() {
             r.dtype = Dtype::F8E4M3FN;
@@ -1028,7 +1030,7 @@ fn layout_plane_docs(h: &Header, closure: &Closure) -> TfsResult<LayoutPlane> {
 
     // THE CONVERTIBLE ARM. Same shape as the recast above, widened the other way: every
     // required dtype becomes f32, so the gap is exactly the lossless cast `reg` registers.
-    let mut widen = code.clone();
+    let mut widen = requirements.clone();
     for (_, keys) in widen.components.iter_mut() {
         for (_, r) in keys.iter_mut() {
             r.dtype = Dtype::F32;
@@ -1044,7 +1046,7 @@ fn layout_plane_docs(h: &Header, closure: &Closure) -> TfsResult<LayoutPlane> {
     )?;
     let widen_report = CompatibilityReport::of(&widen, h, Custody::Canonical, &out)?;
     Ok(LayoutPlane {
-        code,
+        requirements,
         report,
         registration: reg,
         worst_full: whole_set,
@@ -1268,7 +1270,7 @@ fn build_corpus() -> TfsResult<(Vec<Case>, Vec<EncodingSpec>)> {
         "stamp",
         "stamp",
         stmp.canonical_bytes(),
-        "the verified ledger: topology, candidate set, converter, golden, accounting",
+        "the verified ledger: tensor schema, candidate set, converter, golden, accounting",
     ));
     cases.push(ok_case(
         "ingest",
@@ -1278,9 +1280,9 @@ fn build_corpus() -> TfsResult<(Vec<Case>, Vec<EncodingSpec>)> {
         "one evidence arm; signer in the envelope; binds its stamp",
     ));
 
-    // --- the layout plane (tfs-009): code topology, report, registration
+    // --- the layout plane (tfs-009): tensor requirements, report, registration
     let LayoutPlane {
-        code,
+        requirements,
         report,
         registration: reg,
         worst_full,
@@ -1292,9 +1294,9 @@ fn build_corpus() -> TfsResult<(Vec<Case>, Vec<EncodingSpec>)> {
     } = layout_plane_docs(&ha, &closure)?;
     cases.push(ok_case(
         "layout",
-        "code-topology",
-        "code_topology",
-        code.canonical_bytes(),
+        "tensor-requirements",
+        "tensor_requirements",
+        requirements.canonical_bytes(),
         "the meta-device census of factory(config), projected: accepts, pinned dtypes, \
          constructed components",
     ));
@@ -1326,8 +1328,8 @@ fn build_corpus() -> TfsResult<(Vec<Case>, Vec<EncodingSpec>)> {
     ));
     cases.push(ok_case(
         "layout",
-        "code-topology-recast",
-        "code_topology",
+        "tensor-requirements-recast",
+        "tensor_requirements",
         recast.canonical_bytes(),
         "the same contract with only the dtypes recast: a different tensor schema digest",
     ));
@@ -1375,21 +1377,21 @@ fn build_corpus() -> TfsResult<(Vec<Case>, Vec<EncodingSpec>)> {
     cases.push(red_case(
         "layout-red",
         "unconstructed-component",
-        "code_topology",
+        "tensor_requirements",
         sub(
-            &code.canonical_bytes(),
+            &requirements.canonical_bytes(),
             "\"constructed_components\":[",
             "\"constructed_components\":[\"ghost\",",
         ),
         "MISSING_COMPONENT",
-        "constructed_components names exactly the components the topology carries",
+        "constructed_components names exactly the components the requirements carry",
     ));
     cases.push(red_case(
         "layout-red",
         "empty-accepts",
-        "code_topology",
+        "tensor_requirements",
         sub(
-            &code.canonical_bytes(),
+            &requirements.canonical_bytes(),
             "\"accepts\":\"any\"",
             "\"accepts\":[]",
         ),
@@ -1553,13 +1555,13 @@ fn build_corpus() -> TfsResult<(Vec<Case>, Vec<EncodingSpec>)> {
     // `tfs fit --json` (tfs-042): the one code <-> checkpoint answer, frozen on the ok arm
     // and on a planted shape edit so the eight-code vocabulary and its §3 text are held.
     {
-        let ok = fit::fit(&code, &ha, Custody::Canonical, Some("cpu"), None)?;
+        let ok = fit::fit(&requirements, &ha, Custody::Canonical, Some("cpu"), None)?;
         cases.push(ok_case(
             "machine",
             "fit-ok",
             "machine_fit",
             tensorfs_core::machine::fit_json(&ok, Custody::Canonical),
-            "the code constructs exactly what the checkpoint carries: `ok`, routes counted, \
+            "the requirements describe exactly what the checkpoint carries: `ok`, routes counted, \
              encoded leaves qualified on the device asked about",
         ));
         let planted = fit::fit(&worst, &ha, Custody::Canonical, None, None)?;
@@ -2283,8 +2285,8 @@ fn cmd_gen(dir: &Path) -> ExitCode {
                 let h = Header::parse(&c.bytes).unwrap();
                 v += &format!("tensor_schema: {}\n", h.tensor_schema_digest());
             }
-            if c.doc == "code_topology" {
-                let code = tensorfs_core::fit::CodeTopology::parse(&c.bytes).unwrap();
+            if c.doc == "tensor_requirements" {
+                let code = tensorfs_core::fit::TensorRequirements::parse(&c.bytes).unwrap();
                 v += &format!("tensor_schema: {}\n", code.tensor_schema_digest());
             }
             if c.doc == "manifest" {

{tensorfs-0.2.0 → tensorfs-0.2.1}/crates/tensorfs-core/src/bin/tfs/rd.rs

@@ -45,7 +45,7 @@ fn load(root: &Path, hex: &str) -> Result<(Store, Manifest, Header), Refusal> {
 }
 
 /// Every component this header carries. The `tfs` CLI's own plans are whole-artifact by
-/// construction — it has no code topology to narrow by — so it declares the full set
+/// construction — it has no tensor requirements to narrow by — so it declares the full set
 /// (#570b). A caller that binds a subset declares the subset.
 fn all_components(h: &Header) -> Vec<String> {
     h.components.iter().map(|(c, _)| c.clone()).collect()

{tensorfs-0.2.0 → tensorfs-0.2.1}/crates/tensorfs-core/src/corpus.rs

@@ -42,7 +42,7 @@ pub const DOC_KINDS: &[&str] = &[
     "session",
     "receipt",
     "stamp",
-    "code_topology",
+    "tensor_requirements",
     "compat_report",
     // proto-020: the CLI's `--json` machine surfaces, frozen like every other
     // cross-boundary document because they ARE one — tensorhub decodes them.
@@ -96,9 +96,9 @@ pub fn run_doc(
         "session" => IngestSession::parse(bytes).map(|_| (None, None))?,
         "receipt" => IngestVerificationReceipt::parse(bytes).map(|_| (None, None))?,
         "stamp" => crate::ingest::stamp::Stamp::parse(bytes).map(|_| (None, None))?,
-        // The layout plane's documents (tfs-009). A code topology projects to the SAME
+        // The layout plane's documents (tfs-009). A tensor requirements projects to the SAME
         // frozen projection a header does, so its digest is reported here too.
-        "code_topology" => crate::fit::CodeTopology::parse(bytes)
+        "tensor_requirements" => crate::fit::TensorRequirements::parse(bytes)
             .map(|c| (Some(c.tensor_schema_digest()), None))?,
         // The machine surfaces (proto-020). The document is a projection, not a stored
         // object, so there is no reader to round-trip it through: what a consumer needs