cli: guarded obj export

Cargo.lock

@@ -26,5 +26,6 @@ name = "nanobrush-cli"
 version = "0.1.0"
 dependencies = [
  "mb3-dat",
+ "mb3-obj",
  "mb3-txt",
 ]

crates/nanobrush-cli/Cargo.toml

@@ -14,5 +14,7 @@ path = "src/main.rs"
 mb3-dat = { path = "../mb3-dat" }
 mb3-txt = { path = "../mb3-txt" }
 
+mb3-obj = { path = "../mb3-obj" }
+
 [lints]
 workspace = true

crates/nanobrush-cli/src/lib.rs

@@ -8,7 +8,7 @@ use std::io::{self, BufRead, BufReader, Write};
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicU64, Ordering};
 
-const HELP: &str = "nanobrush preflight INPUT --to txt|dat-201501280|dat-201512200 [LIMITS]\nnanobrush inspect INPUT [--from auto|txt|dat] [LIMITS]\nnanobrush validate INPUT [--from auto|txt|dat] [LIMITS]\nnanobrush convert INPUT OUTPUT --to txt|dat-201501280|dat-201512200 [--from auto|txt|dat] [--force] [LIMITS]\nLIMITS: --max-bytes N --max-items N --max-string-bytes N --max-owned-bytes N\nTXT option: --text-encoding utf8|latin1 (default utf8).\nUse -- before positional paths beginning with a dash. TXT input is UTF-8; output has a BOM.\nExit: 0 success/help, 1 invalid data or I/O failure, 2 usage error.\n";
+const HELP: &str = "nanobrush preflight INPUT --to txt|dat-201501280|dat-201512200|obj [LIMITS]\nnanobrush inspect INPUT [--from auto|txt|dat] [LIMITS]\nnanobrush validate INPUT [--from auto|txt|dat] [LIMITS]\nnanobrush convert INPUT OUTPUT --to txt|dat-201501280|dat-201512200|obj [--from auto|txt|dat] [--force] [LIMITS]\nLIMITS: --max-bytes N --max-items N --max-string-bytes N --max-owned-bytes N\nOBJ requires --allow-lossy when editable data is discarded.\nTXT option: --text-encoding utf8|latin1 (default utf8).\nUse -- before positional paths beginning with a dash. TXT input is UTF-8; output has a BOM.\nExit: 0 success/help, 1 invalid data or I/O failure, 2 usage error.\n";
 #[derive(Debug)]
 pub struct Error {
     pub usage: bool,
@@ -47,6 +47,7 @@ enum InputFormat {
 #[derive(Clone, Copy)]
 enum To {
     Txt,
+    Obj,
     Dat(Version),
 }
 struct Options {
@@ -55,6 +56,7 @@ struct Options {
     from: InputFormat,
     to: Option<To>,
     force: bool,
+    allow_lossy: bool,
     limits: Limits,
     encoding: mb3_txt::Encoding,
 }
@@ -81,6 +83,7 @@ fn parse(args: impl IntoIterator<Item = OsString>) -> Result<Option<Options>> {
         from: InputFormat::Auto,
         to: None,
         force: false,
+        allow_lossy: false,
         limits: Limits::default(),
         encoding: mb3_txt::Encoding::Utf8,
     };
@@ -99,6 +102,10 @@ fn parse(args: impl IntoIterator<Item = OsString>) -> Result<Option<Options>> {
             if !seen.insert(flag.to_owned()) {
                 return Err(usage(format!("duplicate option {flag}")));
             }
+            if flag == "--allow-lossy" {
+                options.allow_lossy = true;
+                continue;
+            }
             if flag == "--force" {
                 options.force = true;
                 continue;
@@ -140,6 +147,7 @@ fn parse(args: impl IntoIterator<Item = OsString>) -> Result<Option<Options>> {
                 "--to" => {
                     options.to = Some(match value {
                         "txt" => To::Txt,
+                        "obj" => To::Obj,
                         "dat-201501280" => To::Dat(Version::V201501280),
                         "dat-201512200" => To::Dat(Version::V201512200),
                         _ => {
@@ -179,6 +187,10 @@ fn parse(args: impl IntoIterator<Item = OsString>) -> Result<Option<Options>> {
             "inspect/validate require one INPUT and no --to/--force",
         ));
     }
+    if options.allow_lossy && (options.command != "convert" || !matches!(options.to, Some(To::Obj)))
+    {
+        return Err(usage("--allow-lossy requires convert --to obj"));
+    }
     Ok(Some(options))
 }
 struct Input {
@@ -318,6 +330,7 @@ pub fn run(args: impl IntoIterator<Item = OsString>, stdout: &mut dyn Write) ->
         "preflight" => {
             let target = match o.to.ok_or_else(|| usage("missing --to"))? {
                 To::Txt => preflight::Target::Txt,
+                To::Obj => preflight::Target::Obj,
                 To::Dat(v) => preflight::Target::Dat(v),
             };
             writeln!(
@@ -381,6 +394,16 @@ pub fn run(args: impl IntoIterator<Item = OsString>, stdout: &mut dyn Write) ->
         )?,
         _ => {
             let bytes = match o.to.ok_or_else(|| usage("missing --to"))? {
+                To::Obj => {
+                    let report = preflight::analyze(&input.world, preflight::Target::Obj);
+                    if report.blocked() || (!report.compatible() && !o.allow_lossy) {
+                        return Err(fail(format!(
+                            "OBJ export requires compatible computed geometry and --allow-lossy: {}",
+                            report.json()
+                        )));
+                    }
+                    mb3_obj::encode(&input.world, &o.limits).map_err(|e| fail(e.to_string()))?
+                }
                 To::Txt => {
                     mb3_txt::encode(&input.world, &o.limits).map_err(|e| fail(e.to_string()))?
                 }

crates/nanobrush-cli/src/preflight.rs

@@ -4,12 +4,14 @@ use std::collections::HashSet;
 #[derive(Clone, Copy, Debug)]
 pub enum Target {
     Txt,
+    Obj,
     Dat(Version),
 }
 impl Target {
     pub fn name(self) -> &'static str {
         match self {
             Self::Txt => "txt",
+            Self::Obj => "obj",
             Self::Dat(Version::V201501280) => "dat-201501280",
             Self::Dat(Version::V201512200) => "dat-201512200",
         }
@@ -19,6 +21,7 @@ impl Target {
 pub struct Issue {
     pub code: &'static str,
     pub count: usize,
+    pub lossy: bool,
 }
 #[derive(Clone, Debug)]
 pub struct Report {
@@ -26,6 +29,9 @@ pub struct Report {
     pub issues: Vec<Issue>,
 }
 impl Report {
+    pub fn blocked(&self) -> bool {
+        self.issues.iter().any(|i| !i.lossy)
+    }
     pub fn compatible(&self) -> bool {
         self.issues.is_empty()
     }
@@ -33,7 +39,12 @@ impl Report {
         let issues = self
             .issues
             .iter()
-            .map(|i| format!("{{\"code\":\"{}\",\"count\":{}}}", i.code, i.count))
+            .map(|i| {
+                format!(
+                    "{{\"code\":\"{}\",\"count\":{},\"lossy\":{}}}",
+                    i.code, i.count, i.lossy
+                )
+            })
             .collect::<Vec<_>>()
             .join(",");
         format!(
@@ -48,6 +59,52 @@ pub fn analyze(world: &World, target: Target) -> Report {
     let mut issues = Vec::new();
     let planes = || world.brushes.iter().flat_map(|b| &b.planes);
     match target {
+        Target::Obj => {
+            if !world.computed {
+                issues.push(Issue {
+                    code: "computed_required",
+                    count: 1,
+                    lossy: false,
+                });
+            }
+            let n = planes().count().saturating_add(world.patches.len());
+            if n != 0 {
+                issues.push(Issue {
+                    code: "editable_geometry",
+                    count: n,
+                    lossy: true,
+                });
+            }
+            let n = world
+                .string_properties
+                .len()
+                .saturating_add(world.uv_properties.len())
+                .saturating_add(
+                    planes()
+                        .map(|p| p.strings.len().saturating_add(p.uv.len()))
+                        .fold(0usize, usize::saturating_add),
+                );
+            if n != 0 {
+                issues.push(Issue {
+                    code: "properties",
+                    count: n,
+                    lossy: true,
+                });
+            }
+            let n = world
+                .patches
+                .iter()
+                .filter_map(|p| p.computed.as_ref())
+                .map(|p| p.normals.len())
+                .fold(0usize, usize::saturating_add);
+            if n != 0 {
+                issues.push(Issue {
+                    code: "stored_normals",
+                    count: n,
+                    lossy: true,
+                });
+            }
+        }
         Target::Dat(version) => {
             let n = world
                 .string_properties
@@ -63,6 +120,7 @@ pub fn analyze(world: &World, target: Target) -> Report {
                 );
             if n != 0 {
                 issues.push(Issue {
+                    lossy: false,
                     code: "non_ascii",
                     count: n,
                 });
@@ -79,6 +137,7 @@ pub fn analyze(world: &World, target: Target) -> Report {
                     );
                 if n != 0 {
                     issues.push(Issue {
+                        lossy: false,
                         code: "legacy_properties",
                         count: n,
                     });
@@ -97,6 +156,7 @@ pub fn analyze(world: &World, target: Target) -> Report {
             }
             if n != 0 {
                 issues.push(Issue {
+                    lossy: false,
                     code: "duplicate_names",
                     count: n,
                 });

crates/nanobrush-cli/src/tests.rs

@@ -196,3 +196,38 @@ fn invalid_conversion_with_force_keeps_existing_destination() {
     assert_eq!(fs::read(output).unwrap(), b"KEEP");
     assert_eq!(fs::read_dir(&d.0).unwrap().count(), 2);
 }
+
+#[test]
+fn obj_acknowledgement_and_preflight() {
+    let d = Dir::new();
+    let input = d.file(
+        "triangle.txt",
+        b"world(computedFeatures true brush(plane(0 0 0,1 0 0,0 1 0 polygon[0 0 0,1 0 0,0 1 0])))",
+    );
+    let output = d.0.join("out.obj");
+    let args = [
+        "convert".as_ref(),
+        input.as_os_str(),
+        output.as_os_str(),
+        "--to".as_ref(),
+        "obj".as_ref(),
+    ];
+    assert!(call(&args).is_err());
+    assert!(!output.exists());
+    let mut allowed = args.to_vec();
+    allowed.push("--allow-lossy".as_ref());
+    call(&allowed).unwrap();
+    assert!(fs::read(&output).unwrap().ends_with(b"f 1 2 3\n"));
+    let report = call(&[
+        "preflight".as_ref(),
+        input.as_os_str(),
+        "--to".as_ref(),
+        "obj".as_ref(),
+    ])
+    .unwrap();
+    assert!(
+        String::from_utf8(report)
+            .unwrap()
+            .contains("editable_geometry")
+    );
+}

docs/CLI.md

@@ -56,3 +56,5 @@ Incompatible exports fail before publication: for example, Unicode TXT→ASCII D
 Eight asset-free unit tests cover options, limits, inspection, both DAT directions, Unicode paths, overwrite/same-file/hard-link/symlink guards, validation before any output, preservation of existing destinations after incompatible conversion, exclusive publication races and temporary cleanup. Two process integration tests check documented exit streams/codes and invoke the real binary for inspect, DAT→TXT, validate and TXT→DAT against **all 58 DAT outputs** (232 successful commands), verifying exact final DAT bytes. Fixture tests fail when assets are missing. See [E04](experiments/txt-cli-2026-10-21.md).
 
 `preflight INPUT --to FORMAT` emits schema-1 compatibility JSON without writing a document. A successful report command exits 0 even when `compatible` is false. Grouped issues cover non-ASCII DAT values, property-bearing old-DAT exports and duplicate TXT table names. Counts refer to affected names/entries, not lost bytes. Full structural/size validation remains the encoder’s responsibility.
+
+Computed OBJ export: `convert INPUT OUTPUT --to obj --allow-lossy`. `preflight INPUT --to obj` lists discarded editable geometry/properties/normals as `lossy:true`; missing computed data is blocking. Acknowledgement never overrides malformed data or limits. OBJ has no native import route.

docs/PROGRESS_2026-10-26.md

@@ -7,7 +7,7 @@ Scope: extend native headless formats and geometry. Each stage is independently
 | 1 | P6.23 | Structured preflight reports | Complete: `preflight INPUT --to FORMAT` emits schema-1 JSON with grouped ASCII/downgrade/duplicate-name incompatibilities; reports never mutate documents. Parser/encoder validation remains authoritative. Unit tests and existing CLI unit regressions pass. |
 | 2 | P6.24 | Explicit Latin-1 TXT input | Complete: ISO-8859-1 API and `--text-encoding latin1`, no guessing, conflicting UTF-8 BOM rejected; transcoded bytes and scratch ownership are bounded. UTF-8 remains default and output. Encoding and CLI unit suites pass. |
 | 3 | P6.25 | Bounded computed OBJ writer | Complete: explicit contours and patch grids, stable per-brush exact position deduplication, global 1-based indices and quad winding. Four E02 OBJ outputs match exact bytes; invalid geometry/limits tests pass. |
-| 4 | P6.26 | CLI OBJ with loss acknowledgement | Pending |
+| 4 | P6.26 | CLI OBJ with loss acknowledgement | Complete: `--to obj`, grouped preflight losses and explicit `--allow-lossy`; missing computed data remains blocking. Existing atomic publication is reused. CLI acknowledgement/preflight/regression tests pass. |
 | 5 | P5.15 | Geometry primitives/bounds | Pending |
 | 6 | P5.16 | Convex brush contours | Pending |
 | 7 | P5.17 | Patch9 tessellation | Pending |

docs/TODO.md

@@ -163,6 +163,8 @@ Each task ID is stable. Split tasks into child IDs as evidence grows. Record dep
 
 - [x] P6.25 Implement bounded computed OBJ export and verify all four E02 OBJ goldens ([ledger](PROGRESS_2026-10-26.md)).
 
+- [x] P6.26 Add guarded CLI OBJ export and explicit lossy-export acknowledgement ([ledger](PROGRESS_2026-10-26.md)).
+
 ## P7 — Input, cameras, grids, views, and editing workflows
 
 **Depends on:** P4 dispatch and P5 geometry. **Exit:** complete interaction/state-machine specifications and reproducible replays.