brep-io-kernel 1.0.0

package/src/tests/test_offsetShellGrouping.js

@@ -0,0 +1,85 @@
+import { Cylinder } from '../BREP/primitives.js';
+import { OffsetShellSolid } from '../BREP/OffsetShellSolid.js';
+
+/**
+ * Ensure offset-shell face grouping keeps the new caps aligned with their source faces.
+ * We offset a simple analytic cylinder inward and measure how far the labelled cap
+ * triangles drift away from the expected offset plane. A large deviation indicates
+ * that triangles from the opposite side of the solid were mis-bucketed.
+ */
+export async function test_offsetShellGrouping(partHistory) {
+  const radius = 2;
+  const height = 4;
+  const resolution = 16;
+  const offsetDistance = -1;
+
+  const source = new Cylinder({ radius, height, resolution, name: 'CYL' });
+  const shell = OffsetShellSolid.generate(source, offsetDistance, {
+    newSolidName: 'CYL_shell',
+    featureId: 'TEST',
+  });
+
+  const faces = shell.getFaces(false);
+  const topFaceName = 'CYL_shell_CYL_T';
+  const bottomFaceName = 'CYL_shell_CYL_B';
+
+  const topFace = faces.find((f) => f.faceName === topFaceName);
+  const bottomFace = faces.find((f) => f.faceName === bottomFaceName);
+
+  if (!topFace) {
+    throw new Error(`Offset shell test could not find expected top face "${topFaceName}".`);
+  }
+  if (!bottomFace) {
+    throw new Error(`Offset shell test could not find expected bottom face "${bottomFaceName}".`);
+  }
+  if (!Array.isArray(topFace.triangles) || !topFace.triangles.length) {
+    throw new Error(`Offset shell top face "${topFaceName}" has no triangles to validate.`);
+  }
+  if (!Array.isArray(bottomFace.triangles) || !bottomFace.triangles.length) {
+    throw new Error(`Offset shell bottom face "${bottomFaceName}" has no triangles to validate.`);
+  }
+
+  const expectedDot = offsetDistance;
+  const tolerance = 0.35; // allow a generous margin for marching-cubes artefacts
+
+  const centroidY = (tri) => (tri.p1[1] + tri.p2[1] + tri.p3[1]) / 3;
+
+  const checkFaceOffsets = (face, normal, planePoint, label) => {
+    const [nx, ny, nz] = normal;
+    const [px, py, pz] = planePoint;
+    let worstDeviation = 0;
+
+    for (const tri of face.triangles) {
+      const cx = (tri.p1[0] + tri.p2[0] + tri.p3[0]) / 3;
+      const cy = centroidY(tri);
+      const cz = (tri.p1[2] + tri.p2[2] + tri.p3[2]) / 3;
+      const dot = nx * (cx - px) + ny * (cy - py) + nz * (cz - pz);
+      const deviation = Math.abs(dot - expectedDot);
+      if (deviation > worstDeviation) worstDeviation = deviation;
+    }
+
+    if (worstDeviation > tolerance) {
+      const faceRange = face.triangles.reduce(
+        (acc, tri) => {
+          const cy = centroidY(tri);
+          if (cy < acc.min) acc.min = cy;
+          if (cy > acc.max) acc.max = cy;
+          return acc;
+        },
+        { min: Infinity, max: -Infinity },
+      );
+      throw new Error(
+        [
+          `Offset shell ${label} face deviated ${worstDeviation.toFixed(3)} (tolerance ${tolerance}).`,
+          `Centroid Y range: ${faceRange.min.toFixed(3)} .. ${faceRange.max.toFixed(3)}`,
+          `Triangles: ${face.triangles.length}`,
+        ].join(' '),
+      );
+    }
+  };
+
+  checkFaceOffsets(topFace, [0, 1, 0], [0, height, 0], 'top');
+  checkFaceOffsets(bottomFace, [0, -1, 0], [0, 0, 0], 'bottom');
+
+  return partHistory;
+}

package/src/tests/test_plane.js

