partforge 0.53.0 → 0.54.0

package/src/framework/measure/dim3-scene.js

@@ -0,0 +1,438 @@
+// In-scene dimension renderer (spec v2 + amendments). Renders dim3-place's
+// parametric drawings as three.js objects parented under the meshes' shared
+// group, so the pivot rotation, per-view recentring and pose fast path apply
+// for free. Placement discovers WHERE a dimension is anchored; this module
+// assembles its final geometry every frame, because every display distance is
+// SCREEN-constant — sized off one shared reference distance (camera to the
+// model centre) so the whole drawing reads the same at any zoom, on any part
+// size, uniformly across a view. Text is painted onto canvas textures by an
+// injectable painter (tests inject a fake; happy-dom has no real 2d context).
+// Dims draw over the model (depthTest:false), are never cutaway-clipped
+// (materials deliberately NOT registered with the cutaway), and are hidden
+// from canonical captures.
+import * as THREE from "three";
+import { LineSegments2 } from "three/addons/lines/LineSegments2.js";
+import { LineSegmentsGeometry } from "three/addons/lines/LineSegmentsGeometry.js";
+import { LineMaterial } from "three/addons/lines/LineMaterial.js";
+import { CUTAWAY_OVERLAY_RENDER_ORDER } from "../cutaway-render.js";
+
+// Theme palettes for dimension ink. Deliberately hardcoded (not CSS vars):
+// the scene renders to WebGL where var() can't reach, and these pair with the
+// viewer THEME backgrounds. static = always-on overall dims; strong = hover +
+// pinned.
+export const DIM_THEME = {
+  dark: {
+    static: 0x7d93b8, strong: 0xa8c2ff,
+    text: "#d6e2ff", halo: "rgba(8, 11, 16, 0.95)",
+  },
+  light: {
+    // darker ink + a solid near-white halo: the first light palette washed
+    // out against the pale background and the part's light-blue surfaces
+    static: 0x5a6c8a, strong: 0x2c4a86,
+    text: "#182a4e", halo: "rgba(255, 255, 255, 0.96)",
+  },
+};
+
+// Above the cutaway-overlay tier (section caps, and the hover highlight,
+// which renders at CUTAWAY_OVERLAY_RENDER_ORDER): a later-drawn transparent
+// highlight would otherwise tint every dim pixel it covers. The cutaway
+// GIZMO deliberately stays above the dims — it is an active drag control.
+export const RENDER_ORDER_DIMS = CUTAWAY_OVERLAY_RENDER_ORDER + 2;
+export const RENDER_ORDER_LABELS = CUTAWAY_OVERLAY_RENDER_ORDER + 3;
+
+// Screen-constant sizes, CSS px, all sized off the same per-view reference
+// distance. Uniform per view by design — a nearer dimension is NOT normalized
+// to match a farther one; it just reads slightly larger under perspective
+// like the rest of the scene.
+export const LABEL_SCREEN_PX = 21;     // label text height
+export const ARROW_SCREEN_PX = 10;     // arrowhead length
+export const ARROW_HALF_W = 0.25;      // × arrow length — the narrow drafting ratio
+export const OVERSHOOT_SCREEN_PX = 7;  // extension line past the dim line
+export const GAP_SCREEN_PX = 4;        // extension line stands off the surface
+export const STANDOFF_SCREEN_PX = 40;  // dim line stands off the part (× dim's standoffScale)
+export const STAGGER_SCREEN_PX = 26;   // extra standoff per stacked lane
+export const LEADER_SCREEN_PX = 36;    // R-leader length
+
+// World units per CSS pixel for a point at `dist` from the camera.
+export function worldPerPx(dist, fovDeg, viewportPx) {
+  return (2 * dist * Math.tan((fovDeg * Math.PI) / 360)) / viewportPx;
+}
+
+// Kept for compatibility with earlier callers/tests: the world height that
+// renders as `targetPx` on screen.
+export function labelWorldHeight(dist, fovDeg, viewportPx, targetPx = LABEL_SCREEN_PX) {
+  return targetPx * worldPerPx(dist, fovDeg, viewportPx);
+}
+
+// Default label painter: returns a canvas whose aspect the caller turns into
+// a plane. Pure DOM-canvas; swapped out in tests. Plain value text only —
+// the old param pill misattributed a set-level link to every label in the
+// set, so the dimension->control affordance is now the click itself (every
+// label click flashes the controls that drive the measurement).
+export function defaultPaintLabel({ text, palette }) {
+  const font = "700 96px ui-monospace, Menlo, monospace";
+  const c = document.createElement("canvas");
+  let ctx = c.getContext("2d");
+  ctx.font = font;
+  const wText = Math.ceil(ctx.measureText(text).width);
+  const PAD = 20;
+  c.width = wText + PAD * 2;
+  c.height = 128;
+  ctx = c.getContext("2d");
+  ctx.textAlign = "left";
+  ctx.textBaseline = "middle";
+  ctx.lineJoin = "round";
+  ctx.font = font;
+  ctx.strokeStyle = palette.halo; // halo so bare text reads on the part body
+  ctx.lineWidth = 12;
+  ctx.strokeText(text, PAD, c.height / 2);
+  ctx.fillStyle = palette.text;
+  ctx.fillText(text, PAD, c.height / 2);
+  return c;
+}
+
+export function createDimScene(viewer, { paintLabel = defaultPaintLabel } = {}) {
+  const group = new THREE.Group();
+  group.name = "pf-dims";
+  let attached = false;
+  let unregisterCapture = () => {};
+  function ensureAttached() {
+    if (attached) return true;
+    const parent = Object.values(viewer._subMeshes)[0]?.parent;
+    if (!parent) return false;
+    parent.add(group);
+    unregisterCapture = viewer.registerCanonicalCaptureHidden?.(group) ?? (() => {});
+    attached = true;
+    return true;
+  }
+
+  let theme = viewer.getTheme?.() ?? "dark";
+  const lineMats = {
+    static: new LineMaterial({ color: DIM_THEME[theme].static, linewidth: 1.5 }),
+    strong: new LineMaterial({ color: DIM_THEME[theme].strong, linewidth: 1.5 }),
+  };
+  const fillMats = {
+    static: new THREE.MeshBasicMaterial({ color: DIM_THEME[theme].static, side: THREE.DoubleSide }),
+    strong: new THREE.MeshBasicMaterial({ color: DIM_THEME[theme].strong, side: THREE.DoubleSide }),
+  };
+  for (const m of [...Object.values(lineMats), ...Object.values(fillMats)]) {
+    m.depthTest = false;
+    m.depthWrite = false; // overlay ink must not pollute the depth buffer
+    m.transparent = true; // draw in the late pass so depthTest:false lands on top
+  }
+
+  const matFor = (tier) => (tier === "static" ? "static" : "strong");
+
+  // Shared unit arrowhead: tip at the origin pointing +X, the narrow drafting
+  // ratio baked in; instances are oriented at build time (their in-plane basis
+  // never changes) and positioned + scaled per frame.
+  const unitArrowGeo = new THREE.BufferGeometry();
+  unitArrowGeo.setAttribute("position", new THREE.BufferAttribute(new Float32Array([
+    0, 0, 0, 1, ARROW_HALF_W, 0, 1, -ARROW_HALF_W, 0,
+  ]), 3));
+
+  const quatFromBasis = (x, y) => {
+    const z = new THREE.Vector3().crossVectors(x, y).normalize();
+    return new THREE.Quaternion().setFromRotationMatrix(new THREE.Matrix4().makeBasis(x, y, z));
+  };
+
+  function makeArrow(key, x, y, position) {
+    const mesh = new THREE.Mesh(unitArrowGeo, fillMats[key]);
+    mesh.quaternion.copy(quatFromBasis(x, y));
+    if (position) mesh.position.copy(position);
+    mesh.renderOrder = RENDER_ORDER_DIMS;
+    mesh.frustumCulled = false; // scaled/moved per frame; stale bounds must not cull it
+    group.add(mesh);
+    arrows.push(mesh);
+    return mesh;
+  }
+
+  // A LineSegments2 whose positions this module rewrites in place each frame.
+  function makeLine(key, segmentCount) {
+    const geo = new LineSegmentsGeometry();
+    geo.setPositions(new Array(segmentCount * 6).fill(0));
+    const line = new LineSegments2(geo, lineMats[key]);
+    line.renderOrder = RENDER_ORDER_DIMS;
+    line.frustumCulled = false;
+    group.add(line);
+    return line;
+  }
+
+  function writeSegments(line, arr) {
+    const data = line.geometry.attributes.instanceStart.data;
+    data.array.set(arr);
+    data.needsUpdate = true;
+  }
+
+  // ---- record bookkeeping ---------------------------------------------------
+  // labels: [{ mesh, baseQuat, mirrored, flipped, itemId, text, param }] —
+  // positions/scale are written per frame by the owning record in tick().
+  let labels = [];
+  let arrows = [];
+  let dimRecs = [];    // parametric linear dims
+  let diamRecs = [];   // ⌀ lines (static line, per-frame label anchor)
+  let leaderRecs = []; // R leaders
+  const textureCache = new Map(); // `${theme}|${text}` -> THREE.CanvasTexture
+
+  function labelTexture(text) {
+    const key = `${theme}|${text}`;
+    let tex = textureCache.get(key);
+    if (!tex) {
+      const canvas = paintLabel({ text, palette: DIM_THEME[theme] });
+      tex = new THREE.CanvasTexture(canvas);
+      tex.colorSpace = THREE.SRGBColorSpace;
+      tex.anisotropy = 8; // keep glancing-angle text legible
+      textureCache.set(key, tex);
+    }
+    return tex;
+  }
+
+  function buildLabel(l, itemId) {
+    const tex = labelTexture(l.text);
+    const img = tex.image;
+    const aspect = img && img.height ? img.width / img.height : 4;
+    // unit-height plane; tick() scales it to the screen-constant display height
+    const mesh = new THREE.Mesh(
+      new THREE.PlaneGeometry(aspect, 1),
+      new THREE.MeshBasicMaterial({ map: tex, transparent: true, depthTest: false, depthWrite: false, side: THREE.DoubleSide }),
+    );
+    mesh.renderOrder = RENDER_ORDER_LABELS;
+    mesh.frustumCulled = false;
+    const x = new THREE.Vector3(...l.x), y = new THREE.Vector3(...l.y);
+    mesh.quaternion.copy(quatFromBasis(x, y));
+    mesh.userData.pfDimItemId = itemId;
+    mesh.userData.pfDimValue = l.value ?? null;
+    group.add(mesh);
+    const rec = {
+      mesh, baseQuat: mesh.quaternion.clone(), mirrored: false, flipped: false,
+      itemId, text: l.text,
+    };
+    labels.push(rec);
+    return rec;
+  }
+
+  // ---- build / clear --------------------------------------------------------
+  function disposeChildren() {
+    for (const child of [...group.children]) {
+      group.remove(child);
+      if (child.geometry !== unitArrowGeo) child.geometry?.dispose?.(); // the unit arrow is shared
+      // label materials are per-mesh clones; textures live in the cache
+      if (child.material && !Object.values(lineMats).includes(child.material)
+          && !Object.values(fillMats).includes(child.material)) {
+        child.material.dispose?.();
+      }
+    }
+    labels = [];
+    arrows = [];
+    dimRecs = [];
+    diamRecs = [];
+    leaderRecs = [];
+  }
+
+  function update(drawings) {
+    if (!ensureAttached()) return;
+    disposeChildren();
+    for (const d of drawings) {
+      const key = matFor(d.tier);
+      for (const dim of d.dims ?? []) {
+        const dir = new THREE.Vector3(...dim.dir);
+        const ext = new THREE.Vector3(...dim.ext);
+        dimRecs.push({
+          pA: new THREE.Vector3(...dim.pA), pB: new THREE.Vector3(...dim.pB),
+          baseA: new THREE.Vector3(...dim.baseA), baseB: new THREE.Vector3(...dim.baseB),
+          ext, dir, lane: dim.lane ?? 0, standoffScale: dim.standoffScale ?? 1,
+          line: makeLine(key, 5), // ext A, ext B, dim line, tail A, tail B
+          arrowA: makeArrow(key, dir, ext),
+          arrowB: makeArrow(key, dir.clone().negate(), ext),
+          labelRec: buildLabel(dim.label, d.itemId),
+        });
+      }
+      for (const diam of d.diams ?? []) {
+        const rimA = new THREE.Vector3(...diam.rimA);
+        const rimB = new THREE.Vector3(...diam.rimB);
+        const du = new THREE.Vector3(...diam.du);
+        const dv = new THREE.Vector3(...diam.dv);
+        const line = makeLine(key, 1);
+        writeSegments(line, [rimA.x, rimA.y, rimA.z, rimB.x, rimB.y, rimB.z]); // static
+        makeArrow(key, du.clone().negate(), dv, rimA);
+        makeArrow(key, du, dv, rimB);
+        diamRecs.push({ rimA, du, labelRec: buildLabel(diam.label, d.itemId) });
+      }
+      for (const leader of d.leaders ?? []) {
+        const rim = new THREE.Vector3(...leader.rim);
+        const dir = new THREE.Vector3(...leader.dir);
+        const perp = new THREE.Vector3(...leader.perp);
+        leaderRecs.push({
+          rim, dir,
+          line: makeLine(key, 1),
+          arrow: makeArrow(key, dir, perp, rim),
+          labelRec: buildLabel(leader.label, d.itemId),
+        });
+      }
+    }
+    sweepTextureCache();
+  }
+
+  // Bound the texture cache to labels actually in use: continuous param
+  // dragging mints a fresh label text every frame, so without this the cache
+  // (one CanvasTexture each) would grow unboundedly across a session. Drop
+  // every entry not referenced by the labels just built; entries from a prior
+  // theme become unreferenced the moment setTheme() repaints (it fetches a
+  // new-theme texture on demand but doesn't dispose the old one, since it's
+  // still live if setTheme fires again before the next update) and are swept
+  // here on the next update(), never while still assigned to a live label.
+  function sweepTextureCache() {
+    const live = new Set(labels.map((L) => `${theme}|${L.text}`));
+    for (const [key, tex] of textureCache) {
+      if (live.has(key)) continue;
+      tex.dispose();
+      textureCache.delete(key);
+    }
+  }
+
+  // ---- per-frame assembly + readability flips -------------------------------
+  // Labels correct among four in-plane states so they never read mirrored or
+  // upside down: Ry(π) fixes viewing the plane from behind, Rz(π) fixes the
+  // reading direction. 0.08 deadband stops edge-on flicker.
+  const QY = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI);
+  const QZ = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 0, 1), Math.PI);
+  const _gq = new THREE.Quaternion();
+  const _wq = new THREE.Quaternion();
+  const _iq = new THREE.Quaternion();
+  const _n = new THREE.Vector3();
+  const _x = new THREE.Vector3();
+  const _wp = new THREE.Vector3();
+  const _toCam = new THREE.Vector3();
+  const _gp = new THREE.Vector3();
+  const _dA = new THREE.Vector3();
+  const _dB = new THREE.Vector3();
+  const _uA = new THREE.Vector3();
+  const _uB = new THREE.Vector3();
+  const _p = new THREE.Vector3();
+  const _seg = new Float32Array(30);
+  function tick() {
+    if (!attached || !group.children.length) return;
+    const el = viewer.domElement;
+    const w = el.clientWidth || 1, h = el.clientHeight || 1;
+    lineMats.static.resolution.set(w, h);
+    lineMats.strong.resolution.set(w, h);
+    // One shared reference distance — camera to the dim group's origin (the
+    // recentred model centre) — sizes the whole drawing.
+    group.getWorldPosition(_gp);
+    const dist = viewer.camera.position.distanceTo(_gp);
+    const wpp = worldPerPx(dist, viewer.camera.fov ?? 45, h);
+    if (wpp > 0) {
+      const hStar = LABEL_SCREEN_PX * wpp;
+      const aw = ARROW_SCREEN_PX * wpp;
+      const gap = GAP_SCREEN_PX * wpp;
+      const tail = OVERSHOOT_SCREEN_PX * wpp;
+      for (const R of dimRecs) {
+        const off = (STANDOFF_SCREEN_PX * R.standoffScale + R.lane * STAGGER_SCREEN_PX) * wpp;
+        _dA.copy(R.baseA).addScaledVector(R.ext, off);
+        _dB.copy(R.baseB).addScaledVector(R.ext, off);
+        _uA.copy(_dA).sub(R.pA);
+        if (_uA.lengthSq() > 1e-12) _uA.normalize(); else _uA.copy(R.ext);
+        _uB.copy(_dB).sub(R.pB);
+        if (_uB.lengthSq() > 1e-12) _uB.normalize(); else _uB.copy(R.ext);
+        let i = 0;
+        _p.copy(R.pA).addScaledVector(_uA, gap);
+        _seg[i++] = _p.x; _seg[i++] = _p.y; _seg[i++] = _p.z;
+        _seg[i++] = _dA.x; _seg[i++] = _dA.y; _seg[i++] = _dA.z;
+        _p.copy(R.pB).addScaledVector(_uB, gap);
+        _seg[i++] = _p.x; _seg[i++] = _p.y; _seg[i++] = _p.z;
+        _seg[i++] = _dB.x; _seg[i++] = _dB.y; _seg[i++] = _dB.z;
+        _seg[i++] = _dA.x; _seg[i++] = _dA.y; _seg[i++] = _dA.z;
+        _seg[i++] = _dB.x; _seg[i++] = _dB.y; _seg[i++] = _dB.z;
+        _p.copy(_dA).addScaledVector(_uA, tail);
+        _seg[i++] = _dA.x; _seg[i++] = _dA.y; _seg[i++] = _dA.z;
+        _seg[i++] = _p.x; _seg[i++] = _p.y; _seg[i++] = _p.z;
+        _p.copy(_dB).addScaledVector(_uB, tail);
+        _seg[i++] = _dB.x; _seg[i++] = _dB.y; _seg[i++] = _dB.z;
+        _seg[i++] = _p.x; _seg[i++] = _p.y; _seg[i++] = _p.z;
+        writeSegments(R.line, _seg);
+        R.arrowA.position.copy(_dA);
+        R.arrowB.position.copy(_dB);
+        R.labelRec.mesh.position
+          .copy(_dA).add(_dB).multiplyScalar(0.5)
+          .addScaledVector(R.ext, 0.85 * hStar);
+      }
+      for (const R of diamRecs) {
+        R.labelRec.mesh.position.copy(R.rimA).addScaledVector(R.du, 0.85 * hStar);
+      }
+      for (const R of leaderRecs) {
+        const len = LEADER_SCREEN_PX * wpp;
+        _p.copy(R.rim).addScaledVector(R.dir, gap);
+        _dA.copy(R.rim).addScaledVector(R.dir, gap + len);
+        writeSegments(R.line, [_p.x, _p.y, _p.z, _dA.x, _dA.y, _dA.z]);
+        R.labelRec.mesh.position.copy(_dA).addScaledVector(R.dir, 0.85 * hStar);
+      }
+      for (const a of arrows) a.scale.setScalar(aw);
+      for (const L of labels) L.mesh.scale.setScalar(hStar);
+    }
+    group.getWorldQuaternion(_gq);
+    _iq.copy(viewer.camera.quaternion).invert();
+    for (const L of labels) {
+      _wq.copy(_gq).multiply(L.baseQuat);
+      if (L.mirrored) _wq.multiply(QY);
+      if (L.flipped) _wq.multiply(QZ);
+      L.mesh.getWorldPosition(_wp);
+      _toCam.copy(viewer.camera.position).sub(_wp).normalize();
+      _n.set(0, 0, 1).applyQuaternion(_wq);
+      const facing = _n.dot(_toCam);
+      if (Math.abs(facing) > 0.08 && facing < 0) {
+        L.mirrored = !L.mirrored;
+        _wq.multiply(QY);
+      }
+      _x.set(1, 0, 0).applyQuaternion(_wq).applyQuaternion(_iq);
+      if (Math.abs(_x.x) > 0.08 && _x.x < 0) L.flipped = !L.flipped;
+      L.mesh.quaternion.copy(L.baseQuat);
+      if (L.mirrored) L.mesh.quaternion.multiply(QY);
+      if (L.flipped) L.mesh.quaternion.multiply(QZ);
+    }
+  }
+
+  // ---- label picking --------------------------------------------------------
+  const raycaster = new THREE.Raycaster();
+  const _ndc = new THREE.Vector2();
+  // Returns { itemId, value } for the label under the pointer (value = the
+  // measured number the label shows, for exact-match control focusing), or
+  // null when no label is hit.
+  function pickLabel(clientX, clientY) {
+    if (!attached || !labels.length) return null;
+    const r = viewer.domElement.getBoundingClientRect();
+    _ndc.set(((clientX - r.left) / r.width) * 2 - 1, -(((clientY - r.top) / r.height) * 2 - 1));
+    raycaster.setFromCamera(_ndc, viewer.camera);
+    const hit = raycaster.intersectObjects(labels.map((L) => L.mesh), false)[0];
+    return hit ? { itemId: hit.object.userData.pfDimItemId, value: hit.object.userData.pfDimValue ?? null } : null;
+  }
+
+  // ---- theme ----------------------------------------------------------------
+  function setTheme(mode) {
+    if (!DIM_THEME[mode] || mode === theme) return;
+    theme = mode;
+    lineMats.static.color.set(DIM_THEME[theme].static);
+    lineMats.strong.color.set(DIM_THEME[theme].strong);
+    fillMats.static.color.set(DIM_THEME[theme].static);
+    fillMats.strong.color.set(DIM_THEME[theme].strong);
+    // repaint labels: new-theme textures come from the cache or a fresh paint
+    for (const L of labels) {
+      L.mesh.material.map = labelTexture(L.text);
+      L.mesh.material.needsUpdate = true;
+    }
+  }
+
+  function clear() { disposeChildren(); }
+
+  function dispose() {
+    disposeChildren();
+    unregisterCapture();
+    if (attached) group.parent?.remove(group);
+    attached = false;
+    for (const m of [...Object.values(lineMats), ...Object.values(fillMats)]) m.dispose();
+    unitArrowGeo.dispose();
+    for (const t of textureCache.values()) t.dispose();
+    textureCache.clear();
+  }
+
+  return { update, tick, pickLabel, setTheme, clear, group, dispose };
+}

