partforge 0.22.0 → 0.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "Turn a declarative part definition into a parametric-CAD web app (three.js + Manifold/Replicad). Requires a Vite-based consumer.",
   "type": "module",
   "license": "MIT",

package/src/framework/jobs.js

@@ -1,6 +1,8 @@
 import { meshTo3MF } from "./geometry/threemf.js";
 import { resolveDerived } from "./derive.js";
 import { resolveFonts } from "./fonts.js";
+import { measure } from "../testing/measure.js";
+import { verify } from "../testing/verify.js";
 
 // Names of the sub-parts a view shows: declared in the view and enabled for these
 // params. Order follows Object.keys(part.parts) (definition order).
@@ -113,6 +115,18 @@ export async function handle(kernel, part, msg, post) {
       onProgress("writing 3MF file");
       const data = meshTo3MF(meshes);
       post({ type: "download", data, filename: `${msg.view}.3mf`, mime: "model/3mf" }, [bufferOf(data)]);
+    } else if (msg.type === "inspect") {
+      // Full geometric oracle for the current view: solid facts (volume/genus/
+      // watertight), mesh facts, overlaps, and gap distances, plus the part's
+      // structural + declared verify gates. Runs against the worker's live kernel
+      // — the main thread only has mesh arrays, so this can only happen here.
+      // measure/verify build their own solids via buildView and are cleaned up by
+      // the `finally` below.
+      const report = {
+        measure: measure(kernel, part, msg.view, msg.params ?? {}, { minWall: true }),
+        verify: verify(kernel, part, { view: msg.view }),
+      };
+      post({ type: "report", ...report });
     }
   } catch (err) {
     if (err?.code === "NEEDS_OCCT") post({ type: "needs-occt" });

package/src/framework/mount.js

@@ -19,6 +19,12 @@ import { createViewTabs } from "./view-tabs.js";
 import { attachPickToggle, attachHoverLabels, attachPicker, formatSelection } from "./selection/index.js";
 import { createPickRequestClient } from "./pick-request/index.js";
 
+// The mount handle, factored out so its shape is unit-testable without booting
+// the full mount() pipeline (WASM + workers + DOM).
+export function makeHandle({ ready, dispose, viewer }) {
+  return { ready, dispose, captureViews: (viewNames) => viewer.captureCanonicalViews(viewNames) };
+}
+
 function createCleanupStack() {
   const cleanups = [];
   let disposed = false;
@@ -351,7 +357,7 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick,
       cleanup.dispose();
     }
 
-    return { ready, dispose };
+    return makeHandle({ ready, dispose, viewer });
   } catch (error) {
     try {
       cleanup.dispose();

package/src/framework/view-angles.js

@@ -0,0 +1,33 @@
+// Canonical camera angles for headless/offscreen captures, in the viewer's
+// three.js WORLD space (Y-up). The model is authored Z-up; the viewer's pivot
+// rotates it into Y-up, so these directions are expressed Y-up directly. Kept in
+// one place so the cloud render tool and any future headless capture agree.
+export const CANONICAL_VIEWS = ["iso", "front", "back", "top", "bottom", "left", "right"];
+
+// Direction FROM the part centre TOWARD the camera (world Y-up), plus the up vector.
+const DIRS = {
+  iso:    { dir: [1, 1, 1],   up: [0, 1, 0] },
+  front:  { dir: [0, 0, 1],   up: [0, 1, 0] },
+  back:   { dir: [0, 0, -1],  up: [0, 1, 0] },
+  top:    { dir: [0, 1, 0],   up: [0, 0, -1] },
+  bottom: { dir: [0, -1, 0],  up: [0, 0, 1] },
+  left:   { dir: [-1, 0, 0],  up: [0, 1, 0] },
+  right:  { dir: [1, 0, 0],   up: [0, 1, 0] },
+};
+
+const norm = (v) => {
+  const l = Math.hypot(v[0], v[1], v[2]) || 1;
+  return [v[0] / l, v[1] / l, v[2] / l];
+};
+
+export function cameraPoseForView(view, { center, radius }) {
+  const a = DIRS[view];
+  if (!a) throw new Error(`unknown canonical view "${view}"`);
+  const d = norm(a.dir);
+  const dist = radius * 2.6 + 6; // matches viewer.frameTo's framing distance
+  return {
+    position: [center[0] + d[0] * dist, center[1] + d[1] * dist, center[2] + d[2] * dist],
+    up: a.up,
+    target: [...center],
+  };
+}

package/src/framework/viewer.js

@@ -6,6 +6,29 @@ import { LineSegmentsGeometry } from "three/addons/lines/LineSegmentsGeometry.js
 import { LineMaterial } from "three/addons/lines/LineMaterial.js";
 import { createCutaway } from "./cutaway.js";
 import { addViewerLights } from "./viewer-lighting.js";
+import { CANONICAL_VIEWS, cameraPoseForView } from "./view-angles.js";
+
+// Render a set of canonical views without disturbing the live camera/canvas.
+// `renderer.renderOffscreen(pose)` does the GL work (temp camera → offscreen
+// target → readback → JPEG data URL); injected so this is unit-testable without
+// a GL context. The grid is hidden for the whole synchronous pass and restored.
+export function captureViewsFromScene(viewNames, { renderer, liveCamera, grid, bounds }) {
+  const views = (viewNames?.length ? viewNames : ["iso", "front", "top"])
+    .filter((v) => CANONICAL_VIEWS.includes(v))
+    .slice(0, CANONICAL_VIEWS.length);
+  const before = liveCamera.position.clone();
+  const gridWasVisible = grid?.visible;
+  if (grid) grid.visible = false;
+  try {
+    return views.map((view) => ({
+      view,
+      dataUrl: renderer.renderOffscreen(cameraPoseForView(view, bounds)),
+    }));
+  } finally {
+    if (grid) grid.visible = gridWasVisible;
+    liveCamera.position.copy(before); // belt-and-suspenders: never leak camera state
+  }
+}
 
 export function createViewer(container, part) {
   const names = Object.keys(part.parts);
@@ -261,6 +284,53 @@ export function createViewer(container, part) {
   ro.observe(container);
   resize();
 
+  // --- offscreen canonical-view capture -------------------------------------
+  // Offscreen render of the shared scene from an arbitrary pose → JPEG data URL.
+  // A separate WebGLRenderTarget + temp camera means the visible canvas and the
+  // live `camera` are never touched. WebGL pixels are bottom-up, so flip on encode.
+  const _rtSize = 512;
+  let _rt = null;
+  function renderOffscreen({ position, up, target }) {
+    _rt = _rt ?? new THREE.WebGLRenderTarget(_rtSize, _rtSize);
+    const cam = new THREE.PerspectiveCamera(45, 1, 0.1, 1000);
+    cam.position.set(position[0], position[1], position[2]);
+    cam.up.set(up[0], up[1], up[2]);
+    cam.lookAt(target[0], target[1], target[2]);
+    renderer.setRenderTarget(_rt);
+    renderer.render(scene, cam);
+    const buf = new Uint8Array(_rtSize * _rtSize * 4);
+    renderer.readRenderTargetPixels(_rt, 0, 0, _rtSize, _rtSize, buf);
+    renderer.setRenderTarget(null);
+    const canvas = document.createElement("canvas");
+    canvas.width = _rtSize; canvas.height = _rtSize;
+    const ctx = canvas.getContext("2d");
+    const img = ctx.createImageData(_rtSize, _rtSize);
+    // flip rows (GL origin is bottom-left)
+    for (let y = 0; y < _rtSize; y++) {
+      const src = (_rtSize - 1 - y) * _rtSize * 4;
+      img.data.set(buf.subarray(src, src + _rtSize * 4), y * _rtSize * 4);
+    }
+    ctx.putImageData(img, 0, 0);
+    return canvas.toDataURL("image/jpeg", 0.8);
+  }
+
+  // Render the canonical camera angles offscreen, framed to whatever is visible,
+  // without disturbing the user's live view. Returns [{ view, dataUrl }].
+  function captureCanonicalViews(viewNames) {
+    if (disposed) return [];
+    const box = getVisibleWorldBounds();
+    if (!box || box.isEmpty()) return [];
+    const center = box.getCenter(new THREE.Vector3()).toArray();
+    const size = box.getSize(new THREE.Vector3());
+    const radius = Math.max(size.x, size.y, size.z) / 2 || 10;
+    return captureViewsFromScene(viewNames, {
+      renderer: { renderOffscreen },
+      liveCamera: camera,
+      grid,
+      bounds: { center, radius },
+    });
+  }
+
   // --- render loop ----------------------------------------------------------
   renderer.setAnimationLoop(() => {
     controls.update();
@@ -323,6 +393,7 @@ export function createViewer(container, part) {
     lineMaterial.dispose();
     grid.geometry.dispose();
     grid.material.dispose();
+    _rt?.dispose();
     renderer.dispose();
     renderer.domElement.remove();
   }
@@ -334,6 +405,7 @@ export function createViewer(container, part) {
     hasSubMesh,
     subTriangles,
     frame,
+    captureCanonicalViews,
     setAutoRotate,
     setTheme,
     getCameraState,