@@ -0,0 +1,4 @@
+export async function test_plane(partHistory) {
+    await partHistory.newFeature("PLANE");
+    return partHistory;
+}

package/src/tests/test_primitiveCone.js

@@ -0,0 +1,11 @@
+
+
+export async function test_primitiveCone(partHistory) {
+    const cone = await partHistory.newFeature("P.CO");
+    cone.inputParams.radiusTop = 3;
+    cone.inputParams.radiusBottom = .5;
+    cone.inputParams.height = 5.2;
+    cone.inputParams.resolution = 20;
+
+    return partHistory;
+}

package/src/tests/test_primitiveCube.js

@@ -0,0 +1,7 @@
+export async function test_primitiveCube(partHistory) {
+    const cube = await partHistory.newFeature("P.CU");
+    cube.inputParams.sizeX = 5;
+    cube.inputParams.sizeY = 10;
+    cube.inputParams.sizeZ = 15;
+    return partHistory;
+}

package/src/tests/test_primitiveCylinder.js

@@ -0,0 +1,8 @@
+export async function test_primitiveCylinder(partHistory) {
+    const cylinder = await partHistory.newFeature("P.CY");
+    cylinder.inputParams.radius = 1;
+    cylinder.inputParams.height = 5;
+    cylinder.inputParams.resolution = 30;
+
+    return partHistory;
+}

package/src/tests/test_primitivePyramid.js

@@ -0,0 +1,9 @@
+export async function test_primitivePyramid(partHistory) {
+    const pyramid = await partHistory.newFeature("P.PY");
+    pyramid.inputParams.baseSideLength = 5;
+    pyramid.inputParams.height = 8;
+    pyramid.inputParams.sides = 4;
+
+    return partHistory;
+}
+

package/src/tests/test_primitiveSphere.js

@@ -0,0 +1,17 @@
+
+export async function test_primitiveSphere(partHistory) {
+    const sphere = await partHistory.newFeature("P.S");
+    sphere.inputParams.radius = 5;
+    sphere.inputParams.resolution =10;
+
+    return partHistory;
+}
+
+
+
+
+
+
+
+
+

package/src/tests/test_primitiveTorus.js

@@ -0,0 +1,21 @@
+
+
+export async function test_primitiveTorus(partHistory) {
+    const torus = await partHistory.newFeature("P.T");
+    torus.inputParams.majorRadius = 20;
+    torus.inputParams.tubeRadius = 5;
+    torus.inputParams.resolution = 10;
+    // arc with 90 degrees
+    torus.inputParams.arc =  300;
+
+
+    const torus2 = await partHistory.newFeature("P.T");
+    torus2.inputParams.majorRadius = 5;
+    torus2.inputParams.tubeRadius = 3;
+    torus2.inputParams.resolution = 30;
+    // arc with 90 degrees
+    torus2.inputParams.arc =  360;
+
+    
+    return partHistory;
+}

package/src/tests/test_pushFace.js

