brep-io-kernel 1.0.0

package/src/tests/test_boolean_subtract.js

@@ -0,0 +1,27 @@
+
+export async function test_boolean_subtract(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;
+
+
+    const cube = await partHistory.newFeature("P.CU");    
+    cube.inputParams.sizeX = 2;
+    cube.inputParams.sizeY = 2;
+    cube.inputParams.sizeZ = 20;
+
+
+    const booleanFeature2 = await partHistory.newFeature("B");
+    booleanFeature2.inputParams.targetSolid = cube.inputParams.featureID;
+    booleanFeature2.inputParams.boolean = {
+        targets: [cone.inputParams.featureID],
+        operation: "SUBTRACT",
+    };
+
+
+
+
+    return partHistory;
+}

package/src/tests/test_chamfer.js

@@ -0,0 +1,17 @@
+export async function test_Chamfer(partHistory) {
+  // Base solid: cube to test planar chamfer along a face’s boundary
+  const cube = await partHistory.newFeature("P.CU");
+  cube.inputParams.sizeX = 20;
+  cube.inputParams.sizeY = 20;
+  cube.inputParams.sizeZ = 20;
+
+  // Chamfer all edges of the +Z face (PZ)
+  const chamfer = await partHistory.newFeature("CHAMFER");
+  chamfer.inputParams.edges = [`${cube.inputParams.featureID}_PZ`]; // select face to include its edges
+  chamfer.inputParams.distance = 3.0;
+  chamfer.inputParams.inflate = 0.0005; // nudge to prevent tiny remainders
+  chamfer.inputParams.direction = "INSET"; // subtract from the base body
+
+  return partHistory;
+}
+

package/src/tests/test_extrudeFace.js

@@ -0,0 +1,24 @@
+export async function test_ExtrudeFace(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;
+
+
+    const extrude = await partHistory.newFeature("E");
+    extrude.inputParams.profile = `${cone.inputParams.featureID}_T`;
+    // Use back distance instead of negative distance
+    extrude.inputParams.distance = 0;
+    extrude.inputParams.distanceBack = 5;
+
+    // Use internal boolean on the extrude feature to union with the cone
+    extrude.inputParams.boolean = {
+        targets: [cone.inputParams.featureID],
+        operation: "UNION",
+    };
+
+    // No separate boolean feature; handled internally by the extrude
+
+    return partHistory;
+}

package/src/tests/test_fillet.js

@@ -0,0 +1,17 @@
+export async function test_Fillet(partHistory) {
+  // Base solid: cylinder to provide a clean closed-loop edge at the top cap
+  const cyl = await partHistory.newFeature("P.CY");
+  cyl.inputParams.radius = 5;
+  cyl.inputParams.height = 10;
+  cyl.inputParams.resolution = 48;
+
+  // Apply a fillet along all edges of the top face (closed ring between _T and _S)
+  const fillet = await partHistory.newFeature("F");
+  fillet.inputParams.edges = [`${cyl.inputParams.featureID}_T`]; // select face to grab its edges
+  fillet.inputParams.radius = 1.0;
+  fillet.inputParams.inflate = 0.1; // tiny inflation to avoid sliver leftovers
+  fillet.inputParams.direction = "INSET"; // subtract from the base body
+
+  return partHistory;
+}
+

package/src/tests/test_fillet_nonClosed.js

