partforge 0.1.0 → 0.3.3

package/src/framework/mount.js

@@ -1,9 +1,12 @@
 import "./app.css"; // shared chrome styles — every part-app gets them via mount
 import { zipSync } from "fflate";
 import { createViewer } from "./viewer.js";
+import { loadRotating, saveRotating, loadCamera, saveCamera, loadView, saveView } from "./view-state.js";
 import { buildControls } from "./controls.js";
+import { relevantParamKeys } from "./param-deps.js";
 import { createGeometryService } from "./geometry-service.js";
 import { viewSubParts } from "./jobs.js";
+import { detectBackend } from "./geometry/probe.js";
 
 // Mount a full parametric-part app from a PartDefinition: 3-D viewer + control
 // panel + the two geometry workers + the auto-regenerating view/cache loop +
@@ -16,8 +19,10 @@ export function mount(part, { createWorker, container = document.getElementById(
   const names = Object.keys(part.parts);
   const viewer = createViewer(container, part);
 
-  // ?backend=occt routes preview generate through the OCCT worker (dev toggle).
-  const occtPreview = new URLSearchParams(location.search).get("backend") === "occt";
+  // ?backend=occt|manifold forces the backend; otherwise it's detected per part.
+  let forcedBackend = new URLSearchParams(location.search).get("backend");
+  if (forcedBackend !== "occt" && forcedBackend !== "manifold") forcedBackend = null;
+  const backendFor = () => forcedBackend ?? detectBackend(part, params);
 
   const statusEl = document.getElementById("status");
   const dlBtn = document.getElementById("download");
@@ -36,12 +41,23 @@ export function mount(part, { createWorker, container = document.getElementById(
   const hideBusy = () => busyEl.classList.remove("show");
 
   // --- per-sub-part mesh cache + auto-regenerating view composition ----------
-  // The host page owns the view-tab markup (#part buttons, data-part = view name);
-  // `part.views` documents the available views and their labels for that page.
-  // The initial view is whichever tab the page marks active (else the first tab).
+  // The view-tab buttons are generated from `part.views` (the single source of truth):
+  // each entry becomes a <button data-part=view>label</button> inside #part, with the
+  // first view marked active by default. (A saved view, below, overrides the default.)
+  if (partSeg && part.views) {
+    partSeg.innerHTML = Object.entries(part.views)
+      .map(([key, v], i) => `<button data-part="${key}"${i === 0 ? ' class="on"' : ""}>${v?.label ?? key}</button>`)
+      .join("");
+  }
+  // The initial view is whichever tab is marked active (else the first tab).
   const params = { ...part.defaults };
-  let view = partSeg.querySelector("button.on")?.dataset.part ?? partSeg.querySelector("button")?.dataset.part;
+  const defaultView = partSeg.querySelector("button.on")?.dataset.part ?? partSeg.querySelector("button")?.dataset.part;
+  const savedView = loadView();
+  const savedBtn = savedView ? [...partSeg.querySelectorAll("button[data-part]")].find((b) => b.dataset.part === savedView) : null;
+  let view = savedBtn ? savedView : defaultView;
+  if (savedBtn) for (const b of partSeg.children) b.classList.toggle("on", b === savedBtn);
   let framedView = null; // the view the camera was last framed to (null until first show)
+  let cameraRestored = false; // saved camera applied once, on the first frame after load
   let generating = false;
   let paramsVersion = 0; // bumped on every settings edit
   let genVersion = -1;   // the params version the in-flight generate is building
@@ -60,7 +76,14 @@ export function mount(part, { createWorker, container = document.getElementById(
   function showView(needed) {
     const frame = view !== framedView;
     viewer.showAssembly(needed, { frame });
-    if (frame) framedView = view;
+    if (frame) {
+      framedView = view;
+      if (!cameraRestored) {
+        const cam = loadCamera();
+        if (cam) viewer.setCameraState(cam);
+        cameraRestored = true;
+      }
+    }
   }
 
   function refreshView() {
@@ -135,6 +158,11 @@ export function mount(part, { createWorker, container = document.getElementById(
         triggerDownload(data.data, data.filename, data.mime);
         setStatus(`${data.filename} downloaded`);
         break;
+      case "needs-occt":
+        forcedBackend = "occt"; // probe missed; this part needs OCCT — stick to it
+        generating = false;
+        maybeGenerate();
+        break;
       case "error":
         generating = false;
         hideBusy();
@@ -144,13 +172,16 @@ export function mount(part, { createWorker, container = document.getElementById(
     }
   }
 
-  const service = createGeometryService({ createWorker, onMessage: onWorkerMessage, occtPreview });
+  const service = createGeometryService({ createWorker, onMessage: onWorkerMessage });
 
-  buildControls(controls, part.parameters, params, onParamChange);
+  const panel = buildControls(controls, part.parameters, params, onParamChange);
+  const updateRelevance = () => panel.applyRelevance(relevantParamKeys(part, view, params));
+  updateRelevance(); // initial view
 
   function onParamChange() {
     paramsVersion++; // every edit invalidates the caches (by version)
     refreshView();   // keep showing the now-stale mesh (no flicker); disable export
+    updateRelevance();
     scheduleGenerate();
   }
 
@@ -168,21 +199,23 @@ export function mount(part, { createWorker, container = document.getElementById(
     generating = true;
     genVersion = paramsVersion;
     showBusy("generating");
-    service.generate({ type: "generate", subparts: missing, view, params });
+    service.generate({ type: "generate", subparts: missing, view, params }, backendFor());
   }
 
   partSeg.addEventListener("click", (e) => {
     const btn = e.target.closest("button[data-part]");
     if (!btn) return;
     view = btn.dataset.part;
+    saveView(view);
     for (const b of partSeg.children) b.classList.toggle("on", b === btn);
     refreshView();  // instant if the view's parts are cached + current
+    updateRelevance();
     maybeGenerate(); // else auto-build the missing pieces
   });
 
   dlBtn.addEventListener("click", () => {
     showBusy("exporting STL");
-    service.exportStl({ type: "export-stl", view, params });
+    service.exportStl({ type: "export-stl", view, params }, backendFor());
   });
 
   dlStepBtn.addEventListener("click", () => {
@@ -192,7 +225,7 @@ export function mount(part, { createWorker, container = document.getElementById(
 
   dl3mfBtn?.addEventListener("click", () => {
     showBusy("exporting 3MF");
-    service.export3mf({ type: "export-3mf", view, params });
+    service.export3mf({ type: "export-3mf", view, params }, backendFor());
   });
 
   // --- viewer controls (optional host-page buttons: #pause / #reframe / #theme) --
@@ -214,14 +247,25 @@ export function mount(part, { createWorker, container = document.getElementById(
   themeBtn?.addEventListener("click", () => applyTheme(theme === "light" ? "dark" : "light"));
 
   // Pause/resume the idle auto-rotation.
-  let rotating = true;
+  let rotating = loadRotating();
+  viewer.setAutoRotate(rotating);
+  if (pauseBtn) {
+    pauseBtn.textContent = rotating ? "⏸" : "▶";
+    pauseBtn.title = rotating ? "Pause rotation" : "Resume rotation";
+  }
   pauseBtn?.addEventListener("click", () => {
     rotating = !rotating;
     viewer.setAutoRotate(rotating);
     pauseBtn.textContent = rotating ? "⏸" : "▶";
     pauseBtn.title = rotating ? "Pause rotation" : "Resume rotation";
+    saveRotating(rotating);
   });
 
   // Re-fit the camera to the current view.
   reframeBtn?.addEventListener("click", () => viewer.frame());
+
+  // Persist the camera when the user finishes an orbit/zoom, and right before a
+  // reload (captures the latest pose, including auto-rotation drift).
+  viewer.onCameraEnd(() => saveCamera(viewer.getCameraState()));
+  window.addEventListener("pagehide", () => saveCamera(viewer.getCameraState()));
 }

package/src/framework/param-deps.js

@@ -0,0 +1,50 @@
+// Which raw parameters affect the parts on screen in the active view. A removable
+// relevance layer: the panel uses this to dim controls / hide sections that don't
+// affect what's visible. Pure — no DOM, no real geometry (reuses the geometry-free
+// probe kernel). Errs toward RELEVANT_ALL whenever it can't analyze a build.
+import { createProbeKernel } from "./geometry/probe.js";
+import { viewSubParts } from "./jobs.js";
+
+export const RELEVANT_ALL = Symbol("relevant-all");
+
+// A read-recording Proxy over a shallow clone of `obj`: records each top-level
+// property key read into `seen`, returns the real value so the build's conditionals
+// evaluate correctly, and never mutates the original `obj` (writes hit the clone).
+function recorder(obj, seen) {
+  return new Proxy({ ...obj }, {
+    get(target, key) {
+      if (typeof key === "string") seen.add(key);
+      return Reflect.get(target, key);
+    },
+  });
+}
+
+export function relevantParamKeys(part, view, params) {
+  try {
+    const relevant = new Set();
+
+    // derive: record which raw params feed it; produce real derived values once.
+    const deriveInputs = new Set();
+    const derived = part.derive ? (part.derive(recorder(params, deriveInputs)) ?? {}) : {};
+
+    // gate params: a param read by a view sub-part's enabled() changes what's on screen.
+    for (const name of Object.keys(part.parts)) {
+      const sp = part.parts[name];
+      if (sp.views.includes(view) && sp.enabled) sp.enabled(recorder(params, relevant));
+    }
+
+    // direct build reads across the on-screen (enabled) sub-parts.
+    const { kernel } = createProbeKernel();
+    let anyDerivedRead = false;
+    for (const name of viewSubParts(part, view, params)) {
+      const dSeen = new Set();
+      part.parts[name].build(kernel, recorder(params, relevant), recorder(derived, dSeen));
+      if (dSeen.size > 0) anyDerivedRead = true;
+    }
+    if (anyDerivedRead) for (const k of deriveInputs) relevant.add(k);
+
+    return relevant;
+  } catch {
+    return RELEVANT_ALL; // couldn't analyze — treat everything as relevant
+  }
+}

package/src/framework/view-state.js

@@ -0,0 +1,55 @@
+// Persist a little viewer UI state across browser reloads (notably Vite dev
+// auto-refresh) in localStorage. All keys are global. Reads/writes are guarded:
+// if localStorage is unavailable (private mode, disabled) or a value is corrupt,
+// reads return the documented default and writes are no-ops — persistence never
+// throws. Theme is persisted separately (in mount.js) and is not handled here.
+
+const KEY = {
+  rotating: "partforge:rotating",
+  camera: "partforge:camera",
+  view: "partforge:view",
+};
+
+function read(key) {
+  try { return localStorage.getItem(key); } catch { return null; }
+}
+function write(key, value) {
+  try { localStorage.setItem(key, value); } catch { /* storage unavailable — no-op */ }
+}
+
+const isVec3 = (v) => Array.isArray(v) && v.length === 3 && v.every((n) => Number.isFinite(n));
+
+export function loadRotating() {
+  const raw = read(KEY.rotating);
+  if (raw === "false") return false;
+  if (raw === "true") return true;
+  return true; // default: auto-rotate on (matches the viewer's default)
+}
+
+export function saveRotating(on) {
+  write(KEY.rotating, on ? "true" : "false");
+}
+
+export function loadCamera() {
+  const raw = read(KEY.camera);
+  if (!raw) return null;
+  let parsed;
+  try { parsed = JSON.parse(raw); } catch { return null; }
+  if (parsed && isVec3(parsed.pos) && isVec3(parsed.target)) {
+    return { pos: parsed.pos, target: parsed.target };
+  }
+  return null;
+}
+
+export function saveCamera(state) {
+  if (!state || !isVec3(state.pos) || !isVec3(state.target)) return;
+  write(KEY.camera, JSON.stringify({ pos: state.pos, target: state.target }));
+}
+
+export function loadView() {
+  return read(KEY.view); // raw string or null; caller validates against available tabs
+}
+
+export function saveView(name) {
+  if (typeof name === "string" && name) write(KEY.view, name);
+}

package/src/framework/viewer.js

@@ -61,8 +61,20 @@ export function createViewer(container, part) {
   const partsGroup = new THREE.Group();
   pivot.add(partsGroup);
 
+  // Per-sub-part material: parts share the default material unless they declare
+  // `display: { color?, opacity? }` (e.g. a reference/ghost part shown in a
+  // distinct colour and/or semi-transparent so it reads as "not a printed part").
+  function materialFor(name) {
+    const disp = part.parts[name].display;
+    if (!disp || (disp.color == null && disp.opacity == null)) return material;
+    const m = material.clone();
+    if (disp.color != null) m.color = new THREE.Color(disp.color);
+    if (disp.opacity != null && disp.opacity < 1) { m.transparent = true; m.opacity = disp.opacity; m.depthWrite = false; }
+    return m;
+  }
+
   const subMesh = Object.fromEntries(
-    names.map((n) => [n, new THREE.Mesh(new THREE.BufferGeometry(), material)])
+    names.map((n) => [n, new THREE.Mesh(new THREE.BufferGeometry(), materialFor(n))])
   );
   for (const m of Object.values(subMesh)) {
     m.visible = false;
@@ -193,6 +205,20 @@ export function createViewer(container, part) {
     renderer.render(scene, camera);
   });
 
+  // --- camera state (read/write for persistence; mount.js owns storage) -------
+  function getCameraState() {
+    return {
+      pos: [camera.position.x, camera.position.y, camera.position.z],
+      target: [controls.target.x, controls.target.y, controls.target.z],
+    };
+  }
+  function setCameraState({ pos, target }) {
+    camera.position.set(pos[0], pos[1], pos[2]);
+    controls.target.set(target[0], target[1], target[2]);
+    controls.update();
+  }
+  function onCameraEnd(cb) { controls.addEventListener("end", cb); }
+
   // --- dispose --------------------------------------------------------------
   function dispose() {
     renderer.setAnimationLoop(null);
@@ -200,5 +226,5 @@ export function createViewer(container, part) {
     container.removeChild(renderer.domElement);
   }
 
-  return { showAssembly, hideAssembly, setSubGeometry, resize, dispose, frame, setAutoRotate, setTheme, _subCache: subCache };
+  return { showAssembly, hideAssembly, setSubGeometry, resize, dispose, frame, setAutoRotate, setTheme, getCameraState, setCameraState, onCameraEnd, _subCache: subCache };
 }

package/src/parts/demo.js

@@ -1,38 +1,56 @@
-// Example PartDefinition — a parametric spacer. Proof that a new part is just a new
-// script: the framework (viewer, controls, workers, STL/STEP export) is reused
-// unchanged. Mount it with its own app/worker entry exactly as the drum does.
+// Example PartDefinition — a parametric spacer. Doubles as the worked example for
+// docs/AUTHORING-PARTS.md "Designing the control panel": a description on every
+// control, a hidden internal constant, and a derive() that turns raw inputs into the
+// dependent dimensions the build consumes. The framework (viewer, controls, workers,
+// STL/STEP export) is reused unchanged.
 export default {
   meta: { title: "Spacer", units: "mm", background: 0x15181d },
   parameters: [
     {
       id: "body",
       title: "Body",
+      description: "The spacer barrel and its through-bore. Pick a preset for a common screw size, or open **Advanced** to set exact dimensions.",
       presets: { M3: { od: 8, bore: 3.4, h: 10 }, M5: { od: 12, bore: 5.4, h: 16 } },
       advanced: [
-        { key: "od", label: "Outer diameter", unit: "mm", min: 4, max: 40, step: 0.5 },
-        { key: "bore", label: "Bore", unit: "mm", min: 1, max: 30, step: 0.1, control: "number" },
-        { key: "h", label: "Height", unit: "mm", min: 2, max: 60, step: 1 },
+        { key: "od", label: "Outer diameter", unit: "mm", min: 4, max: 40, step: 0.5,
+          description: "Barrel outer diameter. Keep it comfortably larger than the bore so a wall remains. See the [authoring guide](https://github.com/scottsykora/partforge/blob/main/docs/AUTHORING-PARTS.md)." },
+        { key: "bore", label: "Bore", unit: "mm", min: 1, max: 30, step: 0.1, control: "number",
+          description: "Nominal screw clearance hole. A fixed print clearance is added automatically (see `derive`), so enter the *nominal* size." },
+        { key: "h", label: "Height", unit: "mm", min: 2, max: 60, step: 1,
+          description: "Spacer length along the axis." },
+        { key: "flange_h", label: "Flange thickness", unit: "mm", min: 1, max: 5, step: 0.5, hidden: true,
+          description: "Internal: flange plate thickness, fixed by the design. Hidden from the end user, but still drives the geometry." },
       ],
     },
     {
       id: "flange",
       title: "Flange",
+      description: "Optional base flange — a wider seating plate at one end.",
       features: [
         { label: "Base flange", key: "flange_d", on: 16,
-          sliders: [{ key: "flange_d", label: "Flange diameter", unit: "mm", min: 8, max: 50, step: 1 }] },
+          description: "Adds a `flange_h`-thick plate of this diameter at the base.",
+          sliders: [{ key: "flange_d", label: "Flange diameter", unit: "mm", min: 8, max: 50, step: 1,
+            description: "Outer diameter of the base flange." }] },
       ],
     },
   ],
-  defaults: { od: 8, bore: 3.4, h: 10, flange_d: 0 },
+  defaults: { od: 8, bore: 3.4, h: 10, flange_d: 0, flange_h: 2 },
+  // derive(): turn raw inputs into the dependent dimensions the build needs, so one
+  // input drives the geometry consistently — here the bore gains a fixed print
+  // clearance and the cut tool is sized to pierce the whole part.
+  derive: (p) => ({
+    boreR: (p.bore + 0.2) / 2, // nominal bore + 0.2 mm print clearance, as a radius
+    cutH: p.h + 4,             // through-cut tool, taller than the part
+  }),
   parts: {
     spacer: {
       label: "Spacer",
       views: ["spacer"],
       export: { name: "spacer" },
-      build: (k, p) => {
+      build: (k, p, d) => {
         let s = k.cylinder(p.od / 2, p.od / 2, p.h);
-        if (p.flange_d > 0) s = k.union([s, k.cylinder(p.flange_d / 2, p.flange_d / 2, 2)]);
-        return s.cut(k.cylinder(p.bore / 2, p.bore / 2, p.h + 4).translate([0, 0, -2]));
+        if (p.flange_d > 0) s = k.union([s, k.cylinder(p.flange_d / 2, p.flange_d / 2, p.flange_h)]);
+        return s.cut(k.cylinder(d.boreR, d.boreR, d.cutH).translate([0, 0, -2]));
       },
     },
   },

package/src/parts/filleted-box.js

@@ -0,0 +1,46 @@
+// Example part exercising native CAD ops — it auto-routes to the OCCT backend
+// because it uses fillet (and chamfer when enabled). Vertical edges are rounded
+// and an optional bore drilled; the base chamfer is off by default (turn it up to
+// try chamfering, kept off in defaults so the gating build uses only the fillet).
+export default {
+  meta: { title: "Filleted Box", units: "mm", background: 0x15181d },
+  parameters: [
+    {
+      id: "box", title: "Box",
+      advanced: [
+        { key: "w", label: "Width", unit: "mm", min: 10, max: 80, step: 1 },
+        { key: "d", label: "Depth", unit: "mm", min: 10, max: 80, step: 1 },
+        { key: "h", label: "Height", unit: "mm", min: 5, max: 40, step: 1 },
+        { key: "fillet", label: "Edge fillet", unit: "mm", min: 0, max: 10, step: 0.5 },
+        { key: "top", label: "Top fillet", unit: "mm", min: 0, max: 5, step: 0.5 },
+        { key: "chamfer", label: "Base chamfer", unit: "mm", min: 0, max: 10, step: 0.5 },
+        { key: "bore", label: "Bore", unit: "mm", min: 0, max: 24, step: 0.5 },
+      ],
+    },
+  ],
+  defaults: { w: 40, d: 30, h: 16, fillet: 3, top: 2, chamfer: 0, bore: 8 },
+  parts: {
+    body: {
+      label: "Body",
+      views: ["box"],
+      build: (k, p) => {
+        let s = k.box([0, 0, 0], [p.w, p.d, p.h]);
+        const half = Math.min(p.w, p.d) / 2;
+        // Round the vertical edges, then the top rim — each clamped to the box so a
+        // radius can't exceed the available material.
+        const vFillet = Math.min(p.fillet, half - 0.5, p.h - 0.5);
+        if (vFillet > 0) s = s.fillet(vFillet, { dir: "Z" });                   // 4 vertical edges
+        const topFillet = Math.min(p.top, half - vFillet - 0.5, p.h / 2 - 0.5);
+        if (topFillet > 0) s = s.fillet(topFillet, { inPlane: "XY", at: p.h });  // top rim — curves all the way around
+        // Base chamfer AFTER the fillets, so it cuts a clean curve across the rounded
+        // corners. No manual limit needed: the backend auto-clamps a chamfer to half
+        // the shortest edge it touches (here the fillets' bottom arcs), so it stops at
+        // its valid maximum instead of mangling the bottom face.
+        if (p.chamfer > 0) s = s.chamfer(p.chamfer, { inPlane: "XY", at: 0 });    // base edges
+        if (p.bore > 0) s = s.cut(k.cylinder(p.bore / 2, p.bore / 2, p.h + 2).translate([p.w / 2, p.d / 2, -1]));
+        return s;
+      },
+    },
+  },
+  views: { box: { label: "Box" } },
+};

package/src/testing/build.js

@@ -0,0 +1,17 @@
+import { viewSubParts } from "../framework/jobs.js";
+
+// Build every sub-part of a view in its display (assembly) pose with the given
+// Manifold kernel, returning live solids + copied-out meshes. Mirrors the
+// `generate` path in jobs.js, but keeps solids LIVE (does NOT call
+// kernel.cleanup()) so callers can read exact solid facts (volume/genus/empty)
+// before they free the kernel. Meshes are JS-owned arrays and survive cleanup.
+export function buildView(kernel, part, view, params = {}) {
+  const p = { ...part.defaults, ...params };
+  const d = part.derive ? part.derive(p) : {};
+  return viewSubParts(part, view, p).map((name) => {
+    const sp = part.parts[name];
+    let solid = sp.build(kernel, p, d);
+    if (sp.place) solid = sp.place(solid, { view, purpose: "display", p, d });
+    return { name, solid, mesh: solid.toMesh() };
+  });
+}

package/src/testing/measure.js

@@ -0,0 +1,53 @@
+import { buildView } from "./build.js";
+import { assemblyOverlaps } from "../framework/assembly.js";
+import { bounds, meshArea } from "./mesh.js";
+
+const size = ({ min, max }) => [max[0] - min[0], max[1] - min[1], max[2] - min[2]];
+const unionBounds = (list) => list.reduce(
+  (acc, b) => ({ min: acc.min.map((v, i) => Math.min(v, b.min[i])), max: acc.max.map((v, i) => Math.max(v, b.max[i])) }),
+  { min: [Infinity, Infinity, Infinity], max: [-Infinity, -Infinity, -Infinity] },
+);
+
+// Headless geometric report for one view of a part (Manifold-only). Reads exact
+// solid facts (volume/genus/emptiness) and mesh facts (bbox/area/triangles), plus
+// the assembly overlap check. All solid facts are read BEFORE assemblyOverlaps,
+// which frees the shared kernel's objects at its end.
+//   → { part, view, subparts[], aggregate, overlaps[], ok }
+export function measure(kernel, part, view = Object.keys(part.views)[0], params = {}) {
+  const built = buildView(kernel, part, view, params);
+  const subBounds = [];
+  const subparts = built.map(({ name, solid, mesh }) => {
+    const b = bounds(mesh.positions);
+    subBounds.push(b);
+    return {
+      name,
+      bbox: size(b),
+      volume: solid.volume(),
+      surfaceArea: meshArea(mesh.positions, mesh.indices),
+      triangleCount: mesh.triangles,
+      watertight: typeof solid.isEmpty === "function" ? !solid.isEmpty() : null,
+      holes: typeof solid.genus === "function" ? solid.genus() : null,
+    };
+  });
+
+  // Rebuilds with the same kernel and cleans up at its end — every solid fact
+  // above is already read, so this is safe.
+  const canIntersect = built.length > 0 && typeof built[0].solid.intersect === "function";
+  const overlaps = canIntersect ? assemblyOverlaps(kernel, part, view, params) : [];
+  kernel.cleanup?.();
+
+  const aggregate = {
+    bbox: subparts.length ? size(unionBounds(subBounds)) : [0, 0, 0],
+    volume: subparts.reduce((a, s) => a + s.volume, 0),
+    surfaceArea: subparts.reduce((a, s) => a + s.surfaceArea, 0),
+    triangleCount: subparts.reduce((a, s) => a + s.triangleCount, 0),
+  };
+  return {
+    part: part.meta?.title ?? view,
+    view,
+    subparts,
+    aggregate,
+    overlaps,
+    ok: subparts.every((s) => s.watertight !== false) && overlaps.length === 0,
+  };
+}

package/src/testing/mesh.js

@@ -19,3 +19,30 @@ export function bboxSize(positions) {
   }
   return [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]];
 }
+
+// Axis-aligned bounds of a flat position array (x,y,z per vertex).
+export function bounds(positions) {
+  const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
+  for (let i = 0; i < positions.length; i += 3) for (let a = 0; a < 3; a++) {
+    const v = positions[i + a];
+    if (v < min[a]) min[a] = v;
+    if (v > max[a]) max[a] = v;
+  }
+  return { min, max };
+}
+
+// Surface area (mm²) of a triangle mesh. `indices` is optional: when omitted the
+// positions are a non-indexed soup (3 consecutive verts per triangle, Manifold);
+// when given, positions is a vertex array indexed by triangle (OCCT/replicad).
+export function meshArea(positions, indices) {
+  let area = 0;
+  const n = indices ? indices.length : positions.length / 3;
+  for (let i = 0; i < n; i += 3) {
+    const a = (indices ? indices[i] : i) * 3, b = (indices ? indices[i + 1] : i + 1) * 3, c = (indices ? indices[i + 2] : i + 2) * 3;
+    const ux = positions[b] - positions[a], uy = positions[b + 1] - positions[a + 1], uz = positions[b + 2] - positions[a + 2];
+    const vx = positions[c] - positions[a], vy = positions[c + 1] - positions[a + 1], vz = positions[c + 2] - positions[a + 2];
+    const nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
+    area += Math.hypot(nx, ny, nz) / 2;
+  }
+  return area;
+}