package/src/framework/measure/feature-dims.js

@@ -0,0 +1,258 @@
+// PURE dimension engine for measurement mode: a feature's triangle subset ->
+// a MeasureSpec (plane / cylinder / bbox). No three.js, no DOM, no kernel —
+// plain typed arrays, same discipline as oracle/mesh.js. Handles both indexed
+// (OCCT) and non-indexed (Manifold) payloads.
+//
+// Spec shapes (anchors are 3D points in the delivered geometry's own frame —
+// the orchestrator projects them through mesh.matrixWorld, which is what makes
+// dims ride the pose fast path and animations):
+//   plane    { kind, values: {width, height},            anchors: {width:{a,b}, height:{a,b}, normal} }
+//   cylinder { kind, values: {diameter, depth, partial}, anchors: {center, axis, top, bottom, rimDir} }
+//   bbox     { kind, values: {w, d, h},                  anchors: {min, max} }
+
+const COS_3DEG = 0.99863;      // same axis-snap threshold as selection/resolve.js
+const PLANAR_COS = 0.999999;   // ~1.4e-3 rad: all normals agree -> planar
+const AXIS_DOT_MAX = 0.05;     // wall normals ⊥ axis within ~3°
+const RADIUS_TOL = 0.02;       // radial residual: 2% of radius
+const FULL_ARC_DEG = 300;      // coverage below this reads R, not ⌀
+
+const q2 = (x) => { const r = Math.round(x * 100) / 100; return r === 0 ? 0 : r; };
+export const fmtMm = (v) => v.toFixed(2);
+
+const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+const scale = (a, s) => [a[0] * s, a[1] * s, a[2] * s];
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const cross = (a, b) => [
+  a[1] * b[2] - a[2] * b[1],
+  a[2] * b[0] - a[0] * b[2],
+  a[0] * b[1] - a[1] * b[0],
+];
+const norm = (a) => {
+  const l = Math.hypot(a[0], a[1], a[2]);
+  return l > 0 ? [a[0] / l, a[1] / l, a[2] / l] : [0, 0, 0];
+};
+
+// Iterate the triangles of one feature: yields [a, b, c] vertex triples.
+function* featureTris({ positions, indices, featureIds }, featureId) {
+  const vert = indices
+    ? (t, v) => { const i = indices[t * 3 + v] * 3; return [positions[i], positions[i + 1], positions[i + 2]]; }
+    : (t, v) => { const i = (t * 3 + v) * 3; return [positions[i], positions[i + 1], positions[i + 2]]; };
+  for (let t = 0; t < featureIds.length; t++) {
+    if (featureIds[t] !== featureId) continue;
+    yield [vert(t, 0), vert(t, 1), vert(t, 2)];
+  }
+}
+
+export function unionBounds(list) {
+  return 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] },
+  );
+}
+
+export function bboxSpec(min, max) {
+  return {
+    kind: "bbox",
+    values: { w: q2(max[0] - min[0]), d: q2(max[1] - min[1]), h: q2(max[2] - min[2]) },
+    anchors: { min: [...min], max: [...max] },
+  };
+}
+
+function vertexBounds(tris) {
+  const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
+  for (const tri of tris) for (const p of tri) for (let i = 0; i < 3; i++) {
+    if (p[i] < min[i]) min[i] = p[i];
+    if (p[i] > max[i]) max[i] = p[i];
+  }
+  return { min, max };
+}
+
+// Axis-snap a unit normal (COS_3DEG idiom from selection/resolve.js).
+function snapAxis(n) {
+  let ai = 0;
+  if (Math.abs(n[1]) > Math.abs(n[ai])) ai = 1;
+  if (Math.abs(n[2]) > Math.abs(n[ai])) ai = 2;
+  if (Math.abs(n[ai]) < COS_3DEG) return null;
+  const axis = [0, 0, 0];
+  axis[ai] = n[ai] > 0 ? 1 : -1;
+  return axis;
+}
+
+function planeSpec(tris, normals) {
+  // area-weighted mean normal
+  let acc = [0, 0, 0];
+  for (const { n, area } of normals) acc = add(acc, scale(n, area));
+  const mean = norm(acc);
+  for (const { n } of normals) if (dot(n, mean) < PLANAR_COS) return null;
+
+  // Basis: axis-snapped normal -> the other two GLOBAL axes (a box face reads
+  // W×H, not a PCA-tilted pair). Otherwise: dominant in-plane edge direction.
+  const snapped = snapAxis(mean);
+  let u, v;
+  if (snapped) {
+    const ai = snapped.findIndex((c) => c !== 0);
+    u = [0, 0, 0]; u[(ai + 1) % 3] = 1;
+    v = [0, 0, 0]; v[(ai + 2) % 3] = 1;
+  } else {
+    let best = null, bestLen = -1;
+    for (const [a, b, c] of tris) {
+      for (const e of [sub(b, a), sub(c, b), sub(a, c)]) {
+        const l = Math.hypot(e[0], e[1], e[2]);
+        if (l > bestLen) { bestLen = l; best = e; }
+      }
+    }
+    u = norm(sub(best, scale(mean, dot(best, mean)))); // project into plane
+    v = norm(cross(mean, u));
+  }
+
+  const c0 = tris[0][0];
+  let uMin = Infinity, uMax = -Infinity, vMin = Infinity, vMax = -Infinity;
+  for (const tri of tris) for (const p of tri) {
+    const d = sub(p, c0);
+    const uu = dot(d, u), vv = dot(d, v);
+    if (uu < uMin) uMin = uu; if (uu > uMax) uMax = uu;
+    if (vv < vMin) vMin = vv; if (vv > vMax) vMax = vv;
+  }
+  const corner = (uu, vv) => add(c0, add(scale(u, uu), scale(v, vv)));
+  return {
+    kind: "plane",
+    values: { width: q2(uMax - uMin), height: q2(vMax - vMin) },
+    anchors: {
+      width: { a: corner(uMin, vMin), b: corner(uMax, vMin) },
+      height: { a: corner(uMax, vMin), b: corner(uMax, vMax) },
+      normal: snapped ?? mean.map(q2),
+    },
+  };
+}
+
+function cylinderSpec(tris, normals) {
+  // Candidate axes from cross products of well-separated normal pairs, scored
+  // by how much triangle area agrees the candidate is ⊥ to it. A single seeded
+  // pair is not robust: when a feature carries wall AND cap triangles, a
+  // wall×cap pair yields a tangent to the cylinder, not its axis.
+  const stride = Math.max(1, Math.floor(normals.length / 16));
+  const sample = [];
+  for (let i = 0; i < normals.length; i += stride) sample.push(normals[i].n);
+  let axis = null, bestScore = 0;
+  for (let i = 0; i < sample.length; i++) {
+    for (let j = i + 1; j < sample.length; j++) {
+      if (Math.abs(dot(sample[i], sample[j])) > 0.95) continue;
+      const cand = norm(cross(sample[i], sample[j]));
+      if (cand[0] === 0 && cand[1] === 0 && cand[2] === 0) continue;
+      let score = 0;
+      for (const { n: tn, area } of normals) {
+        if (Math.abs(dot(tn, cand)) <= AXIS_DOT_MAX) score += area;
+      }
+      if (score > bestScore) { bestScore = score; axis = cand; }
+    }
+  }
+  if (!axis) return null;
+
+  // Wall triangles only (a labeled boss's end caps attribute to the same
+  // feature — their normals are along the axis; exclude them from the fit).
+  const wallVerts = [];
+  for (let t = 0; t < tris.length; t++) {
+    if (Math.abs(dot(normals[t].n, axis)) > AXIS_DOT_MAX) continue;
+    wallVerts.push(...tris[t]);
+  }
+  if (wallVerts.length < 9) return null; // fewer than 3 wall triangles: not a cylinder
+
+  // Circle fit (Kåsa least-squares) in the plane ⊥ axis: for a partial arc
+  // the vertex centroid is NOT on the axis, so a centroid-based radius check
+  // wrongly rejects arcs. Solve x²+y² = Ax + By + C over the projected wall
+  // vertices; center (A/2, B/2), r = sqrt(C + |center|²).
+  const e = Math.abs(axis[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+  const uBasis = norm(cross(axis, e));
+  const vBasis = cross(axis, uBasis);
+  const p0 = wallVerts[0];
+  const pts = wallVerts.map((p) => {
+    const d = sub(p, p0);
+    return [dot(d, uBasis), dot(d, vBasis)];
+  });
+  let sxx = 0, sxy = 0, syy = 0, sx = 0, sy = 0, sxz = 0, syz = 0, sz = 0;
+  for (const [x, y] of pts) {
+    const z = x * x + y * y;
+    sxx += x * x; sxy += x * y; syy += y * y; sx += x; sy += y;
+    sxz += x * z; syz += y * z; sz += z;
+  }
+  const n = pts.length;
+  // Cramer's rule on the 3x3 normal equations [[sxx,sxy,sx],[sxy,syy,sy],[sx,sy,n]] · [A,B,C]ᵀ = [sxz,syz,sz]ᵀ
+  const det = sxx * (syy * n - sy * sy) - sxy * (sxy * n - sy * sx) + sx * (sxy * sy - syy * sx);
+  if (Math.abs(det) < 1e-12) return null;
+  const A = (sxz * (syy * n - sy * sy) - sxy * (syz * n - sy * sz) + sx * (syz * sy - syy * sz)) / det;
+  const B = (sxx * (syz * n - sy * sz) - sxz * (sxy * n - sy * sx) + sx * (sxy * sz - syz * sx)) / det;
+  const Cc = (sxx * (syy * sz - syz * sy) - sxy * (sxy * sz - syz * sx) + sxz * (sxy * sy - syy * sx)) / det;
+  const cx = A / 2, cy = B / 2;
+  const rSquared = Cc + cx * cx + cy * cy;
+  if (rSquared <= 0) return null;
+  const r = Math.sqrt(rSquared);
+  // Axis point in 3D: the fitted center lifted back out of the projection plane.
+  const c = add(p0, add(scale(uBasis, cx), scale(vBasis, cy)));
+  const radial = (p) => { const d = sub(p, c); return sub(d, scale(axis, dot(d, axis))); };
+  for (const p of wallVerts) {
+    const ri = Math.hypot(...radial(p));
+    if (Math.abs(ri - r) > Math.max(RADIUS_TOL * r, 1e-6)) return null;
+  }
+
+  // Depth from ALL feature vertices (caps included) along the axis.
+  let tMin = Infinity, tMax = -Infinity;
+  for (const tri of tris) for (const p of tri) {
+    const t = dot(sub(p, c), axis);
+    if (t < tMin) tMin = t; if (t > tMax) tMax = t;
+  }
+
+  // Angular coverage of wall vertices -> ⌀ vs R notation.
+  const u = norm(radial(wallVerts[0]));
+  const v = cross(axis, u);
+  const angles = wallVerts
+    .map((p) => { const rd = radial(p); return Math.atan2(dot(rd, v), dot(rd, u)); })
+    .sort((a, b) => a - b);
+  let maxGap = 2 * Math.PI + angles[0] - angles[angles.length - 1];
+  let gapEnd = angles[0]; // angle where the covered span begins (after the largest gap)
+  for (let i = 1; i < angles.length; i++) {
+    const g = angles[i] - angles[i - 1];
+    if (g > maxGap) { maxGap = g; gapEnd = angles[i]; }
+  }
+  const coverageDeg = 360 - (maxGap * 180) / Math.PI;
+  // Radial direction at the angular midpoint of the covered span — where the
+  // wall actually is; the placer hangs R-leaders (and degenerate-view ⌀ dims)
+  // off it so they always spring from real surface. For a full circle
+  // (maxGap ~ the seam between last and first sample) this still yields a
+  // stable default direction.
+  const midAngle = gapEnd + (2 * Math.PI - maxGap) / 2;
+  const rimDir = norm(add(scale(u, Math.cos(midAngle)), scale(v, Math.sin(midAngle))));
+
+  const snapped = snapAxis(axis);
+  const ax = snapped ?? axis.map(q2);
+  return {
+    kind: "cylinder",
+    values: { diameter: q2(2 * r), depth: q2(tMax - tMin), partial: coverageDeg < FULL_ARC_DEG },
+    anchors: {
+      center: add(c, scale(axis, (tMin + tMax) / 2)).map(q2),
+      axis: ax,
+      bottom: add(c, scale(axis, tMin)).map(q2),
+      top: add(c, scale(axis, tMax)).map(q2),
+      rimDir: rimDir.map(q2),
+    },
+  };
+}
+
+export function classifyFeature(mesh, featureId) {
+  const tris = [...featureTris(mesh, featureId)];
+  if (tris.length === 0) return null;
+  const normals = tris.map(([a, b, c]) => {
+    const n = cross(sub(b, a), sub(c, a));
+    const area = Math.hypot(n[0], n[1], n[2]) / 2;
+    return { n: norm(n), area };
+  });
+  const plane = planeSpec(tris, normals);
+  if (plane) return plane;
+  const cyl = cylinderSpec(tris, normals);
+  if (cyl) return cyl;
+  const { min, max } = vertexBounds(tris);
+  return bboxSpec(min, max);
+}