@@ -0,0 +1,45 @@
+export async function test_Fillet_NonClosed(partHistory) {
+  // Create base solid: a cube
+  const cube = await partHistory.newFeature("P.CU");
+  cube.inputParams.width = 10;
+  cube.inputParams.height = 10;
+  cube.inputParams.depth = 10;
+
+  // Fillet a single cube edge (non-closed path segment).
+  const fillet = await partHistory.newFeature("F");
+  fillet.inputParams.edges = [
+    `${cube.inputParams.featureID}_NX|${cube.inputParams.featureID}_NY[0]`,
+  ];
+  fillet.inputParams.radius = 0.5;
+  fillet.inputParams.inflate = 0.1;
+  fillet.inputParams.direction = "INSET";
+
+  return partHistory;
+}
+
+export async function afterRun_Fillet_NonClosed(partHistory) {
+  // Verify that the fillet feature was created successfully
+  const filletFeature = partHistory.features.find((f) => f?.type === "F");
+  if (!filletFeature) {
+    throw new Error("Fillet feature missing from history");
+  }
+  
+  // Verify that the fillet solid exists in the scene
+  const filletGroup = (partHistory.scene?.children || []).find(
+    (obj) => obj?.owningFeatureID === filletFeature.inputParams.featureID
+  );
+  if (!filletGroup) throw new Error("Fillet group not found in scene");
+  
+  // Check that the fillet has produced geometry
+  let solidCount = 0;
+  filletGroup.traverse((obj) => {
+    if (obj?.type === "SOLID") solidCount++;
+  });
+  
+  if (solidCount === 0) {
+    throw new Error("Fillet feature should produce at least one solid");
+  }
+  
+  console.log(`✓ Non-closed fillet test passed: ${solidCount} solid(s) created`);
+  console.log(`✓ Tube centerline extended at both ends for non-closed loop`);
+}

package/src/tests/test_filletsMoreDifficult.js

@@ -0,0 +1,46 @@
+export async function test_filletsMoreDifficult(partHistory) {
+  // Recreate the scenario from the provided saved state
+
+  // 1) Cone
+  const cone = await partHistory.newFeature("P.CO");
+  cone.inputParams.radiusTop = 3;
+  cone.inputParams.radiusBottom = 0.5;
+  cone.inputParams.height = 5.2;
+  cone.inputParams.resolution = "128";
+  // No boolean on cone (defaults to NONE)
+
+  // 2) Cube unioned with cone
+  const cube = await partHistory.newFeature("P.CU");
+  cube.inputParams.sizeX = 5;
+  cube.inputParams.sizeY = 2;
+  cube.inputParams.sizeZ = 10;
+  cube.inputParams.boolean.targets = [cone.inputParams.featureID];
+  cube.inputParams.boolean.operation = 'UNION';
+
+  // 3) Fillet across intersection edge between cone side and cube +Y face
+  const fillet1 = await partHistory.newFeature("F");
+  fillet1.inputParams.edges = [
+    `${cone.inputParams.featureID}_S|${cube.inputParams.featureID}_PY[0]`,
+  ];
+  fillet1.inputParams.radius = 1;
+  fillet1.inputParams.inflate = 0.1;
+  fillet1.inputParams.direction = "OUTSET";
+  fillet1.inputParams.debug = false;
+
+  // 4) Fillet around top ring of the cone
+  const fillet2 = await partHistory.newFeature("F");
+  fillet2.inputParams.edges = [
+    `${cone.inputParams.featureID}_S|${cone.inputParams.featureID}_T[0]`,
+  ];
+  fillet2.inputParams.radius = 1;
+  fillet2.inputParams.inflate = 0.1;
+  fillet2.inputParams.direction = "INSET";
+  fillet2.inputParams.debug = false;
+
+  return partHistory;
+}
+
+// Alias with the requested test name spelling for the runner/export folder
+export async function test_fillets_more_dificult(partHistory) {
+  return test_filletsMoreDifficult(partHistory);
+}

package/src/tests/test_history_features_basic.js

