geometry: compute worlds

Cargo.lock

@@ -28,6 +28,7 @@ dependencies = [
  "mb3-dat",
  "mb3-obj",
  "mb3-txt",
+ "nanobrush-geometry",
 ]
 
 [[package]]

crates/nanobrush-cli/Cargo.toml

@@ -16,5 +16,7 @@ mb3-txt = { path = "../mb3-txt" }
 
 mb3-obj = { path = "../mb3-obj" }
 
+nanobrush-geometry = { path = "../nanobrush-geometry" }
+
 [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|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";
+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\nUse --compute with convert/preflight to regenerate native geometry.\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,
@@ -57,6 +57,7 @@ struct Options {
     to: Option<To>,
     force: bool,
     allow_lossy: bool,
+    compute: bool,
     limits: Limits,
     encoding: mb3_txt::Encoding,
 }
@@ -84,6 +85,7 @@ fn parse(args: impl IntoIterator<Item = OsString>) -> Result<Option<Options>> {
         to: None,
         force: false,
         allow_lossy: false,
+        compute: false,
         limits: Limits::default(),
         encoding: mb3_txt::Encoding::Utf8,
     };
@@ -102,6 +104,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 == "--compute" {
+                options.compute = true;
+                continue;
+            }
             if flag == "--allow-lossy" {
                 options.allow_lossy = true;
                 continue;
@@ -191,6 +197,9 @@ fn parse(args: impl IntoIterator<Item = OsString>) -> Result<Option<Options>> {
     {
         return Err(usage("--allow-lossy requires convert --to obj"));
     }
+    if options.compute && !matches!(options.command.as_str(), "convert" | "preflight") {
+        return Err(usage("--compute requires convert or preflight"));
+    }
     Ok(Some(options))
 }
 struct Input {
@@ -325,7 +334,18 @@ pub fn run(args: impl IntoIterator<Item = OsString>, stdout: &mut dyn Write) ->
         stdout.write_all(HELP.as_bytes())?;
         return Ok(());
     };
-    let input = load(&o.paths[0], o.from, o.encoding, &o.limits)?;
+    let mut input = load(&o.paths[0], o.from, o.encoding, &o.limits)?;
+    if o.compute {
+        let limits = nanobrush_geometry::ComputeLimits {
+            max_vertices: o.limits.max_items.min(100_000),
+            max_owned_bytes: o.limits.max_owned_bytes.min(128 * 1024 * 1024),
+            ..Default::default()
+        };
+        input.world =
+            nanobrush_geometry::world::compute(&input.world, Default::default(), limits, o.limits)
+                .map_err(|e| fail(e.to_string()))?
+                .0;
+    }
     match o.command.as_str() {
         "preflight" => {
             let target = match o.to.ok_or_else(|| usage("missing --to"))? {

crates/nanobrush-cli/src/tests.rs

@@ -231,3 +231,37 @@ fn obj_acknowledgement_and_preflight() {
             .contains("editable_geometry")
     );
 }
+
+#[test]
+fn compute_cube_to_obj() {
+    let d = Dir::new();
+    let mut w = World::default();
+    let mut planes = Vec::new();
+    for axis in 0..3 {
+        for sign in [-1., 1.] {
+            let mut p = mb3_dat::Plane::default();
+            p.p0[axis] = sign;
+            p.u[(axis + 1) % 3] = 1.;
+            p.v[(axis + 2) % 3] = sign;
+            planes.push(p);
+        }
+    }
+    w.brushes.push(mb3_dat::Brush { planes });
+    let bytes = mb3_txt::encode(&w, &Limits::default()).unwrap();
+    let input = d.file("cube.txt", &bytes);
+    let output = d.0.join("cube.obj");
+    call(&[
+        "convert".as_ref(),
+        input.as_os_str(),
+        output.as_os_str(),
+        "--to".as_ref(),
+        "obj".as_ref(),
+        "--compute".as_ref(),
+        "--allow-lossy".as_ref(),
+    ])
+    .unwrap();
+    let obj = fs::read_to_string(output).unwrap();
+    assert_eq!(obj.lines().filter(|l| l.starts_with("v ")).count(), 8);
+    assert_eq!(obj.lines().filter(|l| l.starts_with("f ")).count(), 6);
+    assert_eq!(fs::read(input).unwrap(), bytes);
+}

crates/nanobrush-geometry/src/lib.rs

@@ -103,3 +103,4 @@ impl Budget {
     }
 }
 pub mod patch;
+pub mod world;

crates/nanobrush-geometry/src/world.rs

@@ -0,0 +1,268 @@
+use crate::*;
+use mb3_dat::{Brush, Limits, Patch9, PatchComputed, Plane, Property, Uv, World};
+struct CopyBudget {
+    items: usize,
+    bytes: usize,
+    limits: Limits,
+}
+impl CopyBudget {
+    fn bytes(&mut self, n: usize) -> Result<()> {
+        self.bytes = self.bytes.checked_add(n).ok_or(Error::Overflow)?;
+        if self.bytes > self.limits.max_owned_bytes {
+            Err(Error::Limit)
+        } else {
+            Ok(())
+        }
+    }
+    fn vec<T>(&mut self, n: usize) -> Result<Vec<T>> {
+        self.items = self.items.checked_add(n).ok_or(Error::Overflow)?;
+        if self.items > self.limits.max_items {
+            return Err(Error::Limit);
+        }
+        self.bytes(
+            n.checked_mul(std::mem::size_of::<T>())
+                .ok_or(Error::Overflow)?,
+        )?;
+        alloc(n)
+    }
+    fn string(&mut self, s: &str) -> Result<String> {
+        if s.len() > self.limits.max_string_bytes {
+            return Err(Error::Limit);
+        }
+        self.bytes(s.len())?;
+        let mut out = String::new();
+        out.try_reserve_exact(s.len())
+            .map_err(|_| Error::Allocation)?;
+        out.push_str(s);
+        Ok(out)
+    }
+    fn names(&mut self, names: &[String]) -> Result<Vec<String>> {
+        let mut out = self.vec(names.len())?;
+        for s in names {
+            out.push(self.string(s)?);
+        }
+        Ok(out)
+    }
+    fn base(&mut self, w: &World) -> Result<World> {
+        let string_properties = self.names(&w.string_properties)?;
+        let uv_properties = self.names(&w.uv_properties)?;
+        let mut brushes = self.vec(w.brushes.len())?;
+        for b in &w.brushes {
+            let mut planes = self.vec(b.planes.len())?;
+            for p in &b.planes {
+                let mut strings = self.vec(p.strings.len())?;
+                for s in &p.strings {
+                    strings.push(Property {
+                        index: s.index,
+                        value: self.string(&s.value)?,
+                    });
+                }
+                let mut uv: Vec<Property<Uv>> = self.vec(p.uv.len())?;
+                uv.extend(p.uv.iter().cloned());
+                planes.push(Plane {
+                    p0: p.p0,
+                    u: p.u,
+                    v: p.v,
+                    strings,
+                    uv,
+                    polygon: None,
+                });
+            }
+            brushes.push(Brush { planes });
+        }
+        let mut patches = self.vec(w.patches.len())?;
+        for p in &w.patches {
+            let mut anchors = self.vec(p.anchors.len())?;
+            anchors.extend_from_slice(&p.anchors);
+            patches.push(Patch9 {
+                anchors_u: p.anchors_u,
+                anchors_v: p.anchors_v,
+                quads_u: p.quads_u,
+                quads_v: p.quads_v,
+                anchors,
+                computed: None,
+            });
+        }
+        Ok(World {
+            computed: false,
+            string_properties,
+            uv_properties,
+            brushes,
+            patches,
+        })
+    }
+    fn vectors(&mut self, source: &[DVec3]) -> Result<Vec<mb3_dat::Vec3>> {
+        let mut out = self.vec(source.len())?;
+        for v in source {
+            out.push(math::to_f32(*v)?);
+        }
+        Ok(out)
+    }
+}
+/// Transactional by ownership: source is never mutated, and no partial world is
+/// returned. Existing derived arrays are recomputed rather than copied.
+pub fn compute(
+    source: &World,
+    policy: Policy,
+    limits: ComputeLimits,
+    codec: Limits,
+) -> Result<(World, Stats)> {
+    policy.validate()?;
+    let mut b = CopyBudget {
+        items: 0,
+        bytes: 0,
+        limits: Limits {
+            max_owned_bytes: codec.max_owned_bytes.min(limits.max_owned_bytes),
+            ..codec
+        },
+    };
+    let limits = ComputeLimits {
+        max_owned_bytes: b.limits.max_owned_bytes,
+        ..limits
+    };
+    let mut out = b.base(source)?;
+    let mut stats = Stats::default();
+    for brush in &mut out.brushes {
+        let remaining = remaining(limits, &stats, b.bytes)?;
+        let mesh = crate::brush::contours(brush, policy, remaining)?;
+        stats.work = stats
+            .work
+            .checked_add(mesh.stats.work)
+            .ok_or(Error::Overflow)?;
+        stats.vertices = stats
+            .vertices
+            .checked_add(mesh.stats.vertices)
+            .ok_or(Error::Overflow)?;
+        b.bytes(mesh.stats.owned)?;
+        for (p, polygon) in brush.planes.iter_mut().zip(&mesh.contours) {
+            p.polygon = Some(b.vectors(polygon)?);
+        }
+    }
+    for patch in &mut out.patches {
+        let remaining = remaining(limits, &stats, b.bytes)?;
+        let mesh = crate::patch::tessellate(patch, policy, remaining)?;
+        stats.work = stats
+            .work
+            .checked_add(mesh.stats.work)
+            .ok_or(Error::Overflow)?;
+        stats.vertices = stats
+            .vertices
+            .checked_add(mesh.stats.vertices)
+            .ok_or(Error::Overflow)?;
+        b.bytes(mesh.stats.owned)?;
+        patch.computed = Some(PatchComputed {
+            points: b.vectors(&mesh.points)?,
+            normals: b.vectors(&mesh.normals)?,
+        });
+    }
+    out.computed = true;
+    stats.owned = b.bytes;
+    Ok((out, stats))
+}
+fn remaining(limits: ComputeLimits, stats: &Stats, owned: usize) -> Result<ComputeLimits> {
+    Ok(ComputeLimits {
+        max_vertices: limits
+            .max_vertices
+            .checked_sub(stats.vertices)
+            .ok_or(Error::Limit)?,
+        max_work: limits
+            .max_work
+            .checked_sub(stats.work)
+            .ok_or(Error::Limit)?,
+        max_owned_bytes: limits
+            .max_owned_bytes
+            .checked_sub(owned)
+            .ok_or(Error::Limit)?,
+        ..limits
+    })
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn mixed_world_roundtrip_properties_and_source_immutable() {
+        let mut w = World {
+            brushes: vec![crate::brush::cube()],
+            patches: vec![crate::patch::flat(3, 3)],
+            string_properties: vec!["name".into()],
+            ..World::default()
+        };
+        w.brushes[0].planes[0].strings.push(Property {
+            index: 0,
+            value: "value".into(),
+        });
+        let before = w.clone();
+        let (out, s) = compute(
+            &w,
+            Policy::default(),
+            ComputeLimits::default(),
+            Limits::default(),
+        )
+        .unwrap();
+        assert_eq!(w, before);
+        assert!(out.computed);
+        assert_eq!(s.vertices, 33);
+        assert_eq!(
+            out.brushes[0].planes[0].strings,
+            w.brushes[0].planes[0].strings
+        );
+        let d = mb3_dat::Document {
+            world: out,
+            version: mb3_dat::Version::V201512200,
+        };
+        assert_eq!(
+            mb3_dat::decode(
+                &mb3_dat::encode(&d, &Limits::default()).unwrap(),
+                &Limits::default()
+            )
+            .unwrap(),
+            d
+        );
+    }
+    #[test]
+    fn late_failure_and_global_budgets() {
+        let w = World {
+            brushes: vec![crate::brush::cube(), Brush { planes: vec![] }],
+            ..World::default()
+        };
+        let before = w.clone();
+        assert!(
+            compute(
+                &w,
+                Policy::default(),
+                ComputeLimits::default(),
+                Limits::default()
+            )
+            .is_err()
+        );
+        assert_eq!(w, before);
+        let w = World {
+            brushes: vec![crate::brush::cube(), crate::brush::cube()],
+            ..World::default()
+        };
+        assert!(
+            compute(
+                &w,
+                Policy::default(),
+                ComputeLimits {
+                    max_vertices: 30,
+                    ..Default::default()
+                },
+                Limits::default()
+            )
+            .is_err()
+        );
+        assert!(
+            compute(
+                &w,
+                Policy::default(),
+                ComputeLimits::default(),
+                Limits {
+                    max_owned_bytes: 1,
+                    ..Default::default()
+                }
+            )
+            .is_err()
+        );
+    }
+}

docs/CLI.md

@@ -58,3 +58,5 @@ Eight asset-free unit tests cover options, limits, inspection, both DAT directio
 `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.
+
+`convert/preflight --compute` explicitly regenerates native brush contours and Patch9 samples before export/reporting. See [native geometry policy](GEOMETRY.md); it is not a claim of editor-identical geometry. It reuses guarded publication, and geometry failure leaves both source and destination untouched.

docs/GEOMETRY.md

@@ -17,3 +17,9 @@ Defaults cap 64 planes, 100,000 generated face vertices, 10 million work units a
 `patch::sample` evaluates a quadratic 3×3 tile and analytic derivatives; `tessellate` spans odd anchor grids with overlapping tiles every two anchors, U varying fastest. The evaluator uses the tensor product of three-control-point quadratic curves ([W3C quadratic curve definition](https://www.w3.org/TR/SVG/paths.html#PathDataQuadraticBezierCommands)); this tensor-product choice is native policy, not recovered host implementation. Basis is `[(1-t)^2,2t(1-t),t²]`; derivatives are `[-2(1-t),2-4t,2t]`.
 
 Anchor dimensions must be odd and at least three, and quads per tile at least two, matching source API declarations. Normals use `dv×du` to agree with exported OBJ quad winding. At an interior tile boundary, the right/upper tile supplies the derivative; positional seams are shared but normals are not averaged. Degenerate tangents/normals fail rather than inventing a direction. Sample count/products, work (nine control evaluations per sample) and requested point/normal allocations are bounded. Flat XZ patches, endpoints, exact quadratic midpoints, multi-tile seams and invalid/budget cases pass. Folded/self-intersecting surfaces and legacy seam-normal parity remain open.
+
+## Computed world pipeline
+
+`world::compute` returns a new world, preserving source tables, slots, bases and anchors. It fallibly copies editable data, rebuilds every brush/patch, checks f64→f32 range, and sets computed=true only after all objects succeed. Prior derived arrays are intentionally replaced. Properties are copied unchanged, not normalized; codec-specific validation still happens at save. No source mutation or partial world escapes on a late error.
+
+Work and generated-position budgets apply across the whole world. Requested copy/geometry/output allocations are charged cumulatively (including scratch already freed, conservatively); model element/string limits also apply. CLI `convert/preflight --compute` opts into this native policy before target analysis/encoding. Defaults cap 64 planes per brush, 100,000 generated positions, 10 million work units, and the lower of codec/geometry storage limits. Empty worlds compute successfully; malformed/redundant/open brushes and degenerate patches fail instead of being dropped. Mixed cube/patch, property preservation, DAT round trip, late failure, global-budget and CLI cube-to-OBJ tests pass.

docs/PROGRESS_2026-10-26.md

@@ -11,6 +11,6 @@ Scope: extend native headless formats and geometry. Each stage is independently
 | 5 | P5.15 | Geometry primitives/bounds | Complete: f64 vector helpers, checked unit plane equations/triple intersections, f32 boundary checks, MAP axes and AABBs. Analytic/degenerate/scaled-basis tests pass; native epsilon/interior policy documented separately from legacy parity. |
 | 6 | P5.16 | Convex brush contours | Complete: bounded half-space intersections, recession rejection, deterministic outward contours, closed-edge and volume checks. Cube/translation/winding/invalid/redundant/budget tests pass. |
 | 7 | P5.17 | Patch9 tessellation | Complete: tiled tensor-quadratic positions, analytic derivatives, OBJ-consistent normals, shared-position seam policy and bounded allocations/work. Planar/curved/multi-tile/degenerate/limit tests pass. |
-| 8 | P5.18 | Computed world pipeline/CLI | Pending |
+| 8 | P5.18 | Computed world pipeline/CLI | Complete: fallible editable-data copying, aggregate work/storage/position budgets, complete-or-error derived data and explicit `--compute`. Mixed-world/property/DAT/late-failure/global-limit and CLI cube→OBJ tests pass. |
 | 9 | P5.19 | Nearest-hit ray queries | Pending |
 | 10 | P5.20 | Property table edits/reindexing | Pending |

docs/TODO.md

@@ -132,6 +132,8 @@ Each task ID is stable. Split tasks into child IDs as evidence grows. Record dep
 
 - [x] P5.17 Implement bounded native Patch9 tensor-quadratic sampling/tessellation and analytic normals ([GEOMETRY.md](GEOMETRY.md)).
 
+- [x] P5.18 Integrate bounded complete-or-error computed worlds and explicit CLI geometry generation ([GEOMETRY.md](GEOMETRY.md)).
+
 ## P6 — File formats and converters
 
 **Depends on:** P3 oracle where available, P5 document model. **Exit:** standalone format specifications, declared compatibility subsets, fixture corpus, and native codecs.