R2007+ DXF, code pages, header, every new model field, and uncad-export (0.3 port, 3/3)

.gitattributes

@@ -1,2 +1,5 @@
 * text=auto eol=lf
 *.sh text eol=lf
+# Hand-written DXF fixtures: keep their bytes (CRLF, and a code page
+# that is not UTF-8) exactly as the generator wrote them
+crates/uncad/tests/fixtures/*.dxf -text

Cargo.toml

@@ -1,10 +1,10 @@
 [workspace]
 resolver = "2"
-members = ["crates/libredwg-sys", "crates/uncad", "crates/uncad-cli"]
+members = ["crates/libredwg-sys", "crates/uncad", "crates/uncad-export", "crates/uncad-cli"]
 
 [workspace.package]
 edition = "2021"
-# Minimum supported Rust version, for all three crates. Measured, not guessed:
+# Minimum supported Rust version, for all four crates. Measured, not guessed:
 # 1.87 fails (`slice::as_chunks`, stable since 1.88, in crates/uncad) and 1.88
 # passes. CI's `msrv` job reads this value and checks the workspace with
 # exactly that toolchain -- raise the two together, never this line alone.

README.md

@@ -4,7 +4,9 @@
 [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](LICENSE)
 
 An open-source Rust library that parses CAD files (DWG/DXF) into a model and
-exports that model as JSON, SVG or PNG. Read-only: it does not write DWG or DXF,
+exports that model as JSON, SVG or PNG -- and, through the `uncad-export` crate,
+as a directory an LLM or VLM can read (overview and tile images, sheet images,
+and JSON records that point into them). Read-only: it does not write DWG or DXF,
 and does not convert between them.
 
 ## Quick start
@@ -19,12 +21,28 @@ cargo test --workspace
 let db = uncad::parse("drawing.dwg")?;   // same model for DWG and DXF (entities + tables)
 println!("{} entities", db.entities.len());
 
+// The header variables that give the numbers a meaning come beside the model:
+let (db, header) = uncad::parse_with_header("drawing.dxf")?;
+println!("units: {:?}", header.units());   // $INSUNITS; None when the file does not say
+
+// Bytes already in memory (from the network, an archive, ...):
+let bytes = std::fs::read("drawing.dwg")?;
+let db = uncad::parse_bytes(&bytes, uncad::Format::Dwg)?;
+
 let json = db.to_json(uncad::ToJsonOptions { pretty: true })?;   // the model, serialized as-is
 std::fs::write("drawing.json", json)?;
 
 // Rendering is the iron-render-cad crate's (uncad-cli uses it):
 let result = iron_render_cad::to_svg(&db, iron_render_cad::ToSvgOptions::default());
 std::fs::write("drawing.svg", result.svg)?;
+
+// The LLM/VLM package (the uncad-export crate; uncad-cli's `uncad export`):
+let report = uncad_export::export_file(
+    std::path::Path::new("drawing.dwg"),
+    std::path::Path::new("drawing.pkg"),
+    &uncad_export::ExportOptions::default(),
+)?;
+println!("{} files, {} sheets", report.files.len(), report.sheets.len());
 ```
 
 ## CLI
@@ -38,18 +56,27 @@ cargo run -p uncad-cli -- drawing.dwg -o drawing.png --scale 2   # rasterize at
 cargo run -p uncad-cli -- drawing.dwg -o drawing.svg --no-trim   # keep outlying coordinates
 cargo run -p uncad-cli -- drawing.dwg -o sheet.svg --space paper # sheet borders / title blocks
 cargo run -p uncad-cli -- drawing.dwg -o all.svg --space all     # every space in one document
+cargo run -p uncad-cli -- drawing.dwg -o all.svg --include-hidden # also what layers hide
+cargo run -p uncad-cli -- export drawing.dwg -o drawing.pkg       # the LLM/VLM package
+cargo run -p uncad-cli -- export drawing.dwg -o drawing.pkg --profile openai-patch --max-levels 2
+cargo run -p uncad-cli -- --version
 ```
 
+An option the CLI does not know is an error that names it, on both commands.
+`uncad export` writes `manifest.json` last; start reading a package there (its
+`README.txt` says the same in prose).
+
 ## Scope
 
 1. **DWG** — read through [LibreDWG](https://www.gnu.org/software/libredwg/)
    (GPLv3+), bound directly via Rust FFI (`bindgen`). All versions.
-2. **DXF** — read through the same LibreDWG engine, chosen by file extension.
-   **DXF saved as R2007 or later is refused** with `ParseError::UnsupportedDxfVersion`
-   rather than read incompletely — see `docs/CAVEATS.md`, "DXF reading". R2000/R2004
-   DXF and every DWG version are unaffected.
-   LibreDWG's own DXF importer is documented as working "for most objects", so
-   it is less complete than its DWG reading ([`docs/CAVEATS.md`](./docs/CAVEATS.md)).
+2. **DXF** — read through the same LibreDWG engine, chosen by file extension
+   (`parse`) or by the caller (`parse_bytes`). Every version, R2007 and later
+   included: such a file holds its strings in two widths in LibreDWG's memory,
+   and each is read in its own — see `docs/CAVEATS.md`, "DXF saved as R2007 or
+   later is read". LibreDWG's own DXF importer is documented as working "for most
+   objects", so it is less complete than its DWG reading, and slower than linear
+   in the entity count ([`docs/CAVEATS.md`](./docs/CAVEATS.md)).
 3. **Output** — the parsed model as JSON (`CadDatabase::to_json`, from
    `uncad-model`). SVG and PNG come from the
    [`iron-render-cad`](https://github.com/iyulab/iron-render-cad) crate (MIT), which
@@ -81,8 +108,11 @@ well as Windows.
 ## License
 
 **GPLv3-or-later**. LibreDWG (GPLv3+) is the only third-party component linked
-in, and its license carries over. Copyright and license details for third-party
-components are in [`docs/THIRD_PARTY_NOTICES.md`](./docs/THIRD_PARTY_NOTICES.md).
+in, and its license carries over. The vendored copy carries five local patches;
+`crates/libredwg-sys/NOTICE.md` is their modification notice, inside the crate
+so that it reaches the published tarball. Copyright and license details for
+third-party components are in
+[`docs/THIRD_PARTY_NOTICES.md`](./docs/THIRD_PARTY_NOTICES.md).
 
 ## Repository layout
 
@@ -91,12 +121,17 @@ lib/libredwg/            LibreDWG upstream, as a git submodule. Not used by the
                          it is the source vendor/ is regenerated from, and where the
                          real-file test fixtures (test/test-data/) come from
 crates/
-  libredwg-sys/          raw FFI (cc + bindgen). vendor/libredwg/ holds the unmodified
-                         subset of C sources actually compiled (for publishing to
-                         crates.io); shim/ holds the C accessors for opaque types, and
+  libredwg-sys/          raw FFI (cc + bindgen). vendor/libredwg/ holds the subset of C
+                         sources actually compiled (for publishing to crates.io), with
+                         five local patches marked "uncad local patch" and listed in
+                         NOTICE.md; shim/ holds the C accessors for opaque types, and
                          vendor-config/config.h stands in for autotools
-  uncad/                 the safe API: parse() -> uncad_model::CadDatabase
-  uncad-cli/             the CLI binary (uncad)
+  uncad/                 the safe API: parse() / parse_bytes() -> uncad_model::CadDatabase,
+                         and the drawing's Header beside it from parse_with_header()
+  uncad-export/          the LLM/VLM package: export_file() / export_package() write a
+                         directory of images and JSON records; bundles a Noto Sans KR
+                         subset (OFL-1.1) so Korean text renders anywhere
+  uncad-cli/             the CLI binary (uncad), including `uncad export`
 crates/*/tests/          integration tests against the public API. crates/*/examples/ are
                          manual-check tools, and #[cfg(test)] blocks inside src/*.rs are
                          unit tests -- docs/ARCHITECTURE.md's "Test layout" says which
@@ -115,3 +150,5 @@ Further reading:
   test layout, the FFI/bindgen boundary, thread safety, the entity model
 - [`docs/CAVEATS.md`](./docs/CAVEATS.md) — entity type coverage, known
   limitations and bugs, cross-platform notes
+- [`docs/VLM_EXPORT_DESIGN.md`](./docs/VLM_EXPORT_DESIGN.md) — the LLM/VLM
+  package `uncad export` writes: its files, coordinates, tiling and crop rules

crates/libredwg-sys/Cargo.toml

@@ -7,7 +7,7 @@ license.workspace = true
 repository.workspace = true
 homepage.workspace = true
 readme.workspace = true
-description = "Raw FFI bindings to the LibreDWG C sources (vendored, unmodified upstream), built natively via cc + bindgen (no Emscripten/WASM)."
+description = "Raw FFI bindings to the LibreDWG C sources (a vendored subset of upstream carrying five local patches, see NOTICE.md), built natively via cc + bindgen (no Emscripten/WASM)."
 keywords = ["dwg", "dxf", "ffi", "libredwg", "cad"]
 categories = ["external-ffi-bindings"]
 links = "libredwg"