@@ -0,0 +1,149 @@
+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] }],
+});
+
+const makeLineSketch = (ax, ay, bx, by, geomId = 200) => ({
+  points: [
+    { id: 0, x: ax, y: ay, fixed: true },
+    { id: 1, x: bx, y: by, fixed: false },
+  ],
+  geometries: [{ id: geomId, type: "line", points: [0, 1], construction: false }],
+  constraints: [{ id: 0, type: "⏚", points: [0] }],
+});
+
+export async function test_history_features_basic(partHistory) {
+  const datum = await partHistory.newFeature("D");
+  datum.inputParams.transform = {
+    position: [1, 2, 3],
+    rotationEuler: [0, 30, 0],
+    scale: [1, 1, 1],
+  };
+
+  const spline = await partHistory.newFeature("SP");
+  spline.persistentData.spline = {
+    points: [
+      { id: "p0", position: [0, 0, 0], forwardDistance: 1, backwardDistance: 1, flipDirection: false },
+      { id: "p1", position: [5, 2, 0], forwardDistance: 1, backwardDistance: 1, flipDirection: false },
+      { id: "p2", position: [10, 0, 0], forwardDistance: 1, backwardDistance: 1, flipDirection: false },
+    ],
+  };
+
+  const helix = await partHistory.newFeature("HX");
+  helix.inputParams.radius = 2;
+  helix.inputParams.endRadius = 1.5;
+  helix.inputParams.height = 8;
+  helix.inputParams.turns = 2;
+  helix.inputParams.resolution = 32;
+
+  const planeA = await partHistory.newFeature("P");
+  planeA.inputParams.orientation = "XY";
+  const planeB = await partHistory.newFeature("P");
+  planeB.inputParams.orientation = "XY";
+  planeB.inputParams.offset_distance = 5;
+
+  const loftSketchA = await partHistory.newFeature("S");
+  loftSketchA.inputParams.sketchPlane = planeA.inputParams.featureID;
+  loftSketchA.persistentData.sketch = makeRectSketch(0, 0, 10, 10, 100);
+
+  const loftSketchB = await partHistory.newFeature("S");
+  loftSketchB.inputParams.sketchPlane = planeB.inputParams.featureID;
+  loftSketchB.persistentData.sketch = makeRectSketch(2, 2, 8, 8, 200);
+
+  const loft = await partHistory.newFeature("LOFT");
+  loft.inputParams.profiles = [
+    loftSketchA.inputParams.featureID,
+    loftSketchB.inputParams.featureID,
+  ];
+
+  const axisSketch = await partHistory.newFeature("S");
+  axisSketch.inputParams.sketchPlane = planeA.inputParams.featureID;
+  axisSketch.persistentData.sketch = makeLineSketch(0, -5, 0, 5, 300);
+  const axisEdgeName = `${axisSketch.inputParams.featureID}:G300`;
+
+  const revolveSketch = await partHistory.newFeature("S");
+  revolveSketch.inputParams.sketchPlane = planeA.inputParams.featureID;
+  revolveSketch.persistentData.sketch = makeRectSketch(4, -2, 7, 2, 400);
+
+  const revolve = await partHistory.newFeature("R");
+  revolve.inputParams.profile = revolveSketch.inputParams.featureID;
+  revolve.inputParams.axis = axisEdgeName;
+  revolve.inputParams.angle = 180;
+  revolve.inputParams.resolution = 32;
+
+  const remeshBase = await partHistory.newFeature("P.CU");
+  const remesh = await partHistory.newFeature("RM");
+  remesh.inputParams.targetSolid = remeshBase.inputParams.featureID;
+  remesh.inputParams.mode = "Simplify";
+  remesh.inputParams.tolerance = 0.05;
+
+  const xformBase = await partHistory.newFeature("P.CU");
+  const xform = await partHistory.newFeature("XFORM");
+  xform.inputParams.solids = [xformBase.inputParams.featureID];
+  xform.inputParams.translate = [2, 0, 0];
+  xform.inputParams.rotateEulerDeg = [0, 0, 45];
+  xform.inputParams.copy = true;
+
+  const overlapBase = await partHistory.newFeature("P.CU");
+  const overlap = await partHistory.newFeature("OVL");
+  overlap.inputParams.targetSolid = overlapBase.inputParams.featureID;
+  overlap.inputParams.distance = 0.0005;
+
+  const patLinBase = await partHistory.newFeature("P.CU");
+  const patLin = await partHistory.newFeature("PATLIN");
+  patLin.inputParams.solids = [patLinBase.inputParams.featureID];
+  patLin.inputParams.count = 3;
+  patLin.inputParams.offset = { position: [3, 0, 0], rotationEuler: [0, 0, 0], scale: [1, 1, 1] };
+
+  const patRadBase = await partHistory.newFeature("P.CU");
+  const patRad = await partHistory.newFeature("PATRAD");
+  patRad.inputParams.solids = [patRadBase.inputParams.featureID];
+  patRad.inputParams.axisRef = axisEdgeName;
+  patRad.inputParams.count = 4;
+  patRad.inputParams.totalAngleDeg = 180;
+
+  const patLegacyBase = await partHistory.newFeature("P.CU");
+  const patLegacy = await partHistory.newFeature("PATTERN");
+  patLegacy.inputParams.solids = [patLegacyBase.inputParams.featureID];
+  patLegacy.inputParams.mode = "LINEAR";
+  patLegacy.inputParams.count = 2;
+
+  const acomp = await partHistory.newFeature("ACOMP");
+  acomp.inputParams.componentName = "missing_component";
+
+  const image = await partHistory.newFeature("IMAGE");
+  image.inputParams.fileToImport = "";
+
+  const heightmap = await partHistory.newFeature("HEIGHTMAP");
+  heightmap.inputParams.fileToImport = "";
+
+  return partHistory;
+}
+
+export async function afterRun_history_features_basic(partHistory) {
+  const requireFeatureObject = (type, label) => {
+    const entry = partHistory.features.find((f) => f?.type === type);
+    if (!entry) throw new Error(`${label} feature missing from history`);
+    const fid = entry?.inputParams?.featureID;
+    if (!fid) throw new Error(`${label} feature missing featureID`);
+    const obj = partHistory.scene.getObjectByName(fid);
+    if (!obj) throw new Error(`${label} object not found in scene`);
+  };
+
+  requireFeatureObject("D", "Datium");
+  requireFeatureObject("SP", "Spline");
+  requireFeatureObject("HX", "Helix");
+  requireFeatureObject("LOFT", "Loft");
+  requireFeatureObject("R", "Revolve");
+}

