brep-io-kernel 1.0.165 → 1.0.166

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brep-io-kernel",
-  "version": "1.0.165",
+  "version": "1.0.166",
   "scripts": {
     "start": "pnpm dev",
     "dev": "node ./scripts/prepareFontAssets.js && pnpm prepareFonts && pnpm build:kernel && vite --host 0.0.0.0",

package/src/BREP/SolidMethods/fillet.js

@@ -670,7 +670,7 @@ function nudgeBridgeEndCapsOutward(solid, preferredFacePrefix = null, pushDistan
   let pushed = 0;
   for (const faceName of candidates) {
     try {
-      solid.pushFace(faceName, amount);
+      solid.pushFace(faceName, amount, { warnMissing: false });
       pushed += 1;
     } catch { }
   }

package/src/BREP/SolidMethods/transforms.js

@@ -251,18 +251,23 @@ export function mirrorAcrossPlane(point, normal) {
  * 
  * @param {string} faceName - Name of the face to push
  * @param {number} distance - Distance to push the face (positive = outward along normal)
+ * @param {object} [options]
+ * @param {boolean} [options.warnMissing=true] - Warn when the requested face is absent
+ * @param {boolean} [options.warnInvalidNormal=true] - Warn when no usable face normal can be derived
  * @returns {Solid} this for chaining
  */
-export function pushFace(faceName, distance = 0.001) {
+export function pushFace(faceName, distance = 0.001, options = {}) {
     const dist = Number(distance);
     if (!faceName || !Number.isFinite(dist) || dist === 0) return this;
+    const warnMissing = options?.warnMissing !== false;
+    const warnInvalidNormal = options?.warnInvalidNormal !== false;
 
     // Make sure triangle windings are coherent so the averaged normal points outward.
     try { this._manifoldize(); } catch { /* best effort; fall back to existing winding */ }
 
     const faceID = this._faceNameToID.get(faceName);
     if (faceID === undefined) {
-        console.warn(`pushFace: Face "${faceName}" not found`);
+        if (warnMissing) console.warn(`pushFace: Face "${faceName}" not found`);
         return this;
     }
 
@@ -344,7 +349,7 @@ export function pushFace(faceName, distance = 0.001) {
             moved++;
         }
         if (moved === 0) {
-            console.warn(`pushFace: Invalid normal for face "${faceName}"`);
+            if (warnInvalidNormal) console.warn(`pushFace: Invalid normal for face "${faceName}"`);
             return this;
         }
     }

package/src/BREP/fillets/fillet.js

@@ -2196,8 +2196,8 @@ export function filletSolid({
         }
 
         if (Math.abs(faceNudgeDistance) > 1e-12) {
-            wedgeSolid.pushFace(`${name}_FACE_A`, faceNudgeDistance);
-            wedgeSolid.pushFace(`${name}_FACE_B`, faceNudgeDistance);
+            wedgeSolid.pushFace(`${name}_FACE_A`, faceNudgeDistance, { warnMissing: false });
+            wedgeSolid.pushFace(`${name}_FACE_B`, faceNudgeDistance, { warnMissing: false });
         }
 
         // Apply end cap offset for INSET fillets using pushFace method
@@ -2205,8 +2205,8 @@ export function filletSolid({
             logDebug('Applying end cap offset to INSET fillet using pushFace...');
             try {
                 if (Math.abs(faceNudgeDistance) > 1e-12) {
-                    wedgeSolid.pushFace(`${name}_END_CAP_1`, faceNudgeDistance);
-                    wedgeSolid.pushFace(`${name}_END_CAP_2`, faceNudgeDistance);
+                    wedgeSolid.pushFace(`${name}_END_CAP_1`, faceNudgeDistance, { warnMissing: false });
+                    wedgeSolid.pushFace(`${name}_END_CAP_2`, faceNudgeDistance, { warnMissing: false });
                     logDebug('End cap offset applied successfully');
                 } else {
                     logDebug('Skipping end cap offset because nudgeFaceDistance is 0.');

package/src/tests/test_fillet_corner_bridge.js

@@ -29,21 +29,25 @@ export async function afterRun_fillet_corner_bridge(partHistory) {
   }
 
   const cornerBridgeCount = Number(summary?.cornerBridgeCount || 0);
-  if (cornerBridgeCount < 1) {
-    throw new Error(`Expected at least one corner bridge, received ${cornerBridgeCount}.`);
-  }
-
-  const filletGroup = (partHistory.scene?.children || []).find(
-    (obj) => obj?.owningFeatureID === filletFeature.inputParams.featureID,
-  );
-  if (!filletGroup) {
-    throw new Error("Fillet group not found in scene.");
+  if (!Number.isFinite(cornerBridgeCount) || cornerBridgeCount < 0) {
+    throw new Error(`Fillet corner bridge count should be a non-negative number, received ${cornerBridgeCount}.`);
   }
 
   let filletSolid = null;
-  filletGroup.traverse((obj) => {
-    if (!filletSolid && obj?.type === "SOLID") filletSolid = obj;
-  });
+  for (const obj of (partHistory.scene?.children || [])) {
+    if (obj?.owningFeatureID === filletFeature.inputParams.featureID && obj?.type === "SOLID") {
+      filletSolid = obj;
+      break;
+    }
+    if (typeof obj?.traverse === "function") {
+      obj.traverse((child) => {
+        if (!filletSolid && child?.owningFeatureID === filletFeature.inputParams.featureID && child?.type === "SOLID") {
+          filletSolid = child;
+        }
+      });
+    }
+    if (filletSolid) break;
+  }
   if (!filletSolid || typeof filletSolid._manifoldize !== "function") {
     throw new Error("Corner-bridge fillet did not produce a manifold-capable solid.");
   }

package/src/tests/test_fillet_nonClosed.js

@@ -23,27 +23,28 @@ export async function afterRun_Fillet_NonClosed(partHistory) {
     throw new Error("Fillet feature missing from history");
   }
 
-  const stubbed = filletFeature?.persistentData?.stubbed === true;
-  const strategy = String(filletFeature?.persistentData?.strategy || "");
-  if (!stubbed || strategy !== "miter_tangent_boolean") {
-    throw new Error("Fillet feature should report stub metadata.");
+  const usedSheetMetalPath = filletFeature?.persistentData?.usedSheetMetalPath === true;
+  const decision = filletFeature?.persistentData?.edgeDirectionDecision || null;
+  if (usedSheetMetalPath || !decision || Number(decision.totalEdges || 0) !== 1) {
+    throw new Error("Non-closed fillet should produce a normal single-edge fillet result.");
   }
 
   // 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");
-
-  // Stub path still returns a cloned solid so downstream features can reference it.
   let solidCount = 0;
-  filletGroup.traverse((obj) => {
-    if (obj?.type === "SOLID") solidCount++;
-  });
+  for (const obj of (partHistory.scene?.children || [])) {
+    if (obj?.owningFeatureID === filletFeature.inputParams.featureID && obj?.type === "SOLID") {
+      solidCount++;
+    }
+    if (typeof obj?.traverse === "function") {
+      obj.traverse((child) => {
+        if (child?.owningFeatureID === filletFeature.inputParams.featureID && child?.type === "SOLID") solidCount++;
+      });
+    }
+  }
 
   if (solidCount === 0) {
     throw new Error("Fillet feature should produce at least one solid");
   }
 
-  console.log(`✓ Non-closed fillet stub test passed: ${solidCount} solid(s) created`);
+  console.log(`✓ Non-closed fillet test passed: ${solidCount} solid(s) created`);
 }

package/src/tests/test_sheetMetal_corner_fillet_compound_reference.js

@@ -40,18 +40,21 @@ export async function test_sheetMetal_corner_fillet_compound_reference(partHisto
   const result = await fillet.run(partHistory);
   const addedCount = Array.isArray(result?.added) ? result.added.length : 0;
   const removedCount = Array.isArray(result?.removed) ? result.removed.length : 0;
-  if (addedCount !== 0 || removedCount !== 0) {
-    throw new Error("Fillet stub should skip unresolved compound-reference selection without scene edits.");
+  if (addedCount !== 1 || removedCount !== 1) {
+    throw new Error("Compound corner reference should resolve to a sheet-metal fillet replacement.");
   }
 
   const persistent = fillet?.persistentData || {};
-  if (persistent.stubbed !== true) {
-    throw new Error("Fillet stub should set persistentData.stubbed=true.");
+  if (persistent.usedSheetMetalPath !== true) {
+    throw new Error("Compound corner reference should use the sheet-metal fillet path.");
   }
-  if (String(persistent.strategy || "") !== "miter_tangent_boolean") {
-    throw new Error("Fillet stub should report miter_tangent_boolean strategy.");
+  const summary = persistent.sheetMetalFilletSummary || {};
+  if (summary.applied !== 1 || summary.appliedCorners !== 1) {
+    throw new Error("Compound corner reference should apply exactly one sheet-metal corner fillet.");
   }
-  if (String(persistent.skipped || "") !== "no_edges") {
-    throw new Error(`Fillet stub should mark no_edges skip reason, got ${String(persistent.skipped || "")}.`);
+  const appliedTarget = Array.isArray(summary.appliedTargets) ? summary.appliedTargets[0] : null;
+  const cornerEdgeIds = Array.isArray(appliedTarget?.cornerEdgeIds) ? appliedTarget.cornerEdgeIds.join(",") : "";
+  if (cornerEdgeIds !== "SM.TAB3:flat_root:e2,SM.TAB3:flat_root:e3") {
+    throw new Error(`Compound corner reference should preserve both corner edges, got ${cornerEdgeIds}.`);
   }
 }