ducpy 3.1.0__tar.gz → 3.1.1__tar.gz

{ducpy-3.1.0 → ducpy-3.1.1}/Cargo.lock

@@ -411,7 +411,7 @@ dependencies = [
 
 [[package]]
 name = "ducpy-native"
-version = "3.1.0"
+version = "3.1.1"
 dependencies = [
  "duc",
  "pyo3",
@@ -713,10 +713,11 @@ checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
 
 [[package]]
 name = "hipdf"
-version = "1.3.5"
+version = "1.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3b986659f7ff291144addff668450799e4c2cd69686601cd48dfe23d7afc316"
+checksum = "2dfe672796312ef1e60b2866d6dac03b67c32dc7276a71c6d34b573dd00502f1"
 dependencies = [
+ "image",
  "jpeg-decoder",
  "lopdf",
  "miniz_oxide",
@@ -764,6 +765,7 @@ dependencies = [
  "byteorder-lite",
  "color_quant",
  "gif",
+ "image-webp",
  "moxcms",
  "num-traits",
  "png 0.18.0",
@@ -2477,18 +2479,18 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.41"
+version = "0.8.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96e13bc581734df6250836c59a5f44f3c57db9f9acb9dc8e3eaabdaf6170254d"
+checksum = "f2578b716f8a7a858b7f02d5bd870c14bf4ddbbcf3a4c05414ba6503640505e3"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.41"
+version = "0.8.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3545ea9e86d12ab9bba9fcd99b54c1556fd3199007def5a03c375623d05fac1c"
+checksum = "7e6cc098ea4d3bd6246687de65af3f920c430e236bee1e3bf2e441463f08a02f"
 dependencies = [
  "proc-macro2",
  "quote",

{ducpy-3.1.0 → ducpy-3.1.1}/Cargo.toml

@@ -2,7 +2,6 @@
 resolver = "2"
 members = ["packages/ducrs", "packages/ducpy/crate"]
 
-
 [profile.release]
 lto = true
 opt-level = "s"

{ducpy-3.1.0 → ducpy-3.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ducpy
-Version: 3.1.0
+Version: 3.1.1
 Classifier: License :: OSI Approved :: MIT License
 Requires-Dist: nanoid>=2.0.0
 License-File: LICENSE

{ducpy-3.1.0 → ducpy-3.1.1}/packages/ducpy/crate/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ducpy-native"
-version = "3.1.0"
+version = "3.1.1"
 edition = "2021"
 description = "Python native extension for the duc file format (used by ducpy)"
 publish = false

ducpy-3.1.1/packages/ducrs/src/lib.rs

@@ -0,0 +1,297 @@
+#[allow(unused_imports)]
+#[allow(non_camel_case_types)]
+#[allow(non_snake_case)]
+#[allow(non_upper_case_globals)]
+pub mod parse;
+pub mod serde_utils;
+pub mod serialize;
+pub mod types;
+
+// SQLite storage layer and high-level document API
+pub mod db;
+pub mod api;
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashSet;
+    use std::fs;
+    use std::path::{Path, PathBuf};
+
+    use crate::parse;
+    use crate::serialize;
+    use crate::types::*;
+
+    fn assets_dir() -> PathBuf {
+        Path::new(env!("CARGO_MANIFEST_DIR")).join("../../assets/testing/duc-files")
+    }
+
+    fn all_duc_files() -> Vec<PathBuf> {
+        let dir = assets_dir();
+        assert!(dir.exists(), "assets dir missing: {}", dir.display());
+        let mut files: Vec<PathBuf> = fs::read_dir(&dir)
+            .expect("read assets dir")
+            .filter_map(|e| e.ok())
+            .map(|e| e.path())
+            .filter(|p| p.extension().is_some_and(|ext| ext == "duc"))
+            .collect();
+        files.sort();
+        assert!(!files.is_empty(), "no .duc files in {}", dir.display());
+        files
+    }
+
+    fn load(path: &Path) -> Vec<u8> {
+        fs::read(path).unwrap_or_else(|e| panic!("read {}: {e}", path.display()))
+    }
+
+    // ── Parse every asset ────────────────────────────────────────────────────
+
+    #[test]
+    fn parse_all_assets() {
+        for path in all_duc_files() {
+            let buf = load(&path);
+            let state = parse::parse(&buf)
+                .unwrap_or_else(|e| panic!("parse {} failed: {e}", path.display()));
+
+            assert!(!state.version.is_empty(), "{}: version must not be empty", path.display());
+            assert!(!state.source.is_empty(), "{}: source must not be empty", path.display());
+            assert!(!state.elements.is_empty() || !state.layers.is_empty(),
+                "{}: must have elements or layers", path.display());
+        }
+    }
+
+    // ── Round-trip: parse → serialize → re-parse preserves data ──────────────
+
+    #[test]
+    fn roundtrip_all_assets() {
+        for path in all_duc_files() {
+            let original = load(&path);
+            let parsed = parse::parse(&original)
+                .unwrap_or_else(|e| panic!("parse {} failed: {e}", path.display()));
+
+            let serialized = serialize::serialize(&parsed)
+                .unwrap_or_else(|e| panic!("serialize {} failed: {e}", path.display()));
+            assert!(!serialized.is_empty(), "{}: serialized must not be empty", path.display());
+
+            let reparsed = parse::parse(&serialized)
+                .unwrap_or_else(|e| panic!("re-parse {} failed: {e}", path.display()));
+
+            assert_eq!(
+                parsed.elements.len(), reparsed.elements.len(),
+                "{}: element count mismatch", path.display()
+            );
+            assert_eq!(
+                parsed.layers.len(), reparsed.layers.len(),
+                "{}: layer count mismatch", path.display()
+            );
+            assert_eq!(
+                parsed.blocks.len(), reparsed.blocks.len(),
+                "{}: block count mismatch", path.display()
+            );
+            assert_eq!(
+                parsed.block_instances.len(), reparsed.block_instances.len(),
+                "{}: block instance count mismatch", path.display()
+            );
+            assert_eq!(
+                parsed.groups.len(), reparsed.groups.len(),
+                "{}: group count mismatch", path.display()
+            );
+            assert_eq!(
+                parsed.regions.len(), reparsed.regions.len(),
+                "{}: region count mismatch", path.display()
+            );
+        }
+    }
+
+    // ── Lazy parse skips external files ──────────────────────────────────────
+
+    #[test]
+    fn lazy_parse_skips_external_files() {
+        for path in all_duc_files() {
+            let buf = load(&path);
+            let full = parse::parse(&buf)
+                .unwrap_or_else(|e| panic!("parse {} failed: {e}", path.display()));
+            let lazy = parse::parse_lazy(&buf)
+                .unwrap_or_else(|e| panic!("parse_lazy {} failed: {e}", path.display()));
+
+            assert!(lazy.external_files.is_none(), "{}: lazy parse must omit external_files", path.display());
+            assert_eq!(full.elements.len(), lazy.elements.len(), "{}: element count diverged", path.display());
+            assert_eq!(full.layers.len(), lazy.layers.len(), "{}: layer count diverged", path.display());
+        }
+    }
+
+    // ── Element IDs are unique within each file ──────────────────────────────
+
+    #[test]
+    fn element_ids_unique() {
+        for path in all_duc_files() {
+            let buf = load(&path);
+            let state = parse::parse(&buf)
+                .unwrap_or_else(|e| panic!("parse {} failed: {e}", path.display()));
+
+            let mut seen = HashSet::new();
+            for wrapper in &state.elements {
+                let id = element_id(&wrapper.element);
+                assert!(seen.insert(id.clone()), "{}: duplicate element id '{id}'", path.display());
+            }
+        }
+    }
+
+    // ── Every element references a valid layer ───────────────────────────────
+
+    #[test]
+    fn element_layer_refs_valid() {
+        for path in all_duc_files() {
+            let buf = load(&path);
+            let state = parse::parse(&buf)
+                .unwrap_or_else(|e| panic!("parse {} failed: {e}", path.display()));
+
+            let layer_ids: HashSet<String> = state.layers.iter().map(|l| l.id.clone()).collect();
+
+            for wrapper in &state.elements {
+                let base = element_base(&wrapper.element);
+                if let Some(ref lid) = base.layer_id {
+                    assert!(
+                        layer_ids.contains(lid),
+                        "{}: element '{}' references non-existent layer '{lid}'",
+                        path.display(), base.id
+                    );
+                }
+            }
+        }
+    }
+
+    // ── Block instances reference valid blocks ───────────────────────────────
+
+    #[test]
+    fn block_instance_refs_valid() {
+        for path in all_duc_files() {
+            let buf = load(&path);
+            let state = parse::parse(&buf)
+                .unwrap_or_else(|e| panic!("parse {} failed: {e}", path.display()));
+
+            let block_ids: HashSet<String> = state.blocks.iter().map(|b| b.id.clone()).collect();
+
+            for inst in &state.block_instances {
+                assert!(
+                    block_ids.contains(&inst.block_id),
+                    "{}: block instance '{}' references non-existent block '{}'",
+                    path.display(), inst.id, inst.block_id
+                );
+            }
+        }
+    }
+
+    // ── External files: list ↔ get round-trip ────────────────────────────────
+
+    #[test]
+    fn external_files_list_get_consistent() {
+        for path in all_duc_files() {
+            let buf = load(&path);
+            let listing = parse::list_external_files(&buf)
+                .unwrap_or_else(|e| panic!("list_external_files {} failed: {e}", path.display()));
+
+            for meta in &listing {
+                let file = parse::get_external_file(&buf, &meta.id)
+                    .unwrap_or_else(|e| panic!("get_external_file {} id={} failed: {e}", path.display(), meta.id));
+                assert!(file.is_some(), "{}: listed file '{}' not found via get", path.display(), meta.id);
+                let file = file.unwrap();
+                assert_eq!(file.id, meta.id);
+                assert!(!file.revisions.is_empty(), "{}: file '{}' has no revisions", path.display(), meta.id);
+            }
+        }
+    }
+
+    // ── DB layer: open in-memory, schema bootstraps correctly ────────────────
+
+    #[test]
+    fn db_open_memory_and_schema() {
+        use crate::api::DucDocument;
+
+        let doc = DucDocument::open_memory().expect("open_memory");
+        let version = doc.schema_version().expect("schema_version");
+        assert!(version > 0, "schema version must be positive, got {version}");
+    }
+
+    // ── Compression: serialized output is smaller than raw SQLite ────────────
+
+    #[test]
+    fn serialized_is_compressed() {
+        for path in all_duc_files() {
+            let buf = load(&path);
+            assert!(!parse::is_sqlite_header(&buf), "{}: assets should be compressed, not raw SQLite", path.display());
+
+            let raw = parse::decompress_duc_bytes(&buf)
+                .unwrap_or_else(|e| panic!("decompress {} failed: {e}", path.display()));
+
+            let state = parse::parse(&buf)
+                .unwrap_or_else(|e| panic!("parse {} failed: {e}", path.display()));
+            let recompressed = serialize::serialize(&state)
+                .unwrap_or_else(|e| panic!("serialize {} failed: {e}", path.display()));
+
+            assert!(
+                recompressed.len() < raw.len(),
+                "{}: compressed ({} B) should be smaller than raw SQLite ({} B)",
+                path.display(), recompressed.len(), raw.len()
+            );
+        }
+    }
+
+    // ── Global state invariants ──────────────────────────────────────────────
+
+    #[test]
+    fn global_state_valid() {
+        for path in all_duc_files() {
+            let buf = load(&path);
+            let state = parse::parse(&buf)
+                .unwrap_or_else(|e| panic!("parse {} failed: {e}", path.display()));
+
+            if let Some(ref gs) = state.duc_global_state {
+                assert!(!gs.view_background_color.is_empty(), "{}: background color must not be empty", path.display());
+                assert!(!gs.main_scope.is_empty(), "{}: main_scope must not be empty", path.display());
+            }
+        }
+    }
+
+    // ── Error handling: garbage input produces a clear error ──────────────────
+
+    #[test]
+    fn parse_rejects_garbage() {
+        let cases: &[(&str, &[u8])] = &[
+            ("empty", &[]),
+            ("random", &[0xFF; 64]),
+            ("text", b"Not a DUC file"),
+        ];
+        for (label, data) in cases {
+            assert!(
+                parse::parse(data).is_err(),
+                "parse should reject {label} input"
+            );
+        }
+    }
+
+    // ── Helpers ──────────────────────────────────────────────────────────────
+
+    fn element_id(el: &DucElementEnum) -> String {
+        element_base(el).id.clone()
+    }
+
+    fn element_base(el: &DucElementEnum) -> &DucElementBase {
+        match el {
+            DucElementEnum::DucRectangleElement(e) => &e.base,
+            DucElementEnum::DucPolygonElement(e) => &e.base,
+            DucElementEnum::DucEllipseElement(e) => &e.base,
+            DucElementEnum::DucEmbeddableElement(e) => &e.base,
+            DucElementEnum::DucPdfElement(e) => &e.base,
+            DucElementEnum::DucTableElement(e) => &e.base,
+            DucElementEnum::DucImageElement(e) => &e.base,
+            DucElementEnum::DucTextElement(e) => &e.base,
+            DucElementEnum::DucLinearElement(e) => &e.linear_base.base,
+            DucElementEnum::DucArrowElement(e) => &e.linear_base.base,
+            DucElementEnum::DucFreeDrawElement(e) => &e.base,
+            DucElementEnum::DucFrameElement(e) => &e.stack_element_base.base,
+            DucElementEnum::DucPlotElement(e) => &e.stack_element_base.base,
+            DucElementEnum::DucDocElement(e) => &e.base,
+            DucElementEnum::DucModelElement(e) => &e.base,
+        }
+    }
+}

ducpy-3.1.1/packages/ducrs/src/serde_utils.rs

@@ -0,0 +1,90 @@
+use serde::Deserializer;
+
+/// Deserializes an `i32` field from any JSON number, truncating floats instead of erroring.
+/// Annotate struct fields with: `#[serde(deserialize_with = "crate::serde_utils::trunc_i32")]`
+pub fn trunc_i32<'de, D>(deserializer: D) -> Result<i32, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    struct Visitor;
+
+    impl<'de> serde::de::Visitor<'de> for Visitor {
+        type Value = i32;
+
+        fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+            f.write_str("integer or float representable as i32")
+        }
+
+        fn visit_i8<E: serde::de::Error>(self, v: i8) -> Result<i32, E> {
+            Ok(v as i32)
+        }
+        fn visit_i16<E: serde::de::Error>(self, v: i16) -> Result<i32, E> {
+            Ok(v as i32)
+        }
+        fn visit_i32<E: serde::de::Error>(self, v: i32) -> Result<i32, E> {
+            Ok(v)
+        }
+        fn visit_i64<E: serde::de::Error>(self, v: i64) -> Result<i32, E> {
+            i32::try_from(v).map_err(E::custom)
+        }
+        fn visit_u8<E: serde::de::Error>(self, v: u8) -> Result<i32, E> {
+            Ok(v as i32)
+        }
+        fn visit_u16<E: serde::de::Error>(self, v: u16) -> Result<i32, E> {
+            Ok(v as i32)
+        }
+        fn visit_u32<E: serde::de::Error>(self, v: u32) -> Result<i32, E> {
+            i32::try_from(v).map_err(E::custom)
+        }
+        fn visit_u64<E: serde::de::Error>(self, v: u64) -> Result<i32, E> {
+            i32::try_from(v).map_err(E::custom)
+        }
+        fn visit_f32<E: serde::de::Error>(self, v: f32) -> Result<i32, E> {
+            Ok(v.trunc() as i32)
+        }
+        fn visit_f64<E: serde::de::Error>(self, v: f64) -> Result<i32, E> {
+            Ok(v.trunc() as i32)
+        }
+    }
+
+    deserializer.deserialize_any(Visitor)
+}
+
+struct FlexI32Seed;
+
+impl<'de> serde::de::DeserializeSeed<'de> for FlexI32Seed {
+    type Value = i32;
+    fn deserialize<D: Deserializer<'de>>(self, deserializer: D) -> Result<i32, D::Error> {
+        trunc_i32(deserializer)
+    }
+}
+
+/// Deserializes a `Vec<i32>` from a JSON array of numbers, truncating any floats.
+/// Annotate struct fields with: `#[serde(deserialize_with = "crate::serde_utils::trunc_vec_i32")]`
+pub fn trunc_vec_i32<'de, D>(deserializer: D) -> Result<Vec<i32>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    struct SeqVisitor;
+
+    impl<'de> serde::de::Visitor<'de> for SeqVisitor {
+        type Value = Vec<i32>;
+
+        fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+            f.write_str("a sequence of integers or floats representable as i32")
+        }
+
+        fn visit_seq<A>(self, mut seq: A) -> Result<Vec<i32>, A::Error>
+        where
+            A: serde::de::SeqAccess<'de>,
+        {
+            let mut v = Vec::with_capacity(seq.size_hint().unwrap_or(0));
+            while let Some(n) = seq.next_element_seed(FlexI32Seed)? {
+                v.push(n);
+            }
+            Ok(v)
+        }
+    }
+
+    deserializer.deserialize_seq(SeqVisitor)
+}