@@ -0,0 +1,126 @@
+const CUBE_ID = 'PUSHFACE_CUBE';
+const CYLINDER_ID = 'PUSHFACE_CYL';
+const BOX_SIZE = 6;
+const CYL_RADIUS = 1.25;
+const PUSH_DISTANCE = 0.5;
+
+export async function test_pushFace(partHistory) {
+  const cube = await partHistory.newFeature("P.CU");
+  cube.inputParams.id = CUBE_ID;
+  cube.inputParams.sizeX = BOX_SIZE;
+  cube.inputParams.sizeY = BOX_SIZE;
+  cube.inputParams.sizeZ = BOX_SIZE;
+
+  const cyl = await partHistory.newFeature("P.CY");
+  cyl.inputParams.id = CYLINDER_ID;
+  cyl.inputParams.radius = CYL_RADIUS;
+  cyl.inputParams.height = BOX_SIZE;
+  cyl.inputParams.transform = {
+    position: [BOX_SIZE / 2, 0, BOX_SIZE / 2],
+    rotationEuler: [0, 0, 0],
+    scale: [1, 1, 1],
+  };
+
+  const booleanFeature = await partHistory.newFeature("B");
+  booleanFeature.inputParams.targetSolid = cube.inputParams.featureID;
+  booleanFeature.inputParams.boolean = {
+    operation: "SUBTRACT",
+    targets: [cyl.inputParams.featureID],
+  };
+
+  return partHistory;
+}
+
+function measureRadialExtent(solid, faceName, centerX, centerZ) {
+  if (typeof solid.getFace !== 'function') throw new Error('Solid missing getFace()');
+  const face = solid.getFace(faceName);
+  if (!Array.isArray(face) || face.length === 0) throw new Error(`Face "${faceName}" not found on solid ${solid.name || ''}`);
+
+  const seen = new Set();
+  const radii = [];
+  for (const tri of face) {
+    for (const p of [tri.p1, tri.p2, tri.p3]) {
+      if (!Array.isArray(p) || p.length < 3) continue;
+      const key = `${p[0]},${p[1]},${p[2]}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const x = p[0];
+      const z = p[2];
+      radii.push(Math.hypot(x - centerX, z - centerZ));
+    }
+  }
+  if (!radii.length) throw new Error(`No vertices collected for face "${faceName}"`);
+  const sum = radii.reduce((a, b) => a + b, 0);
+  const avg = sum / radii.length;
+  const min = Math.min(...radii);
+  const max = Math.max(...radii);
+  return { avg, min, max };
+}
+
+function estimateRadialNormalSign(solid, faceName, centerX, centerZ) {
+  const face = solid.getFace(faceName);
+  if (!Array.isArray(face) || face.length === 0) return 0;
+
+  let sum = 0;
+  for (const tri of face) {
+    if (!Array.isArray(tri.p1) || !Array.isArray(tri.p2) || !Array.isArray(tri.p3)) continue;
+    const ax = tri.p1[0], ay = tri.p1[1], az = tri.p1[2];
+    const bx = tri.p2[0], by = tri.p2[1], bz = tri.p2[2];
+    const cx = tri.p3[0], cy = tri.p3[1], cz = tri.p3[2];
+    const ux = bx - ax, uy = by - ay, uz = bz - az;
+    const vx = cx - ax, vy = cy - ay, vz = cz - az;
+    const nx = uy * vz - uz * vy;
+    const nz = ux * vy - uy * vx;
+    const mx = (ax + bx + cx) / 3;
+    const mz = (az + bz + cz) / 3;
+    const rx = mx - centerX;
+    const rz = mz - centerZ;
+    sum += rx * nx + rz * nz;
+  }
+  if (sum === 0) return 0;
+  return sum > 0 ? 1 : -1;
+}
+
+export async function afterRun_pushFace(partHistory) {
+  const solids = (partHistory.scene?.children || []).filter(o => o?.type === 'SOLID');
+  if (!solids.length) throw new Error('[pushFace] No solids created');
+
+  const solid = solids[0];
+  const cavityFace = `${CYLINDER_ID}_S`;
+  const center = { x: BOX_SIZE / 2, z: BOX_SIZE / 2 };
+
+  const baseline = measureRadialExtent(solid, cavityFace, center.x, center.z);
+  const inwardTest = solid.clone();
+  const control = measureRadialExtent(inwardTest, cavityFace, center.x, center.z);
+
+  solid.pushFace(cavityFace, PUSH_DISTANCE);
+  const pushedOut = measureRadialExtent(solid, cavityFace, center.x, center.z);
+
+  inwardTest.pushFace(cavityFace, -PUSH_DISTANCE);
+  const pushedIn = measureRadialExtent(inwardTest, cavityFace, center.x, center.z);
+
+  const normalSign = estimateRadialNormalSign(solid, cavityFace, center.x, center.z);
+  const tol = 1e-6;
+  if (normalSign === 0) {
+    const outDelta = pushedOut.avg - baseline.avg;
+    const inDelta = pushedIn.avg - control.avg;
+    const opposite = (outDelta > tol && inDelta < -tol) || (outDelta < -tol && inDelta > tol);
+    if (!opposite) {
+      throw new Error(`[pushFace] Expected opposite radial motion, got ${outDelta} and ${inDelta}`);
+    }
+  } else if (normalSign > 0) {
+    if (!(pushedOut.avg > baseline.avg + tol && pushedOut.min > baseline.min + tol / 10)) {
+      throw new Error(`[pushFace] Positive distance failed to move face outward (avg ${baseline.avg} → ${pushedOut.avg})`);
+    }
+    if (!(pushedIn.avg < control.avg - tol && pushedIn.max < control.max - tol / 10)) {
+      throw new Error(`[pushFace] Negative distance failed to move face inward (avg ${control.avg} → ${pushedIn.avg})`);
+    }
+  } else {
+    if (!(pushedOut.avg < baseline.avg - tol && pushedOut.max < baseline.max - tol / 10)) {
+      throw new Error(`[pushFace] Positive distance failed to move face inward (avg ${baseline.avg} → ${pushedOut.avg})`);
+    }
+    if (!(pushedIn.avg > control.avg + tol && pushedIn.min > control.min + tol / 10)) {
+      throw new Error(`[pushFace] Negative distance failed to move face outward (avg ${control.avg} → ${pushedIn.avg})`);
+    }
+  }
+}

package/src/tests/test_sheetMetalContourFlange.js

@@ -0,0 +1,125 @@
+/**
+ * Test for Sheet Metal Contour Flange geometry generation
+ * Validates that the feature correctly creates sweep profiles and geometries
+ */
+
+export async function test_SheetMetalContourFlange_Basic(partHistory) {
+  console.log("[TEST] Starting Sheet Metal Contour Flange basic test");
+
+  // Create a simple L-shaped sketch path
+  const plane = await partHistory.newFeature("P");
+  plane.inputParams.orientation = "XY"; // XY plane at Z=0
+
+  const sketch = await partHistory.newFeature("S");
+  sketch.inputParams.sketchPlane = plane.inputParams.featureID;
+
+  // Define L-shaped path: start at origin, go right 20 units, then up 15 units
+  sketch.persistentData.sketch = {
+    points: [
+      { id: 0, x: 0, y: 0, fixed: true },     // Origin
+      { id: 1, x: 20, y: 0, fixed: false },  // Right 20 units
+      { id: 2, x: 20, y: 15, fixed: false }, // Up 15 units
+    ],
+    geometries: [
+      { id: 100, type: "line", points: [0, 1], construction: false }, // Horizontal segment
+      { id: 101, type: "line", points: [1, 2], construction: false }, // Vertical segment
+    ],
+    constraints: [
+      { id: 0, type: "⏚", points: [0] }, // Ground point 0
+    ],
+  };
+
+  // Create the contour flange
+  const contourFlange = await partHistory.newFeature("SM.CF");
+  contourFlange.inputParams.path = [sketch.inputParams.featureID];
+  contourFlange.inputParams.distance = 10;    // 10 units wide
+  contourFlange.inputParams.thickness = 2;    // 2 units thick
+  contourFlange.inputParams.bendRadius = 1;   // 1 unit bend radius
+  contourFlange.inputParams.sheetSide = "left";
+  contourFlange.inputParams.consumePathSketch = false; // Keep sketch for inspection
+
+  console.log("[TEST] Contour flange created:", contourFlange.inputParams);
+
+  return partHistory;
+}
+
+export async function test_SheetMetalContourFlange_StraightLine(partHistory) {
+  console.log("[TEST] Starting Sheet Metal Contour Flange straight line test");
+
+  // Create a simple straight line sketch
+  const plane = await partHistory.newFeature("P");
+  plane.inputParams.orientation = "XY";
+
+  const sketch = await partHistory.newFeature("S");
+  sketch.inputParams.sketchPlane = plane.inputParams.featureID;
+
+  // Define straight line path
+  sketch.persistentData.sketch = {
+    points: [
+      { id: 0, x: 0, y: 0, fixed: true },
+      { id: 1, x: 30, y: 0, fixed: false },
+    ],
+    geometries: [
+      { id: 100, type: "line", points: [0, 1], construction: false },
+    ],
+    constraints: [
+      { id: 0, type: "⏚", points: [0] },
+    ],
+  };
+
+  // Create the contour flange
+  const contourFlange = await partHistory.newFeature("SM.CF");
+  contourFlange.inputParams.path = [sketch.inputParams.featureID];
+  contourFlange.inputParams.distance = 5;
+  contourFlange.inputParams.thickness = 1;
+  contourFlange.inputParams.bendRadius = 0; // No bends for straight line
+  contourFlange.inputParams.sheetSide = "right";
+  contourFlange.inputParams.consumePathSketch = false;
+
+  console.log("[TEST] Straight line contour flange created");
+
+  return partHistory;
+}
+
+function findContourFlangeFeature(partHistory) {
+  const entry = partHistory.features.find((f) => f?.type === "SM.CF");
+  if (!entry) throw new Error("Contour flange feature missing from history");
+  const featureId = entry?.inputParams?.featureID;
+  if (!featureId) throw new Error("Contour flange feature missing featureID");
+  return featureId;
+}
+
+function collectContourFlangeSolids(partHistory, featureId) {
+  const children = Array.isArray(partHistory.scene?.children) ? partHistory.scene.children : [];
+  return children.filter((obj) => {
+    if (!obj || obj.type !== "SOLID") return false;
+    if (obj?.owningFeatureID && String(obj.owningFeatureID) === String(featureId)) return true;
+    return !!(obj?.name && obj.name.includes(featureId));
+  });
+}
+
+function validateContourFlangeGeometry(partHistory, label) {
+  const featureId = findContourFlangeFeature(partHistory);
+  const solids = collectContourFlangeSolids(partHistory, featureId);
+  if (!solids.length) {
+    throw new Error(`[${label}] No solids were generated by the contour flange feature`);
+  }
+
+  let triCount = 0;
+  for (const solid of solids) {
+    const triVerts = Array.isArray(solid?._triVerts) ? solid._triVerts.length : 0;
+    triCount += Math.floor(triVerts / 3);
+  }
+
+  if (triCount === 0) {
+    throw new Error(`[${label}] Generated geometry has no triangles`);
+  }
+}
+
+export async function afterRun_SheetMetalContourFlange_Basic(partHistory) {
+  validateContourFlangeGeometry(partHistory, "contour_flange_basic");
+}
+
+export async function afterRun_SheetMetalContourFlange_StraightLine(partHistory) {
+  validateContourFlangeGeometry(partHistory, "contour_flange_straight");
+}

package/src/tests/test_sheetMetal_features.js

@@ -0,0 +1,80 @@
+const makeRectSketch = (x0, y0, x1, y1, geomBase = 100) => ({
+  points: [
+    { id: 0, x: x0, y: y0, fixed: true },
+    { id: 1, x: x1, y: y0, fixed: false },
+    { id: 2, x: x1, y: y1, fixed: false },
+    { id: 3, x: x0, y: y1, fixed: false },
+  ],
+  geometries: [
+    { id: geomBase + 0, type: "line", points: [0, 1], construction: false },
+    { id: geomBase + 1, type: "line", points: [1, 2], construction: false },
+    { id: geomBase + 2, type: "line", points: [2, 3], construction: false },
+    { id: geomBase + 3, type: "line", points: [3, 0], construction: false },
+  ],
+  constraints: [{ id: 0, type: "⏚", points: [0] }],
+});
+
+async function buildBaseTab(partHistory, { size = 10, thickness = 1, geomBase = 100 } = {}) {
+  const plane = await partHistory.newFeature("P");
+  plane.inputParams.orientation = "XY";
+
+  const sketch = await partHistory.newFeature("S");
+  sketch.inputParams.sketchPlane = plane.inputParams.featureID;
+  sketch.persistentData.sketch = makeRectSketch(0, 0, size, size, geomBase);
+
+  const tab = await partHistory.newFeature("SM.TAB");
+  tab.inputParams.profile = sketch.inputParams.featureID;
+  tab.inputParams.thickness = thickness;
+  tab.inputParams.consumeProfileSketch = false;
+
+  const edgeFaceName = `${tab.inputParams.featureID}:${sketch.inputParams.featureID}:G${geomBase}_SW`;
+  return { plane, sketch, tab, edgeFaceName };
+}
+
+export async function test_sheetMetal_tab(partHistory) {
+  await buildBaseTab(partHistory, { size: 12, thickness: 1, geomBase: 100 });
+  return partHistory;
+}
+
+export async function test_sheetMetal_flange(partHistory) {
+  const { edgeFaceName } = await buildBaseTab(partHistory, { size: 16, thickness: 1, geomBase: 100 });
+
+  const flange = await partHistory.newFeature("SM.F");
+  flange.inputParams.faces = [edgeFaceName];
+  flange.inputParams.angle = 90;
+
+  return partHistory;
+}
+
+export async function test_sheetMetal_hem(partHistory) {
+  const { edgeFaceName } = await buildBaseTab(partHistory, { size: 14, thickness: 1, geomBase: 110 });
+
+  const hem = await partHistory.newFeature("SM.HEM");
+  hem.inputParams.faces = [edgeFaceName];
+
+  return partHistory;
+}
+
+export async function test_sheetMetal_cutout(partHistory) {
+  const sheetSize = 20;
+  const { tab } = await buildBaseTab(partHistory, { size: sheetSize, thickness: 1, geomBase: 100 });
+
+  const datum = await partHistory.newFeature("D");
+  datum.inputParams.transform = {
+    position: [sheetSize / 2, sheetSize / 2, 0],
+    rotationEuler: [45, 0, 0],
+    scale: [1, 1, 1],
+  };
+
+  const cutSketch = await partHistory.newFeature("S");
+  cutSketch.inputParams.sketchPlane = `${datum.inputParams.featureID}:XY`;
+  cutSketch.persistentData.sketch = makeRectSketch(-2, -2, 2, 2, 200);
+
+  const cutout = await partHistory.newFeature("SM.CUTOUT");
+  cutout.inputParams.sheet = tab.inputParams.featureID;
+  cutout.inputParams.profile = cutSketch.inputParams.featureID;
+  cutout.inputParams.forwardDistance = 5;
+  cutout.inputParams.backDistance = 5;
+
+  return partHistory;
+}

package/src/tests/test_sketch_openLoop.js

@@ -0,0 +1,45 @@
+export async function test_sketch_openLoop(partHistory) {
+    const plane = await partHistory.newFeature("P");
+    plane.inputParams.orientation = "XY";
+
+    const sketch = await partHistory.newFeature("S");
+    sketch.inputParams.sketchPlane = plane.inputParams.featureID;
+    sketch.persistentData.sketch = {
+        points: [
+            { id: 0, x: 0, y: 0, fixed: true },
+            { id: 1, x: 20, y: 0, fixed: false },
+            { id: 2, x: 20, y: 15, fixed: false },
+        ],
+        geometries: [
+            { id: 100, type: "line", points: [0, 1], construction: false },
+            { id: 101, type: "line", points: [1, 2], construction: false },
+        ],
+        constraints: [
+            { id: 0, type: "⏚", points: [0] },
+        ],
+    };
+}
+
+export async function afterRun_sketch_openLoop(partHistory) {
+    const sketchFeature = partHistory.features.find((f) => f?.type === "S");
+    if (!sketchFeature) {
+        throw new Error("Sketch feature missing from history");
+    }
+    const sketchGroup = partHistory.scene.getObjectByName(sketchFeature.inputParams.featureID);
+    if (!sketchGroup) {
+        throw new Error("Sketch group not found in scene");
+    }
+    let faceCount = 0;
+    let edgeCount = 0;
+    sketchGroup.traverse((obj) => {
+        if (!obj) return;
+        if (obj.type === "FACE") faceCount++;
+        else if (obj.type === "EDGE") edgeCount++;
+    });
+    if (faceCount !== 0) {
+        throw new Error(`Open sketch generated ${faceCount} face(s)`);
+    }
+    if (edgeCount === 0) {
+        throw new Error("Open sketch should expose at least one EDGE");
+    }
+}

package/src/tests/test_solidMetrics.js

@@ -0,0 +1,58 @@
+// Builds a rectangular prism and validates Solid.volume(), Solid.surfaceArea(),
+// Face.surfaceArea(), and Edge.length() via console output.
+export async function test_solidMetrics(partHistory) {
+  const cube = await partHistory.newFeature("P.CU");
+  cube.inputParams.sizeX = 2;
+  cube.inputParams.sizeY = 3;
+  cube.inputParams.sizeZ = 4;
+  // Name will be the featureID; visualize() is called by the feature implementation.
+  return partHistory;
+}
+
+export async function afterRun_solidMetrics(partHistory) {
+  try {
+    const solids = (partHistory.scene?.children || []).filter(o => o && o.type === 'SOLID');
+    if (!solids.length) { console.warn('[solidMetrics] No solids in scene.'); return; }
+    const solid = solids[0];
+
+    const X = 2, Y = 3, Z = 4;
+    const expectedVolume = X * Y * Z; // 24
+    const expectedSurfaceArea = 2 * (X * Y + Y * Z + Z * X); // 52
+
+    const vol = typeof solid.volume === 'function' ? solid.volume() : NaN;
+    const sa = typeof solid.surfaceArea === 'function' ? solid.surfaceArea() : NaN;
+
+    const approx = (a, b, eps = 1e-6) => Math.abs(a - b) <= eps * Math.max(1, Math.abs(b));
+    const fmt = (n) => Number.isFinite(n) ? n.toFixed(6) : String(n);
+
+    console.log(`[solidMetrics] Solid volume: ${fmt(vol)} (expected ${fmt(expectedVolume)}) ${approx(vol, expectedVolume) ? 'OK' : 'MISMATCH'}`);
+    console.log(`[solidMetrics] Solid surface area: ${fmt(sa)} (expected ${fmt(expectedSurfaceArea)}) ${approx(sa, expectedSurfaceArea) ? 'OK' : 'MISMATCH'}`);
+
+    // Face areas by suffix: NX/PX = Y*Z, NY/PY = X*Z, NZ/PZ = X*Y
+    const faces = solid.children.filter(ch => ch?.type === 'FACE');
+    const faceAreaBySuffix = new Map([
+      ['_NX', Y * Z],
+      ['_PX', Y * Z],
+      ['_NY', X * Z],
+      ['_PY', X * Z],
+      ['_NZ', X * Y],
+      ['_PZ', X * Y],
+    ]);
+    for (const f of faces) {
+      const name = String(f?.name || '');
+      const suffix = Array.from(faceAreaBySuffix.keys()).find(suf => name.endsWith(suf));
+      if (!suffix) continue;
+      const area = typeof f.surfaceArea === 'function' ? f.surfaceArea() : NaN;
+      const expected = faceAreaBySuffix.get(suffix);
+      console.log(`[solidMetrics] Face ${name} area: ${fmt(area)} (expected ${fmt(expected)}) ${approx(area, expected) ? 'OK' : 'MISMATCH'}`);
+    }
+
+    // Edge lengths: should be one of {X, Y, Z}
+    const edges = solid.children.filter(ch => ch?.type === 'EDGE');
+    const lens = edges.map(e => (typeof e.length === 'function') ? e.length() : NaN);
+    const uniq = Array.from(new Set(lens.map(v => Number.isFinite(v) ? v.toFixed(6) : String(v))));
+    console.log(`[solidMetrics] Distinct edge lengths: ${uniq.join(', ')} (expected ${[X,Y,Z].map(n=>n.toFixed(6)).join(', ')})`);
+  } catch (e) {
+    console.warn('[solidMetrics] afterRun error:', e?.message || e);
+  }
+}