icadkit 0.3.7__tar.gz → 0.3.8__tar.gz

{icadkit-0.3.7 → icadkit-0.3.8}/Cargo.lock

@@ -89,7 +89,7 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "icad-core"
-version = "0.3.7"
+version = "0.3.8"
 dependencies = [
  "flate2",
  "parasolid-core",
@@ -99,7 +99,7 @@ dependencies = [
 
 [[package]]
 name = "icad-python"
-version = "0.3.7"
+version = "0.3.8"
 dependencies = [
  "icad-core",
  "parasolid-core",

{icadkit-0.3.7 → icadkit-0.3.8}/Cargo.toml

@@ -3,7 +3,8 @@ members = ["crates/icad-core", "crates/icad-python"]
 resolver = "3"
 
 [workspace.package]
-version = "0.3.7"
+# Release version source. Update with: python3 scripts/bump_version.py X.Y.Z
+version = "0.3.8"
 edition = "2024"
 rust-version = "1.88"
 license = "PolyForm-Noncommercial-1.0.0"

{icadkit-0.3.7 → icadkit-0.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: icadkit
-Version: 0.3.7
+Version: 0.3.8
 Classifier: Development Status :: 2 - Pre-Alpha
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: Implementation :: CPython
@@ -32,7 +32,7 @@ A Rust-based Python reader for **iCAD SX `.icd` files**. Read saved part
 structure, coordinate frames, names and selected attributes; inspect native
 box/cylinder parameters; and extract embedded Parasolid geometry.
 
-Version **0.3.7** adds:
+Version **0.3.7** added:
 
 - [Saved final bodies](docs/saved-bodies.md) on rolling-ball blend surfaces
   and on toroidal faces that reach their axis, through `parasolid-core 0.3.7`
@@ -88,6 +88,30 @@ The optional OCCT dependency requires glibc 2.31+ on Linux; see
 To build from a source checkout or sdist, install Rust 1.88+ and a C linker,
 then run `python -m pip install .` (or `'.[preview]'`).
 
+## Updating the package version
+
+`[workspace.package].version` in `Cargo.toml` is the single release-version
+source. Both Rust crates inherit it, Maturin derives the Python package version
+from it, and `icadkit.__version__` / the CLI use the installed package metadata.
+With Python 3.11+, Cargo and uv available, update it with one command:
+
+```sh
+python3 scripts/bump_version.py 0.3.8
+python3 scripts/bump_version.py --check --tag v0.3.8
+```
+
+The version above is an example. The command updates the workspace version,
+synchronizes `Cargo.lock` and `uv.lock`, and checks their consistency. On failure
+it restores all three files. Add `--offline` to use cached dependencies. Stable
+`X.Y.Z` and development `X.Y.Z-dev.N` versions are supported; Python metadata
+uses `X.Y.Z.devN` for the latter. `--check` does not modify the source or locks.
+CI checks the same rules and requires release tags to match the source version.
+
+The `parasolid-core` and `parasolid-kit` dependency pins have their own versions
+and are updated separately. Historical versions in this README and the
+[changelog](docs/changelog.md) describe when features were introduced; retain
+those numbers and write new release notes when preparing a release.
+
 ## Part structure, frames and attributes
 
 ```python

{icadkit-0.3.7 → icadkit-0.3.8}/README.md

@@ -4,7 +4,7 @@ A Rust-based Python reader for **iCAD SX `.icd` files**. Read saved part
 structure, coordinate frames, names and selected attributes; inspect native
 box/cylinder parameters; and extract embedded Parasolid geometry.
 
-Version **0.3.7** adds:
+Version **0.3.7** added:
 
 - [Saved final bodies](docs/saved-bodies.md) on rolling-ball blend surfaces
   and on toroidal faces that reach their axis, through `parasolid-core 0.3.7`
@@ -60,6 +60,30 @@ The optional OCCT dependency requires glibc 2.31+ on Linux; see
 To build from a source checkout or sdist, install Rust 1.88+ and a C linker,
 then run `python -m pip install .` (or `'.[preview]'`).
 
+## Updating the package version
+
+`[workspace.package].version` in `Cargo.toml` is the single release-version
+source. Both Rust crates inherit it, Maturin derives the Python package version
+from it, and `icadkit.__version__` / the CLI use the installed package metadata.
+With Python 3.11+, Cargo and uv available, update it with one command:
+
+```sh
+python3 scripts/bump_version.py 0.3.8
+python3 scripts/bump_version.py --check --tag v0.3.8
+```
+
+The version above is an example. The command updates the workspace version,
+synchronizes `Cargo.lock` and `uv.lock`, and checks their consistency. On failure
+it restores all three files. Add `--offline` to use cached dependencies. Stable
+`X.Y.Z` and development `X.Y.Z-dev.N` versions are supported; Python metadata
+uses `X.Y.Z.devN` for the latter. `--check` does not modify the source or locks.
+CI checks the same rules and requires release tags to match the source version.
+
+The `parasolid-core` and `parasolid-kit` dependency pins have their own versions
+and are updated separately. Historical versions in this README and the
+[changelog](docs/changelog.md) describe when features were introduced; retain
+those numbers and write new release notes when preparing a release.
+
 ## Part structure, frames and attributes
 
 ```python

{icadkit-0.3.7 → icadkit-0.3.8}/corpus/public.jsonl

@@ -1,8 +1,8 @@
-{"expected": {"byte_order": "little", "resources": 0}, "family": "synthetic-framing", "holdout": false, "id": "native-uninterpreted", "license": "PolyForm-Noncommercial-1.0.0; see corpus/README.md for profile notices", "path": "native-uninterpreted.icd", "provenance": "authored synthetic; corpus/generate.py and tests/geometry_fixtures.py", "sha256": "d4bb2e63c5cccdac66488f8679740b5962713b9d7dbee0e252f584b722958fc7"}
-{"expected": {"byte_order": "little", "codes": [], "resources": 1, "status": {"brep": "complete", "extraction": "complete", "raw_geometry": "complete", "topology": "complete"}, "wire": {"counts": {"bodies": 1, "curves": 1, "edges": 1, "faces": 0, "points": 2, "vertices": 2}, "length": 5}}, "family": "synthetic-wire", "holdout": false, "id": "wire-little-raw", "license": "PolyForm-Noncommercial-1.0.0; see corpus/README.md for profile notices", "path": "wire-little-raw.icd", "provenance": "authored synthetic; corpus/generate.py and tests/geometry_fixtures.py", "sha256": "75102af13dca3d14d69f268b16fc2889242cb23e64365f36b7459c570e9a85bf"}
-{"expected": {"byte_order": "little", "codes": [], "resources": 1, "status": {"brep": "complete", "extraction": "complete", "raw_geometry": "complete", "topology": "complete"}, "wire": {"counts": {"bodies": 1, "curves": 1, "edges": 1, "faces": 0, "points": 2, "vertices": 2}, "length": 5}}, "family": "synthetic-wire", "holdout": false, "id": "wire-little-zlib", "license": "PolyForm-Noncommercial-1.0.0; see corpus/README.md for profile notices", "path": "wire-little-zlib.icd", "provenance": "authored synthetic; corpus/generate.py and tests/geometry_fixtures.py", "sha256": "a2ef56b2ba29e11ecfd838f41e6d87c7cc6587123b4ef7832a45b3bb10a53d2b"}
-{"expected": {"byte_order": "big", "codes": [], "resources": 1, "status": {"brep": "complete", "extraction": "complete", "raw_geometry": "complete", "topology": "complete"}, "wire": {"counts": {"bodies": 1, "curves": 1, "edges": 1, "faces": 0, "points": 2, "vertices": 2}, "length": 5}}, "family": "synthetic-wire", "holdout": false, "id": "wire-big-raw", "license": "PolyForm-Noncommercial-1.0.0; see corpus/README.md for profile notices", "path": "wire-big-raw.icd", "provenance": "authored synthetic; corpus/generate.py and tests/geometry_fixtures.py", "sha256": "68ed994d8917e553b59381eb1d56874c4fc7243080fd0b45cee027066bf7829f"}
-{"expected": {"byte_order": "big", "codes": [], "resources": 1, "status": {"brep": "complete", "extraction": "complete", "raw_geometry": "complete", "topology": "complete"}, "wire": {"counts": {"bodies": 1, "curves": 1, "edges": 1, "faces": 0, "points": 2, "vertices": 2}, "length": 5}}, "family": "synthetic-wire", "holdout": false, "id": "wire-big-zlib", "license": "PolyForm-Noncommercial-1.0.0; see corpus/README.md for profile notices", "path": "wire-big-zlib.icd", "provenance": "authored synthetic; corpus/generate.py and tests/geometry_fixtures.py", "sha256": "c18e05dea1a40493193a7662557663f5b17b8d6204bbe1ce03b3c43ceceaecc9"}
-{"expected": {"byte_order": "little", "codes": ["schema.missing_base_schema"], "resources": 1, "status": {"brep": "not_checked", "extraction": "complete", "raw_geometry": "unsupported", "topology": "not_checked"}}, "family": "synthetic-wire", "holdout": false, "id": "unknown-schema", "license": "PolyForm-Noncommercial-1.0.0; see corpus/README.md for profile notices", "path": "unknown-schema.icd", "provenance": "authored synthetic; corpus/generate.py and tests/geometry_fixtures.py", "sha256": "18df3e23fa400bc197b9f13c99b280682d92d05bcbbe9bfa0d12fd185996977d"}
-{"expected": {"byte_order": "little", "codes": ["brep.invalid_reference"], "resources": 1, "status": {"brep": "invalid", "extraction": "complete", "raw_geometry": "complete", "topology": "not_checked"}}, "family": "synthetic-wire", "holdout": false, "id": "invalid-reference", "license": "PolyForm-Noncommercial-1.0.0; see corpus/README.md for profile notices", "path": "invalid-reference.icd", "provenance": "authored synthetic; corpus/generate.py and tests/geometry_fixtures.py", "sha256": "c684eb6d0935eb7693386e8221d08a73378414a2c80ce24deeb8929a533f962d"}
-{"expected": {"byte_order": "little", "codes": ["compression.invalid"], "resources": 1, "status": {"brep": "not_checked", "extraction": "invalid", "raw_geometry": "not_checked", "topology": "not_checked"}}, "family": "synthetic-wire", "holdout": false, "id": "invalid-checksum", "license": "PolyForm-Noncommercial-1.0.0; see corpus/README.md for profile notices", "path": "invalid-checksum.icd", "provenance": "authored synthetic; corpus/generate.py and tests/geometry_fixtures.py", "sha256": "cc4e1cdf103193a503db080b0e694865bfaff133ef198c7c41460f093c90e426"}
+{"expected": {"byte_order": "little", "resources": 0}, "family": "synthetic-framing", "holdout": false, "id": "native-uninterpreted", "license": "PolyForm-Noncommercial-1.0.0; see corpus/README.md for profile notices", "path": "native-uninterpreted.icd", "provenance": "authored synthetic; corpus/generate.py and tests/geometry_fixtures.py", "sha256": "2623d141699e0a846ac1d745b8eb4761421cd6bea4cef7ffb79545919e66f62a"}
+{"expected": {"byte_order": "little", "codes": [], "resources": 1, "status": {"brep": "complete", "extraction": "complete", "raw_geometry": "complete", "topology": "complete"}, "wire": {"counts": {"bodies": 1, "curves": 1, "edges": 1, "faces": 0, "points": 2, "vertices": 2}, "length": 5}}, "family": "synthetic-wire", "holdout": false, "id": "wire-little-raw", "license": "PolyForm-Noncommercial-1.0.0; see corpus/README.md for profile notices", "path": "wire-little-raw.icd", "provenance": "authored synthetic; corpus/generate.py and tests/geometry_fixtures.py", "sha256": "90049eb96aa3b89c55a9c912efdfcccf41dbf491ccf6f66af84e9acc5185404d"}
+{"expected": {"byte_order": "little", "codes": [], "resources": 1, "status": {"brep": "complete", "extraction": "complete", "raw_geometry": "complete", "topology": "complete"}, "wire": {"counts": {"bodies": 1, "curves": 1, "edges": 1, "faces": 0, "points": 2, "vertices": 2}, "length": 5}}, "family": "synthetic-wire", "holdout": false, "id": "wire-little-zlib", "license": "PolyForm-Noncommercial-1.0.0; see corpus/README.md for profile notices", "path": "wire-little-zlib.icd", "provenance": "authored synthetic; corpus/generate.py and tests/geometry_fixtures.py", "sha256": "a768f5d63db6bb91f3178c52304002b3dde9eaef7fdd0c0bd5c61160cd94d0ec"}
+{"expected": {"byte_order": "big", "codes": [], "resources": 1, "status": {"brep": "complete", "extraction": "complete", "raw_geometry": "complete", "topology": "complete"}, "wire": {"counts": {"bodies": 1, "curves": 1, "edges": 1, "faces": 0, "points": 2, "vertices": 2}, "length": 5}}, "family": "synthetic-wire", "holdout": false, "id": "wire-big-raw", "license": "PolyForm-Noncommercial-1.0.0; see corpus/README.md for profile notices", "path": "wire-big-raw.icd", "provenance": "authored synthetic; corpus/generate.py and tests/geometry_fixtures.py", "sha256": "222597e831d61fb1b57f78251155c9cda08419056e258333570f514b58327e33"}
+{"expected": {"byte_order": "big", "codes": [], "resources": 1, "status": {"brep": "complete", "extraction": "complete", "raw_geometry": "complete", "topology": "complete"}, "wire": {"counts": {"bodies": 1, "curves": 1, "edges": 1, "faces": 0, "points": 2, "vertices": 2}, "length": 5}}, "family": "synthetic-wire", "holdout": false, "id": "wire-big-zlib", "license": "PolyForm-Noncommercial-1.0.0; see corpus/README.md for profile notices", "path": "wire-big-zlib.icd", "provenance": "authored synthetic; corpus/generate.py and tests/geometry_fixtures.py", "sha256": "9e0aaf42f3d23941c1ecadb354ef026abc4bf9b40979b76a36f71ac996825d93"}
+{"expected": {"byte_order": "little", "codes": ["schema.missing_base_schema"], "resources": 1, "status": {"brep": "not_checked", "extraction": "complete", "raw_geometry": "unsupported", "topology": "not_checked"}}, "family": "synthetic-wire", "holdout": false, "id": "unknown-schema", "license": "PolyForm-Noncommercial-1.0.0; see corpus/README.md for profile notices", "path": "unknown-schema.icd", "provenance": "authored synthetic; corpus/generate.py and tests/geometry_fixtures.py", "sha256": "6e6eb075c99ac512366cb0f2dc049cbd5baf52acafd5916f11fbe349ef74793c"}
+{"expected": {"byte_order": "little", "codes": ["brep.invalid_reference"], "resources": 1, "status": {"brep": "invalid", "extraction": "complete", "raw_geometry": "complete", "topology": "not_checked"}}, "family": "synthetic-wire", "holdout": false, "id": "invalid-reference", "license": "PolyForm-Noncommercial-1.0.0; see corpus/README.md for profile notices", "path": "invalid-reference.icd", "provenance": "authored synthetic; corpus/generate.py and tests/geometry_fixtures.py", "sha256": "1f796bff73c5c3a536832edaca09718bd3ecedd5645535809806b4e7aaa03f02"}
+{"expected": {"byte_order": "little", "codes": ["compression.invalid"], "resources": 1, "status": {"brep": "not_checked", "extraction": "invalid", "raw_geometry": "not_checked", "topology": "not_checked"}}, "family": "synthetic-wire", "holdout": false, "id": "invalid-checksum", "license": "PolyForm-Noncommercial-1.0.0; see corpus/README.md for profile notices", "path": "invalid-checksum.icd", "provenance": "authored synthetic; corpus/generate.py and tests/geometry_fixtures.py", "sha256": "c4b6299ddd93d618fae769272df983e4f0a20b5d915c853792d7842e0720a0de"}

icadkit-0.3.8/crates/icad-core/src/container.rs

@@ -0,0 +1,311 @@
+//! Byte-exact model of the directory-indexed container.
+//!
+//! A [`Container`] keeps the MOD record, the DRW word at `+8`, the saved view
+//! names, every indexed record body and the trailing container verbatim. The
+//! framing that depends on them (directory offsets and lengths, `RES`/`V/W`
+//! length words, the MOD total-word field) is recomputed on serialization, so
+//! an unmodified document reproduces its input byte for byte exactly when its
+//! framing follows the observed rules. Nothing is searched for or repaired.
+
+use crate::{ByteOrder, Diagnostic, Document, ErrorKind, InspectError};
+
+/// Offset of the MOD word that counts the indexed records in 32-bit words.
+const TOTAL_WORDS_AT: usize = 236;
+
+/// One directory-indexed record without its opening frame and end tag.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ContainerRecord {
+    /// `RES`, `V/W` or `USR`.
+    pub tag: &'static str,
+    /// The record's own length word at `+4`. `RES` and `V/W` write their
+    /// physical size instead; `USR` writes this word back because old files
+    /// store a value that is not the physical size.
+    pub declared_words: u32,
+    /// Bytes from `+8` (the word shared by every record of one save) up to
+    /// the end tag, exclusive. The length is a multiple of four.
+    pub body: Vec<u8>,
+}
+
+impl ContainerRecord {
+    /// Physical size in 32-bit words, including the 12 framing bytes.
+    ///
+    /// # Errors
+    /// Returns `container.alignment` for a body that is not word aligned and
+    /// `container.size` for a record that does not fit a 32-bit word count.
+    pub fn words(&self) -> Result<u32, InspectError> {
+        if !self.body.len().is_multiple_of(4) {
+            return Err(InspectError::format(
+                ErrorKind::Invalid,
+                "container.alignment",
+                0,
+                format!(
+                    "{} body of {} bytes is not word aligned",
+                    self.tag,
+                    self.body.len()
+                ),
+            ));
+        }
+        u32::try_from(self.body.len() / 4 + 3).map_err(|_| {
+            InspectError::format(
+                ErrorKind::LimitExceeded,
+                "container.size",
+                0,
+                format!("{} record exceeds the 32-bit word count", self.tag),
+            )
+        })
+    }
+}
+
+/// The indexed container of one document; see the module documentation.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Container {
+    pub byte_order: ByteOrder,
+    /// The complete 256-byte MOD record. Bytes 236..240 are replaced by the
+    /// recomputed total on serialization; the other fields are copied.
+    pub mod_record: [u8; 256],
+    /// The DRW word at `+8`, retained verbatim.
+    pub drw_word: [u8; 4],
+    /// Eight-byte saved view names in directory order, retained verbatim.
+    pub view_names: Vec<[u8; 8]>,
+    /// `RES`, then one `V/W` per view name, then an optional `USR`.
+    pub records: Vec<ContainerRecord>,
+    /// Everything after the last indexed record, retained verbatim.
+    pub tail: Vec<u8>,
+    /// Where the source deviated from the recomputed framing.
+    pub diagnostics: Vec<Diagnostic>,
+}
+
+fn invalid(code: &'static str, message: impl Into<String>) -> InspectError {
+    InspectError::format(ErrorKind::Invalid, code, 0, message)
+}
+
+impl Container {
+    /// Check the record order, the view-name count and the record sizes.
+    fn validate(&self) -> Result<(), InspectError> {
+        let mut views = 0;
+        for (index, record) in self.records.iter().enumerate() {
+            let expected_tag = match (index, record.tag) {
+                (0, _) => "RES",
+                (_, "USR") if index + 1 == self.records.len() => "USR",
+                _ => "V/W",
+            };
+            if record.tag != expected_tag {
+                return Err(invalid(
+                    "container.record_order",
+                    format!("record {index} is {}, expected {expected_tag}", record.tag),
+                ));
+            }
+            if record.tag == "V/W" {
+                views += 1;
+            }
+            record.words()?;
+        }
+        if self.records.first().map(|r| r.tag) != Some("RES") {
+            return Err(invalid(
+                "container.record_order",
+                "the first record must be RES",
+            ));
+        }
+        if views != self.view_names.len() {
+            return Err(invalid(
+                "container.view_names",
+                format!(
+                    "{views} V/W records but {} view names",
+                    self.view_names.len()
+                ),
+            ));
+        }
+        Ok(())
+    }
+
+    /// Byte length of the DRW record for the current number of views.
+    fn drw_bytes(&self) -> usize {
+        32 + 16 * self.view_names.len()
+    }
+
+    /// The MOD total: DRW plus every indexed record, in 32-bit words.
+    ///
+    /// # Errors
+    /// Returns the validation errors of [`Container::to_bytes`].
+    pub fn total_words(&self) -> Result<u32, InspectError> {
+        self.validate()?;
+        let mut total = u32::try_from(self.drw_bytes() / 4)
+            .map_err(|_| invalid("container.size", "too many views"))?;
+        for record in &self.records {
+            total = total
+                .checked_add(record.words()?)
+                .ok_or_else(|| invalid("container.size", "indexed records exceed 2^32 words"))?;
+        }
+        Ok(total)
+    }
+
+    /// Serialize with recomputed framing; see the module documentation.
+    ///
+    /// # Errors
+    /// Returns `container.record_order` for records out of order,
+    /// `container.view_names` when the view names do not match the `V/W`
+    /// records, `container.alignment` for an unaligned body and
+    /// `container.size` when a count does not fit its field.
+    pub fn to_bytes(&self) -> Result<Vec<u8>, InspectError> {
+        let total = self.total_words()?;
+        let order = self.byte_order;
+        let entries = self.view_names.len() + 2;
+        let mut out = Vec::with_capacity(256 + total as usize * 4 + self.tail.len());
+        let mut mod_record = self.mod_record;
+        mod_record[TOTAL_WORDS_AT..TOTAL_WORDS_AT + 4].copy_from_slice(&order.bytes(total));
+        out.extend_from_slice(&mod_record);
+        out.extend_from_slice(b"DRW0");
+        let drw_words = u32::try_from(self.drw_bytes() / 4)
+            .map_err(|_| invalid("container.size", "too many views"))?;
+        out.extend_from_slice(&order.bytes(drw_words));
+        out.extend_from_slice(&self.drw_word);
+        let mut starts = Vec::with_capacity(entries);
+        let mut lengths = Vec::with_capacity(entries);
+        let mut cursor = u32::try_from(256 + self.drw_bytes())
+            .map_err(|_| invalid("container.size", "too many views"))?;
+        for record in &self.records {
+            let words = record.words()?;
+            // Directory starts are byte offsets; lengths are 32-bit words.
+            starts.push(cursor);
+            lengths.push(words);
+            cursor = words
+                .checked_mul(4)
+                .and_then(|bytes| cursor.checked_add(bytes))
+                .ok_or_else(|| invalid("container.size", "indexed records exceed 4 GiB"))?;
+        }
+        // A missing USR is a zero entry; the directory still reserves it.
+        starts.resize(entries, 0);
+        lengths.resize(entries, 0);
+        for value in starts.iter().chain(&lengths) {
+            out.extend_from_slice(&order.bytes(*value));
+        }
+        for name in &self.view_names {
+            out.extend_from_slice(name);
+        }
+        out.extend_from_slice(b"DRW1");
+        for record in &self.records {
+            out.extend_from_slice(record.tag.as_bytes());
+            out.push(b'0');
+            let length = if record.tag == "USR" {
+                record.declared_words
+            } else {
+                record.words()?
+            };
+            out.extend_from_slice(&order.bytes(length));
+            out.extend_from_slice(&record.body);
+            out.extend_from_slice(record.tag.as_bytes());
+            out.push(b'1');
+        }
+        out.extend_from_slice(&self.tail);
+        Ok(out)
+    }
+}
+
+impl Document {
+    /// Model the indexed container for byte-exact serialization.
+    ///
+    /// The directory, record ranges and tags were validated when the
+    /// document was indexed. A stored MOD total that differs from the
+    /// recomputed one is reported as `container.total_words` and is not
+    /// copied; the recomputed value is written instead.
+    ///
+    /// # Errors
+    /// Returns `container.range` when an indexed range does not lie inside
+    /// the input and `container.view_names` when the directory's view names
+    /// do not match its `V/W` records.
+    pub fn container(&self) -> Result<Container, InspectError> {
+        let data = self.all_bytes();
+        let order = self.inspection().header.byte_order;
+        let slice = |start: usize, end: usize| {
+            data.get(start..end).ok_or_else(|| {
+                InspectError::format(
+                    ErrorKind::Invalid,
+                    "container.range",
+                    start as u64,
+                    format!("indexed range [{start}, {end}) exceeds the input"),
+                )
+            })
+        };
+        let indexed = self.records();
+        let drw = indexed
+            .get(1)
+            .filter(|record| record.tag == "DRW")
+            .ok_or_else(|| invalid("container.range", "the DRW record is not indexed"))?;
+        let drw_len = (drw.byte_range.end - drw.byte_range.start) as usize;
+        let views = drw_len.saturating_sub(32) / 16;
+        let names_at = 268 + 8 * (views + 2);
+        let mut view_names = Vec::with_capacity(views);
+        for index in 0..views {
+            let mut name = [0; 8];
+            name.copy_from_slice(slice(names_at + 8 * index, names_at + 8 * index + 8)?);
+            view_names.push(name);
+        }
+        let mut records = Vec::with_capacity(indexed.len().saturating_sub(2));
+        let mut last_end = drw.byte_range.end as usize;
+        for record in indexed.iter().skip(2) {
+            let start = record.byte_range.start as usize;
+            let end = record.byte_range.end as usize;
+            let length = slice(start + 4, start + 8)?;
+            records.push(ContainerRecord {
+                tag: record.tag,
+                declared_words: order.u32([length[0], length[1], length[2], length[3]]),
+                body: slice(start + 8, end - 4)?.to_vec(),
+            });
+            last_end = end;
+        }
+        let mut drw_word = [0; 4];
+        drw_word.copy_from_slice(slice(264, 268)?);
+        let mut container = Container::new(
+            order,
+            self.inspection().header.raw_mod,
+            drw_word,
+            view_names,
+            records,
+            slice(last_end, data.len())?.to_vec(),
+        )?;
+        let stored = order.u32([
+            container.mod_record[TOTAL_WORDS_AT],
+            container.mod_record[TOTAL_WORDS_AT + 1],
+            container.mod_record[TOTAL_WORDS_AT + 2],
+            container.mod_record[TOTAL_WORDS_AT + 3],
+        ]);
+        let total = container.total_words()?;
+        if stored != total {
+            container.diagnostics.push(Diagnostic {
+                kind: ErrorKind::Unsupported,
+                code: "container.total_words",
+                byte_offset: TOTAL_WORDS_AT as u64,
+                message: format!("MOD stores {stored} words but the indexed records span {total}"),
+            });
+        }
+        Ok(container)
+    }
+}
+
+impl Container {
+    /// Assemble a container from its retained parts and validate the record
+    /// order, the view-name count and the record alignment.
+    ///
+    /// # Errors
+    /// Returns the validation errors of [`Container::to_bytes`].
+    pub fn new(
+        byte_order: ByteOrder,
+        mod_record: [u8; 256],
+        drw_word: [u8; 4],
+        view_names: Vec<[u8; 8]>,
+        records: Vec<ContainerRecord>,
+        tail: Vec<u8>,
+    ) -> Result<Self, InspectError> {
+        let container = Self {
+            byte_order,
+            mod_record,
+            drw_word,
+            view_names,
+            records,
+            tail,
+            diagnostics: Vec::new(),
+        };
+        container.validate()?;
+        Ok(container)
+    }
+}

{icadkit-0.3.7 → icadkit-0.3.8}/crates/icad-core/src/lib.rs

@@ -1,6 +1,7 @@
 //! Bounded iCAD SX framing, structural resource indexing and lazy extraction.
 
 mod compression;
+mod container;
 mod document;
 mod error;
 mod header;
@@ -16,6 +17,7 @@ mod schema;
 mod trailer;
 mod views;
 
+pub use container::{Container, ContainerRecord};
 pub use document::Document;
 pub use error::{Diagnostic, ErrorKind, InspectError};
 pub use header::{
@@ -28,8 +30,8 @@ pub use parasolid::{
     GeometryDiagnostic, GeometryError, GeometryResult, GeometryStatus, SchemaSelection,
 };
 pub use parts::{
-    PartAttributeRecord, PartIndex, PartLimits, PartOpaqueRange, PartProfileInfo, PartRecord,
-    PartViewRecord,
+    PartAttributeRecord, PartIndex, PartLimits, PartMaterialRecord, PartOpaqueRange,
+    PartProfileInfo, PartRecord, PartViewRecord,
 };
 pub use provenance::{Extraction, SourceRef};
 pub use reader::ByteOrder;

{icadkit-0.3.7 → icadkit-0.3.8}/crates/icad-core/src/parts.rs

@@ -40,12 +40,26 @@ pub struct PartRecord {
     pub extra_fields: Vec<PartTextRecord>,
     pub opaque_attributes: Vec<PartAttributeRecord>,
     pub entities: Vec<crate::NativeEntityRecord>,
+    /// Materials of the metadata blocks that follow this part record, one per
+    /// saved body; see [`PartMaterialRecord`].
+    pub materials: Vec<PartMaterialRecord>,
     pub parent_source_id: u32,
     pub first_child_source_id: u32,
     pub previous_source_id: u32,
     pub next_source_id: u32,
 }
 
+/// A saved material subrecord (tag `0x7a`, 216 bytes) of the metadata block
+/// that follows its owner's part record: CP932 name, material identifier
+/// and specific gravity. Text is retained undecoded.
+#[derive(Debug, Clone)]
+pub struct PartMaterialRecord {
+    pub byte_range: ByteRange,
+    pub raw_name: Vec<u8>,
+    pub raw_material_id: Vec<u8>,
+    pub specific_gravity: f64,
+}
+
 #[derive(Debug, Clone)]
 pub struct PartTextRecord {
     pub byte_range: ByteRange,
@@ -105,6 +119,38 @@ fn word(bytes: &[u8], at: usize) -> u32 {
     u32::from_le_bytes([bytes[at], bytes[at + 1], bytes[at + 2], bytes[at + 3]])
 }
 
+/// Collect the material subrecords of one qualified metadata block. The
+/// block's framing was validated by `metadata_layout`; every subrecord with
+/// tag `0x7a` and the observed 216-byte length is a material of the part
+/// whose record precedes the block. Other tags and lengths stay opaque.
+fn collect_materials(part: &mut PartRecord, block: &[u8], base: u64) {
+    let count = word(block, 8) as usize;
+    let mut at = 160;
+    for _ in 0..count {
+        if block.len() - at < 4 {
+            break;
+        }
+        let tag = word(block, at);
+        let length = (tag & 0x00ff_ffff) as usize;
+        if length < 4 || length > block.len() - at {
+            break;
+        }
+        if tag >> 24 == 0x7a && length == 216 {
+            let sub = &block[at..at + length];
+            part.materials.push(PartMaterialRecord {
+                byte_range: ByteRange {
+                    start: base + at as u64,
+                    end: base + (at + length) as u64,
+                },
+                raw_name: sub[16..96].to_vec(),
+                raw_material_id: sub[96..136].to_vec(),
+                specific_gravity: f64::from_le_bytes(std::array::from_fn(|i| sub[136 + i])),
+            });
+        }
+        at += length;
+    }
+}
+
 fn limit(at: u64, code: &'static str, message: &str) -> InspectError {
     InspectError::format(ErrorKind::LimitExceeded, code, at, message)
 }
@@ -722,6 +768,9 @@ impl Document {
                     }
                     entities += metadata_entities;
                     result.opaque(base + at as u64, base + next as u64, "entity_metadata");
+                    if let Some(part) = result.parts.last_mut() {
+                        collect_materials(part, &bytes[at..next], base + at as u64);
+                    }
                     at = next;
                     continue;
                 }
@@ -907,6 +956,7 @@ impl Document {
                         extra_fields: Vec::new(),
                         opaque_attributes: Vec::new(),
                         entities: Vec::new(),
+                        materials: Vec::new(),
                         parent_source_id: word(bytes, at + 260),
                         first_child_source_id: word(bytes, at + 264),
                         previous_source_id: word(bytes, at + 268),
@@ -1230,6 +1280,7 @@ impl Document {
                         extra_fields: Vec::new(),
                         opaque_attributes: Vec::new(),
                         entities: Vec::new(),
+                        materials: Vec::new(),
                         parent_source_id: u(260),
                         first_child_source_id: u(264),
                         previous_source_id: u(268),

{icadkit-0.3.7 → icadkit-0.3.8}/crates/icad-core/src/reader.rs

@@ -23,6 +23,13 @@ impl ByteOrder {
         }
     }
 
+    pub(crate) fn bytes(self, value: u32) -> [u8; 4] {
+        match self {
+            Self::Little => value.to_le_bytes(),
+            Self::Big => value.to_be_bytes(),
+        }
+    }
+
     pub(crate) fn u16(self, bytes: [u8; 2]) -> u16 {
         match self {
             Self::Little => u16::from_le_bytes(bytes),
@@ -30,6 +37,13 @@ impl ByteOrder {
         }
     }
 
+    pub(crate) fn f32(self, bytes: [u8; 4]) -> f32 {
+        match self {
+            Self::Little => f32::from_le_bytes(bytes),
+            Self::Big => f32::from_be_bytes(bytes),
+        }
+    }
+
     pub(crate) fn f64(self, bytes: [u8; 8]) -> f64 {
         match self {
             Self::Little => f64::from_le_bytes(bytes),