{ducpy-3.1.0 → ducpy-3.1.1}/packages/ducrs/src/types.rs

@@ -349,6 +349,7 @@ pub struct Viewer3DMaterial {
 #[serde(rename_all = "camelCase")]
 pub struct Viewer3DZebra {
     pub active: bool,
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub stripe_count: i32,
     pub stripe_direction: f64,
     /** Available: "blackwhite" | "colorful" | "grayscale" */
@@ -593,17 +594,20 @@ pub struct DucElementBase {
      * Random integer used to seed shape generation.
      * Doesn't differ across renders.
      */
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub seed: i32,
     /**
      * Integer that is sequentially incremented on each change. Used to reconcile
      * elements during collaboration or when saving to server.
      */
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub version: i32,
     /**
      * Random integer that is regenerated on each change.
      * Used for deterministic reconciliation of updates during collaboration,
      * in case the versions (see above) are identical.
      */
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub version_nonce: i32,
     /** Epoch timestamp (ms) of last element update */
     pub updated: i64,
@@ -673,6 +677,7 @@ pub struct DucHead {
 #[serde(rename_all = "camelCase")]
 pub struct PointBindingPoint {
     /** The index of the target point within the element. */
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub index: i32,
     /**
      * The offset from the point. Ranges from -1 to 1: 0 corresponds to the actual point.
@@ -709,6 +714,7 @@ pub struct DucPointBinding {
 #[serde(rename_all = "camelCase")]
 pub struct DucLineReference {
     /** Index of the point in the points array */
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub index: i32,
     /** Bezier handle of the point on the line segment */
     pub handle: Option<GeometricPoint>,
@@ -724,6 +730,7 @@ pub struct DucLine {
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct DucPath {
+    #[serde(deserialize_with = "crate::serde_utils::trunc_vec_i32")]
     pub line_indices: Vec<i32>,
     /** Override the background and stroke from the base if different than null */
     pub background: Option<ElementBackground>,
@@ -990,6 +997,7 @@ pub struct DucPolygonElement {
     #[serde(flatten)]
     pub base: DucElementBase,
     /** Number of sides of the polygon */
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub sides: i32,
 }
 
@@ -1015,6 +1023,7 @@ pub struct DucEmbeddableElement {
 #[serde(rename_all = "camelCase")]
 pub struct DocumentGridConfig {
     /** 1 = single, 2 = two-up, n = grid */
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub columns: i32,
     /** Horizontal spacing (px) */
     pub gap_x: f64,
@@ -1201,7 +1210,9 @@ pub struct DucModelElement {
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct DucBlockDuplicationArray {
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub rows: i32,
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub cols: i32,
     pub row_spacing: f64,
     pub col_spacing: f64,
@@ -1211,6 +1222,7 @@ pub struct DucBlockDuplicationArray {
 #[serde(rename_all = "camelCase")]
 pub struct DucBlockMetadata {
     pub source: Option<String>,
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub usage_count: i32,
     /** Epoch timestamp (ms) of block creation */
     pub created_at: i64,
@@ -1237,6 +1249,7 @@ pub struct DucBlock {
     pub id: String,
     pub label: String,
     pub description: Option<String>,
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub version: i32,
     pub metadata: Option<DucBlockMetadata>,
     #[serde(with = "serde_bytes", default, skip_serializing_if = "Option::is_none")]
@@ -1250,6 +1263,7 @@ pub struct DucBlockInstance {
     /** The reference to the DucBlock definition this instance is based on */
     pub block_id: String,
     /** The version that should match the block_id's version, incremented on each change */
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub version: i32,
     pub element_overrides: Option<Vec<StringValueEntry>>,
     pub duplication_array: Option<DucBlockDuplicationArray>,
@@ -1353,6 +1367,7 @@ pub struct DucLocalState {
      * The user needs to manually update the graph for new versions to be saved in version control.
      */
     pub manual_save_mode: bool,
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub decimal_places: i32,
 }
 
@@ -1393,6 +1408,7 @@ pub struct Checkpoint {
     #[serde(flatten)]
     pub base: VersionBase,
     pub version_number: i64,
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub schema_version: i32,
     pub is_schema_boundary: bool,
     #[serde(with = "serde_bytes")]
@@ -1406,6 +1422,7 @@ pub struct Delta {
     #[serde(flatten)]
     pub base: VersionBase,
     pub version_number: i64,
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub schema_version: i32,
     pub base_checkpoint_id: String,
     /** Compressed binary data for the delta (zlib). When present, patch_string is ignored. */
@@ -1417,7 +1434,9 @@ pub struct Delta {
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct SchemaMigration {
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub from_schema_version: i32,
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub to_schema_version: i32,
     pub migration_name: String,
     pub migration_checksum: Option<String>,
@@ -1429,6 +1448,7 @@ pub struct SchemaMigration {
 #[serde(rename_all = "camelCase")]
 pub struct VersionChain {
     pub id: String,
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub schema_version: i32,
     pub start_version: i64,
     pub end_version: Option<i64>,
@@ -1440,7 +1460,9 @@ pub struct VersionChain {
 #[serde(rename_all = "camelCase")]
 pub struct VersionGraphMetadata {
     pub current_version: i64,
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub current_schema_version: i32,
+    #[serde(deserialize_with = "crate::serde_utils::trunc_i32")]
     pub chain_count: i32,
     pub last_pruned: i64,
     pub total_size: i64,

ducpy-3.1.0/packages/ducrs/src/lib.rs

@@ -1,94 +0,0 @@
-#[allow(unused_imports)]
-#[allow(non_camel_case_types)]
-#[allow(non_snake_case)]
-#[allow(non_upper_case_globals)]
-pub mod parse;
-pub mod serialize;
-pub mod types;
-
-// SQLite storage layer and high-level document API
-pub mod db;
-pub mod api;
-
-#[cfg(test)]
-mod tests {
-    use std::fs;
-    use std::path::Path;
-
-    // Initialize logging for tests
-    fn init_logging() {
-        let _ = env_logger::builder()
-            .filter_level(log::LevelFilter::Info)
-            .is_test(true)
-            .try_init();
-    }
-
-    #[test]
-    fn test_parse_with_logging() {
-        init_logging();
-
-        // Try to load a test DUC file from assets folder
-        let test_file_path = Path::new("assets/testing/duc-files/plot_elements.duc");
-
-        if test_file_path.exists() {
-            match fs::read(test_file_path) {
-                Ok(data) => {
-                    println!("Loaded test file: {} bytes", data.len());
-
-                    // Call the parse function to trigger the logging
-                    match crate::parse::parse(&data) {
-                        Ok(parsed) => {
-                            println!("✅ Successfully parsed DUC file");
-                            println!("Layers count: {}", parsed.layers.len());
-                        }
-                        Err(e) => {
-                            println!("❌ Parse error: {}", e);
-                        }
-                    }
-                }
-                Err(e) => {
-                    println!("❌ Failed to read test file: {}", e);
-                }
-            }
-        } else {
-            println!("❌ Test file not found: {}", test_file_path.display());
-            // Create minimal test data to at least test the parsing pipeline
-            let minimal_data = vec![0u8; 100];
-            match crate::parse::parse(&minimal_data) {
-                Ok(_) => println!("✅ Minimal parse succeeded"),
-                Err(e) => println!("❌ Minimal parse failed: {}", e),
-            }
-        }
-    }
-
-    #[test]
-    fn test_serialize_roundtrip_compressed() {
-        init_logging();
-
-        let test_file_path = Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../../assets/testing/duc-files/universal.duc");
-        if !test_file_path.exists() {
-            println!("Skipped — test file not found: {}", test_file_path.display());
-            return;
-        }
-
-        let original = fs::read(test_file_path).expect("read test file");
-        let parsed = crate::parse::parse(&original).expect("parse original");
-
-        let compressed = crate::serialize::serialize(&parsed).expect("serialize");
-
-        assert!(!compressed.is_empty(), "serialized output must not be empty");
-        println!(
-            "original={} bytes, compressed={} bytes ({:.1}%)",
-            original.len(),
-            compressed.len(),
-            compressed.len() as f64 / original.len() as f64 * 100.0
-        );
-
-        let reparsed = crate::parse::parse(&compressed).expect("parse compressed");
-        assert_eq!(parsed.elements.len(), reparsed.elements.len());
-        assert_eq!(parsed.layers.len(), reparsed.layers.len());
-        assert_eq!(parsed.blocks.len(), reparsed.blocks.len());
-        println!("Round-trip OK — {} elements preserved", reparsed.elements.len());
-    }
-}