package/src/tests/test_hole.js

@@ -0,0 +1,282 @@
+const CUBE_SIZE = 12;
+const HOLE_DIAMETER = 2;
+const CSK_DIAMETER = 6;
+const CSK_ANGLE = 90;
+const CSK_DEPTH = 6;
+const CBORE_DIAMETER = 6;
+const CBORE_DEPTH = 3;
+const CBORE_TOTAL_DEPTH = 7;
+const EPS = 1e-6;
+
+function buildSketchWithPoints(sketchFeature, points) {
+  const pointList = [
+    { id: 0, x: 0, y: 0, fixed: true },
+    ...points.map((p, idx) => ({
+      id: idx + 1,
+      x: p[0],
+      y: p[1],
+      fixed: false,
+    })),
+  ];
+  sketchFeature.persistentData.sketch = {
+    points: pointList,
+    geometries: [],
+    constraints: [{ id: 0, type: "⏚", points: [0] }],
+  };
+}
+
+function findHoleFeature(partHistory) {
+  return partHistory.features.find((f) => f?.type === "H") || null;
+}
+
+function countHoleMetadata(solids) {
+  let count = 0;
+  for (const solid of solids) {
+    const meta = solid?._faceMetadata;
+    if (!(meta instanceof Map)) continue;
+    for (const value of meta.values()) {
+      if (value?.hole) count++;
+    }
+  }
+  return count;
+}
+
+function getPrimarySolid(partHistory) {
+  const solids = (partHistory.scene?.children || []).filter((o) => o?.type === "SOLID");
+  return solids[0] || null;
+}
+
+function expectApprox(value, expected, label) {
+  if (!Number.isFinite(value) || Math.abs(value - expected) > EPS) {
+    throw new Error(`${label} expected ${expected}, got ${value}`);
+  }
+}
+
+export async function test_hole_through(partHistory) {
+  const cube = await partHistory.newFeature("P.CU");
+  cube.inputParams.sizeX = CUBE_SIZE;
+  cube.inputParams.sizeY = CUBE_SIZE;
+  cube.inputParams.sizeZ = CUBE_SIZE;
+
+  const plane = await partHistory.newFeature("P");
+  plane.inputParams.orientation = "XY";
+
+  const sketch = await partHistory.newFeature("S");
+  sketch.inputParams.sketchPlane = plane.inputParams.featureID;
+  buildSketchWithPoints(sketch, [[CUBE_SIZE * 0.5, CUBE_SIZE * 0.5]]);
+
+  const hole = await partHistory.newFeature("H");
+  hole.inputParams.face = sketch.inputParams.featureID;
+  hole.inputParams.holeType = "SIMPLE";
+  hole.inputParams.diameter = HOLE_DIAMETER;
+  hole.inputParams.throughAll = true;
+  hole.inputParams.boolean = {
+    targets: [cube.inputParams.featureID],
+    operation: "SUBTRACT",
+  };
+
+  return partHistory;
+}
+
+export async function afterRun_hole_through(partHistory) {
+  const holeFeature = findHoleFeature(partHistory);
+  if (!holeFeature) throw new Error("[hole_through] Hole feature missing");
+  const holes = holeFeature.persistentData?.holes || [];
+  if (!holes.length) throw new Error("[hole_through] No hole records");
+  if (!holes[0]?.throughAll) throw new Error("[hole_through] Expected through-all hole record");
+  if (String(holes[0]?.type || "").toUpperCase() !== "SIMPLE") {
+    throw new Error(`[hole_through] Expected SIMPLE hole, got ${holes[0]?.type}`);
+  }
+
+  const solid = getPrimarySolid(partHistory);
+  if (!solid) throw new Error("[hole_through] No solids created");
+  const faceCount = solid._faceNameToID?.size || 0;
+  if (faceCount <= 6) throw new Error("[hole_through] Hole did not add faces");
+
+  const holeMetaCount = countHoleMetadata([solid]);
+  if (holeMetaCount === 0) throw new Error("[hole_through] No hole face metadata found");
+}
+
+export async function test_hole_thread_symbolic(partHistory) {
+  const cube = await partHistory.newFeature("P.CU");
+  cube.inputParams.sizeX = CUBE_SIZE;
+  cube.inputParams.sizeY = CUBE_SIZE;
+  cube.inputParams.sizeZ = CUBE_SIZE;
+
+  const plane = await partHistory.newFeature("P");
+  plane.inputParams.orientation = "XY";
+
+  const sketch = await partHistory.newFeature("S");
+  sketch.inputParams.sketchPlane = plane.inputParams.featureID;
+  buildSketchWithPoints(sketch, [[CUBE_SIZE * 0.35, CUBE_SIZE * 0.35]]);
+
+  const hole = await partHistory.newFeature("H");
+  hole.inputParams.face = sketch.inputParams.featureID;
+  hole.inputParams.holeType = "THREADED";
+  hole.inputParams.depth = 6;
+  hole.inputParams.throughAll = false;
+  hole.inputParams.threadStandard = "ISO_METRIC";
+  hole.inputParams.threadDesignation = "M6x1";
+  hole.inputParams.threadMode = "SYMBOLIC";
+  hole.inputParams.boolean = {
+    targets: [cube.inputParams.featureID],
+    operation: "SUBTRACT",
+  };
+
+  return partHistory;
+}
+
+export async function afterRun_hole_thread_symbolic(partHistory) {
+  const holeFeature = findHoleFeature(partHistory);
+  if (!holeFeature) throw new Error("[hole_thread_symbolic] Hole feature missing");
+  const holes = holeFeature.persistentData?.holes || [];
+  if (!holes.length) throw new Error("[hole_thread_symbolic] No hole records");
+  const record = holes[0];
+  if (String(record?.type || "").toUpperCase() !== "THREADED") {
+    throw new Error(`[hole_thread_symbolic] Expected THREADED hole, got ${record?.type}`);
+  }
+  if (!record?.thread || String(record.thread.mode || "").toUpperCase() !== "SYMBOLIC") {
+    throw new Error("[hole_thread_symbolic] Expected symbolic thread metadata");
+  }
+}
+
+export async function test_hole_thread_modeled(partHistory) {
+  const cube = await partHistory.newFeature("P.CU");
+  cube.inputParams.sizeX = CUBE_SIZE;
+  cube.inputParams.sizeY = CUBE_SIZE;
+  cube.inputParams.sizeZ = CUBE_SIZE;
+
+  const plane = await partHistory.newFeature("P");
+  plane.inputParams.orientation = "XY";
+
+  const sketch = await partHistory.newFeature("S");
+  sketch.inputParams.sketchPlane = plane.inputParams.featureID;
+  buildSketchWithPoints(sketch, [[CUBE_SIZE * 0.65, CUBE_SIZE * 0.35]]);
+
+  const hole = await partHistory.newFeature("H");
+  hole.inputParams.face = sketch.inputParams.featureID;
+  hole.inputParams.holeType = "THREADED";
+  hole.inputParams.depth = 4;
+  hole.inputParams.throughAll = false;
+  hole.inputParams.threadStandard = "ISO_METRIC";
+  hole.inputParams.threadDesignation = "M6x1";
+  hole.inputParams.threadMode = "MODELED";
+  hole.inputParams.boolean = {
+    targets: [cube.inputParams.featureID],
+    operation: "SUBTRACT",
+  };
+
+  return partHistory;
+}
+
+export async function afterRun_hole_thread_modeled(partHistory) {
+  const holeFeature = findHoleFeature(partHistory);
+  if (!holeFeature) throw new Error("[hole_thread_modeled] Hole feature missing");
+  const holes = holeFeature.persistentData?.holes || [];
+  if (!holes.length) throw new Error("[hole_thread_modeled] No hole records");
+  const record = holes[0];
+  if (String(record?.type || "").toUpperCase() !== "THREADED") {
+    throw new Error(`[hole_thread_modeled] Expected THREADED hole, got ${record?.type}`);
+  }
+  if (!record?.thread || String(record.thread.mode || "").toUpperCase() !== "MODELED") {
+    throw new Error("[hole_thread_modeled] Expected modeled thread metadata");
+  }
+}
+
+export async function test_hole_countersink(partHistory) {
+  const cube = await partHistory.newFeature("P.CU");
+  cube.inputParams.sizeX = CUBE_SIZE;
+  cube.inputParams.sizeY = CUBE_SIZE;
+  cube.inputParams.sizeZ = CUBE_SIZE;
+
+  const plane = await partHistory.newFeature("P");
+  plane.inputParams.orientation = "XY";
+
+  const sketch = await partHistory.newFeature("S");
+  sketch.inputParams.sketchPlane = plane.inputParams.featureID;
+  buildSketchWithPoints(sketch, [[CUBE_SIZE * 0.25, CUBE_SIZE * 0.65]]);
+
+  const hole = await partHistory.newFeature("H");
+  hole.inputParams.face = sketch.inputParams.featureID;
+  hole.inputParams.holeType = "COUNTERSINK";
+  hole.inputParams.diameter = HOLE_DIAMETER;
+  hole.inputParams.depth = CSK_DEPTH;
+  hole.inputParams.throughAll = false;
+  hole.inputParams.countersinkDiameter = CSK_DIAMETER;
+  hole.inputParams.countersinkAngle = CSK_ANGLE;
+  hole.inputParams.boolean = {
+    targets: [cube.inputParams.featureID],
+    operation: "SUBTRACT",
+  };
+
+  return partHistory;
+}
+
+export async function afterRun_hole_countersink(partHistory) {
+  const holeFeature = findHoleFeature(partHistory);
+  if (!holeFeature) throw new Error("[hole_countersink] Hole feature missing");
+  const holes = holeFeature.persistentData?.holes || [];
+  if (!holes.length) throw new Error("[hole_countersink] No hole records");
+  const record = holes[0];
+  if (String(record?.type || "").toUpperCase() !== "COUNTERSINK") {
+    throw new Error(`[hole_countersink] Expected COUNTERSINK hole, got ${record?.type}`);
+  }
+  if (record?.throughAll) throw new Error("[hole_countersink] Expected non-through hole");
+  if (!(record?.countersinkHeight > 0)) throw new Error("[hole_countersink] Expected countersink height > 0");
+  expectApprox(record?.countersinkDiameter, CSK_DIAMETER, "[hole_countersink] countersink diameter");
+  expectApprox(record?.countersinkAngle, CSK_ANGLE, "[hole_countersink] countersink angle");
+
+  const solid = getPrimarySolid(partHistory);
+  if (!solid) throw new Error("[hole_countersink] No solids created");
+  const holeMetaCount = countHoleMetadata([solid]);
+  if (holeMetaCount === 0) throw new Error("[hole_countersink] No hole face metadata found");
+}
+
+export async function test_hole_counterbore(partHistory) {
+  const cube = await partHistory.newFeature("P.CU");
+  cube.inputParams.sizeX = CUBE_SIZE;
+  cube.inputParams.sizeY = CUBE_SIZE;
+  cube.inputParams.sizeZ = CUBE_SIZE;
+
+  const plane = await partHistory.newFeature("P");
+  plane.inputParams.orientation = "XY";
+
+  const sketch = await partHistory.newFeature("S");
+  sketch.inputParams.sketchPlane = plane.inputParams.featureID;
+  buildSketchWithPoints(sketch, [[CUBE_SIZE * 0.75, CUBE_SIZE * 0.65]]);
+
+  const hole = await partHistory.newFeature("H");
+  hole.inputParams.face = sketch.inputParams.featureID;
+  hole.inputParams.holeType = "COUNTERBORE";
+  hole.inputParams.diameter = HOLE_DIAMETER;
+  hole.inputParams.depth = CBORE_TOTAL_DEPTH;
+  hole.inputParams.throughAll = false;
+  hole.inputParams.counterboreDiameter = CBORE_DIAMETER;
+  hole.inputParams.counterboreDepth = CBORE_DEPTH;
+  hole.inputParams.boolean = {
+    targets: [cube.inputParams.featureID],
+    operation: "SUBTRACT",
+  };
+
+  return partHistory;
+}
+
+export async function afterRun_hole_counterbore(partHistory) {
+  const holeFeature = findHoleFeature(partHistory);
+  if (!holeFeature) throw new Error("[hole_counterbore] Hole feature missing");
+  const holes = holeFeature.persistentData?.holes || [];
+  if (!holes.length) throw new Error("[hole_counterbore] No hole records");
+  const record = holes[0];
+  if (String(record?.type || "").toUpperCase() !== "COUNTERBORE") {
+    throw new Error(`[hole_counterbore] Expected COUNTERBORE hole, got ${record?.type}`);
+  }
+  if (record?.throughAll) throw new Error("[hole_counterbore] Expected non-through hole");
+  expectApprox(record?.counterboreDiameter, CBORE_DIAMETER, "[hole_counterbore] counterbore diameter");
+  expectApprox(record?.counterboreDepth, CBORE_DEPTH, "[hole_counterbore] counterbore depth");
+  expectApprox(record?.straightDepth, CBORE_TOTAL_DEPTH - CBORE_DEPTH, "[hole_counterbore] straight depth");
+
+  const solid = getPrimarySolid(partHistory);
+  if (!solid) throw new Error("[hole_counterbore] No solids created");
+  const holeMetaCount = countHoleMetadata([solid]);
+  if (holeMetaCount === 0) throw new Error("[hole_counterbore] No hole face metadata found");
+}

package/src/tests/test_mirror.js

@@ -0,0 +1,16 @@
+export async function test_mirror(partHistory) {
+    // Create a base cube to mirror
+    const cube = await partHistory.newFeature("P.CU");
+    cube.inputParams.sizeX = 4;
+    cube.inputParams.sizeY = 3;
+    cube.inputParams.sizeZ = 2;
+
+    // Mirror the cube across one of its own faces (PX face plane)
+    const mirror = await partHistory.newFeature("M");
+    mirror.inputParams.solids = [cube.inputParams.featureID];
+    mirror.inputParams.mirrorPlane = `${cube.inputParams.featureID}_PX`;
+    mirror.inputParams.offsetDistance = 0; // on-face mirror
+
+    return partHistory;
+}
+