brep-io-kernel 1.0.0

package/src/features/boolean/BooleanFeature.js

@@ -0,0 +1,94 @@
+import { BREP } from '../../BREP/BREP.js'
+
+const inputParamsSchema = {
+    id: {
+        type: "string",
+        default_value: null,
+        hint: "unique identifier for the boolean feature",
+    },
+    targetSolid: {
+        type: "reference_selection",
+        selectionFilter: ["SOLID"],
+        multiple: false,
+        default_value: null,
+        hint: "Primary target solid",
+    },
+    boolean: {
+        type: "boolean_operation",
+        // For the Boolean feature, the widget's targets represent the OTHER solids to combine with the targetSolid
+        default_value: { targets: [], operation: 'UNION' },
+        hint: "Operation + other solids (as tools)",
+    }
+};
+
+export class BooleanFeature {
+    static shortName = "B";
+    static longName = "Boolean";
+    static inputParamsSchema = inputParamsSchema;
+
+    constructor() {
+        this.inputParams = {};
+        this.persistentData = {};
+    }
+
+    async run(partHistory) {
+        const scene = partHistory.scene;
+        const targetObj = Array.isArray(this.inputParams.targetSolid) ? (this.inputParams.targetSolid[0] || null) : (this.inputParams.targetSolid || null);
+        const target = (targetObj && typeof targetObj === 'object') ? targetObj : (targetObj ? await scene.getObjectByName(String(targetObj)) : null);
+        if (!target) throw new Error(`Target solid not found`);
+
+        const bool = this.inputParams.boolean || { targets: [], operation: 'NONE' };
+        const op = String((bool.operation ?? 'NONE')).toUpperCase();
+        const toolEntries = Array.isArray(bool.targets) ? bool.targets.filter(Boolean) : [];
+        if (op === 'NONE' || toolEntries.length === 0) {
+            // No-op: leave scene unchanged
+            return { added: [], removed: [] };
+        }
+
+        // Collect tool solids (objects preferred, fallback to names)
+        const seen = new Set();
+        const tools = [];
+        for (const entry of toolEntries) {
+            if (!entry) continue;
+            if (typeof entry === 'object') {
+                const key = entry.uuid || entry.id || entry.name || `${tools.length}`;
+                if (seen.has(key)) continue;
+                seen.add(key);
+                tools.push(entry);
+            } else {
+                const key = String(entry);
+                if (seen.has(key)) continue;
+                seen.add(key);
+                const obj = await scene.getObjectByName(key);
+                if (obj) tools.push(obj);
+            }
+        }
+        if (tools.length === 0) return { added: [], removed: [] };
+
+        // Use the shared helper semantics:
+        // - For UNION/INTERSECT: base = target, targets = tools → returns [result]; tools removed; we remove target.
+        // - For SUBTRACT: invert per helper by passing base = union(tools), targets = [target] → returns [result];
+        //   helper will remove target and the base union; also mark the original tool solids as removed here.
+        let effects = { added: [], removed: [] };
+        if (op === 'SUBTRACT') {
+            let toolUnion = tools[0];
+            for (let i = 1; i < tools.length; i++) toolUnion = toolUnion.union(tools[i]);
+            const param = { operation: 'SUBTRACT', targets: [target] };
+            effects = await BREP.applyBooleanOperation(partHistory, toolUnion, param, this.inputParams.featureID);
+            // Also consider original tools as removed
+            effects.removed = [...tools, ...effects.removed];
+        } else {
+            const param = { operation: op, targets: tools };
+            effects = await BREP.applyBooleanOperation(partHistory, target, param, this.inputParams.featureID);
+            // Ensure original target is removed to avoid duplication
+            effects.removed = [target, ...effects.removed];
+        }
+
+        // Mark removals and return only additions
+        try { for (const obj of effects.removed || []) { if (obj) obj.__removeFlag = true; } } catch { }
+        return {
+            added: Array.isArray(effects.added) ? effects.added : [],
+            removed: Array.isArray(effects.removed) ? effects.removed : [],
+        };
+    }
+}

package/src/features/chamfer/ChamferFeature.js

@@ -0,0 +1,116 @@
+import {
+    collectEdgesFromSelection,
+    getSolidGeometryCounts,
+    resolveSingleSolidFromEdges,
+} from "../edgeFeatureUtils.js";
+
+const inputParamsSchema = {
+    id: {
+        type: "string",
+        default_value: null,
+        hint: "unique identifier for the chamfer feature",
+    },
+    edges: {
+        type: "reference_selection",
+        selectionFilter: ["EDGE", "FACE"],
+        multiple: true,
+        default_value: null,
+        hint: "Select edges or faces to apply the chamfer",
+    },
+    distance: {
+        type: "number",
+        step: 0.1,
+        default_value: 1,
+        hint: "Chamfer distance (equal offset along both faces)",
+    },
+    inflate: {
+        type: "number",
+        default_value: 0.1,
+        step: 0.1,
+        hint: "Grow the cutting solid by this amount (units). Very small values (e.g., 0.0005) help avoid residual slivers after CSG.",
+    },
+    direction: {
+        type: "options",
+        options: ["INSET", "OUTSET"],
+        default_value: "INSET",
+        hint: "Prefer chamfer inside (INSET) or outside (OUTSET)",
+    },
+    debug: {
+        type: "boolean",
+        default_value: false,
+        hint: "Draw diagnostic helpers for section frames",
+    }
+};
+
+export class ChamferFeature {
+    static shortName = "CH";
+    static longName = "Chamfer";
+    static inputParamsSchema = inputParamsSchema;
+
+    constructor() {
+        this.inputParams = {};
+        this.persistentData = {};
+    }
+    async run(partHistory) {
+        const inputObjects = Array.isArray(this.inputParams.edges) ? this.inputParams.edges.filter(Boolean) : [];
+        const edgeObjs = collectEdgesFromSelection(inputObjects);
+
+        if (edgeObjs.length === 0) {
+            console.warn("No edges selected for chamfer");
+            return { added: [], removed: [] };
+        }
+
+        const { solid: targetSolid, solids } = resolveSingleSolidFromEdges(edgeObjs);
+        if (!targetSolid) {
+            if (solids.size === 0) {
+                console.warn("Selected edges do not belong to any solid");
+            } else {
+                console.warn("Selected edges belong to multiple solids");
+            }
+            return { added: [], removed: [] };
+        }
+        const direction = String(this.inputParams.direction || "INSET").toUpperCase();
+        const distance = Number(this.inputParams.distance);
+        if (!Number.isFinite(distance) || !(distance > 0)) {
+            console.warn("Invalid chamfer distance supplied; aborting.", { distance: this.inputParams.distance });
+            return { added: [], removed: [] };
+        }
+
+        const fid = this.inputParams.featureID;
+        const result = await targetSolid.chamfer({
+            distance,
+            edges: edgeObjs,
+            direction,
+            inflate: Number(this.inputParams.inflate),
+            debug: !!this.inputParams.debug,
+            featureID: fid,
+        });
+
+        const { triCount, vertCount } = getSolidGeometryCounts(result);
+        if (!result || triCount === 0 || vertCount === 0) {
+            console.error("[ChamferFeature] Chamfer produced an empty result; skipping scene replacement.", {
+                featureID: fid,
+                triangleCount: triCount,
+                vertexCount: vertCount,
+                direction,
+                distance,
+                inflate: this.inputParams.inflate,
+            });
+            return { added: [], removed: [] };
+        }
+
+        try { result.name = targetSolid.name; } catch {}
+        try { targetSolid.__removeFlag = true; } catch {}
+        result.visualize();
+
+        const added = [result];
+        if (this.inputParams.debug && Array.isArray(result.__debugChamferSolids)) {
+            for (const dbg of result.__debugChamferSolids) {
+                if (!dbg) continue;
+                try { dbg.name = `${fid || "CHAMFER"}_${dbg.name || "DEBUG"}`; } catch {}
+                added.push(dbg);
+            }
+        }
+        return { added, removed: [targetSolid] };
+    }
+}

package/src/features/datium/DatiumFeature.js

@@ -0,0 +1,80 @@
+
+import { BREP } from "../../BREP/BREP.js";
+const THREE = BREP.THREE;
+import { createPlaneBaseMesh } from '../plane/PlaneFeature.js';
+import { createAxisHelperGroup } from "../../utils/axisHelpers.js";
+
+const inputParamsSchema = {
+    id: {
+        type: "string",
+        default_value: null,
+        hint: "unique identifier for the datium feature",
+    },
+    // Optional placement/orientation via TRS
+    transform: {
+        type: 'transform',
+        default_value: { position: [0, 0, 0], rotationEuler: [0, 0, 0], scale: [1, 1, 1] },
+        hint: 'Position, rotation, and scale'
+    },
+};
+
+export class DatiumFeature {
+    static shortName = "D";
+    static longName = "Datium";
+    static inputParamsSchema = inputParamsSchema;
+
+    constructor() {
+        this.inputParams = {};
+        this.persistentData = {};
+    }
+
+    async run(/* partHistory */) {
+        // Build a group with 3 orthogonal plane meshes (XY, XZ, YZ)
+        const group = new THREE.Group();
+        const baseName = this.inputParams.featureID || 'Datium';
+        group.name = baseName;
+        group.type = 'DATUM';
+        // Provide a no-op click handler for UI safety
+        group.onClick = () => {};
+
+        const mkPlane = (orientation, suffix) => {
+            const mesh = createPlaneBaseMesh();
+            mesh.name = `${baseName}:${suffix}`;
+            mesh.userData = mesh.userData || {};
+            mesh.userData.orientation = orientation;
+            // Orient like PlaneFeature for consistency
+            if (orientation === 'XZ') mesh.rotation.x = Math.PI / 2; // normal ±Y
+            if (orientation === 'YZ') mesh.rotation.y = Math.PI / 2; // normal ±X
+            return mesh;
+        };
+
+        const pXY = mkPlane('XY', 'XY');
+        const pXZ = mkPlane('XZ', 'XZ');
+        const pYZ = mkPlane('YZ', 'YZ');
+        group.add(pXY, pXZ, pYZ);
+        group.renderOrder = 1; // Render on top of most things
+
+        const axisHelper = createAxisHelperGroup({
+            name: `${baseName}:Axes`,
+            selectable: true,
+        });
+        group.add(axisHelper);
+
+        // Apply TRS to the whole datum group (position/orient in 3D space)
+        try {
+            const trs = this.inputParams?.transform || {};
+            const p = Array.isArray(trs.position) ? trs.position : [0, 0, 0];
+            const r = Array.isArray(trs.rotationEuler) ? trs.rotationEuler : [0, 0, 0];
+            const s = Array.isArray(trs.scale) ? trs.scale : [1, 1, 1];
+            group.position.set(Number(p[0] || 0), Number(p[1] || 0), Number(p[2] || 0));
+            group.rotation.set(
+                THREE.MathUtils.degToRad(Number(r[0] || 0)),
+                THREE.MathUtils.degToRad(Number(r[1] || 0)),
+                THREE.MathUtils.degToRad(Number(r[2] || 0))
+            );
+            group.scale.set(Number(s[0] || 1), Number(s[1] || 1), Number(s[2] || 1));
+        } catch (_) { /* ignore */ }
+
+        return { added: [group], removed: [] };
+    }
+}

package/src/features/edgeFeatureUtils.js

@@ -0,0 +1,41 @@
+export function collectEdgesFromSelection(inputObjects) {
+  if (!Array.isArray(inputObjects) || inputObjects.length === 0) return [];
+  const edges = [];
+  for (const obj of inputObjects) {
+    if (!obj) continue;
+    if (obj.type === 'EDGE') {
+      edges.push(obj);
+      continue;
+    }
+    if (obj.type === 'FACE' && Array.isArray(obj.edges)) {
+      for (const e of obj.edges) edges.push(e);
+    }
+  }
+  const unique = [];
+  const seen = new Set();
+  for (const edge of edges) {
+    if (!edge || seen.has(edge)) continue;
+    if (!(edge.parentSolid || edge.parent)) continue;
+    seen.add(edge);
+    unique.push(edge);
+  }
+  return unique;
+}
+
+export function resolveSingleSolidFromEdges(edges) {
+  const solids = new Set();
+  if (Array.isArray(edges)) {
+    for (const edge of edges) {
+      const solid = edge?.parentSolid || edge?.parent;
+      if (solid) solids.add(solid);
+    }
+  }
+  const solid = solids.size === 1 ? solids.values().next().value : null;
+  return { solid, solids };
+}
+
+export function getSolidGeometryCounts(solid) {
+  const triCount = Array.isArray(solid?._triVerts) ? (solid._triVerts.length / 3) : 0;
+  const vertCount = Array.isArray(solid?._vertProperties) ? (solid._vertProperties.length / 3) : 0;
+  return { triCount, vertCount };
+}

package/src/features/extrude/ExtrudeFeature.js

@@ -0,0 +1,143 @@
+import { increment } from "three/tsl";
+import { BREP } from "../../BREP/BREP.js";
+import { selectionHasSketch } from "../selectionUtils.js";
+
+const inputParamsSchema = {
+  id: {
+    type: "string",
+    default_value: null,
+    hint: "unique identifier for the extrude feature",
+  },
+  profile: {
+    type: "reference_selection",
+    selectionFilter: ["FACE", "SKETCH"],
+    multiple: false,
+    default_value: null,
+    hint: "Select the profile to extrude",
+  },
+  consumeProfileSketch: {
+    type: "boolean",
+    default_value: true,
+    hint: "Remove the referenced sketch after creating the extrusion. Turn off to keep it in the scene.",
+  },
+  distance: {
+    type: "number",
+    default_value: 1,
+    hint: "Extrude distance when no path is provided",
+  },
+  distanceBack: {
+    type: "number",
+    default_value: 0,
+    hint: "Optional backward extrude distance (two-sided extrude)",
+  },
+  boolean: {
+    type: "boolean_operation",
+    default_value: { targets: [], operation: 'NONE' },
+    hint: "Optional boolean operation with selected solids"
+  }
+};
+
+export class ExtrudeFeature {
+  static shortName = "E";
+  static longName = "Extrude";
+  static inputParamsSchema = inputParamsSchema;
+
+  constructor() {
+    this.inputParams = {};
+    this.persistentData = {};
+  }
+
+  uiFieldsTest(context) {
+    const params = this.inputParams || context?.params || {};
+    const partHistory = context?.history || null;
+    return selectionHasSketch(params.profile, partHistory) ? [] : ["consumeProfileSketch"];
+  }
+
+  async run(partHistory) {
+    // actual code to create the extrude feature.
+    const { profile, distance, distanceBack } = this.inputParams;
+
+    // Resolve profile object: accept FACE object or a SKETCH group object
+    const obj = Array.isArray(profile) ? (profile[0] || null) : (profile || null);
+    let faceObj = obj;
+    if (obj && obj.type === 'SKETCH') {
+      // Find child FACE named PROFILE (or any FACE child)
+      faceObj = obj.children.find(ch => ch.type === 'FACE') || obj.children.find(ch => ch.userData?.faceName);
+    }
+
+    const removed = [];
+    const consumeSketch = this.inputParams?.consumeProfileSketch !== false;
+    // if the face is a child of a sketch we need to remove the sketch from the scene
+    if (consumeSketch && faceObj && faceObj.type === 'FACE' && faceObj.parent && faceObj.parent.type === 'SKETCH') {
+      removed.push(faceObj.parent);
+    }
+
+
+
+    // Create the extrude using the robust Sweep implementation (handles holes and per-edge side faces)
+    // If user requests a UNION with the same solid the profile came from,
+    // bias both directions slightly so the sweep fully overlaps the parent
+    // instead of leaving a coplanar cap on the source face.
+    const op = String(this.inputParams?.boolean?.operation || 'NONE').toUpperCase();
+    const targets = Array.isArray(this.inputParams?.boolean?.targets) ? this.inputParams.boolean.targets : [];
+    const parentSolid = faceObj && faceObj.parent && typeof faceObj.parent.getFaceNames === 'function' ? faceObj.parent : null;
+    const unionTargetsIncludeParent = op === 'UNION' && parentSolid && targets && targets.some(t => t === parentSolid || (typeof t === 'string' && t === parentSolid.name));
+    const forwardBias = (op === 'SUBTRACT' ? 0.00001 : 0) + (op === 'UNION' ? 0.00001 : 0);
+    const backwardBias = unionTargetsIncludeParent ? 0.00001 : 0;
+
+    const extrude = new BREP.Sweep({
+      face: faceObj,
+      distance: distance + forwardBias, // small forward nudge helps avoid z-fighting for boolean ops
+      distanceBack: distanceBack + backwardBias,
+      mode: 'translate',
+      name: this.inputParams.featureID,
+      omitBaseCap: false,
+    });
+    // Attach centerlines for any circular/arc sketch edges in the profile
+    try {
+      const THREE = BREP.THREE;
+      const edges = Array.isArray(faceObj?.edges) ? faceObj.edges : (faceObj?.edges ? Array.from(faceObj.edges) : []);
+      const centers = [];
+      const addCenter = (arr) => {
+        if (!Array.isArray(arr) || arr.length !== 3) return;
+        centers.push(new THREE.Vector3(arr[0], arr[1], arr[2]));
+      };
+      for (const e of edges) {
+        const kind = e?.userData?.sketchGeomType;
+        if (kind === 'arc' && Array.isArray(e?.userData?.arcCenter)) addCenter(e.userData.arcCenter);
+        else if (kind === 'circle' && Array.isArray(e?.userData?.circleCenter)) addCenter(e.userData.circleCenter);
+      }
+      // Deduplicate centers by hashing rounded coords
+      const uniq = new Map();
+      const round = (v)=> Math.round(v*1e6)/1e6;
+      const uniqueCenters = [];
+      for (const c of centers) { const k = `${round(c.x)},${round(c.y)},${round(c.z)}`; if (!uniq.has(k)) { uniq.set(k, true); uniqueCenters.push(c); } }
+
+      if (uniqueCenters.length) {
+        // Compute face normal for direction
+        const n = (typeof faceObj.getAverageNormal === 'function') ? faceObj.getAverageNormal().clone() : new THREE.Vector3(0,1,0);
+        if (n.lengthSq() < 1e-20) n.set(0,1,0); n.normalize();
+        const fwd = n.clone().multiplyScalar(Number(distance) || 0);
+        const back = n.clone().multiplyScalar(-(Number(distanceBack) || 0));
+        let idx = 0;
+        for (const c of uniqueCenters) {
+          const a = new THREE.Vector3(c.x, c.y, c.z).add(back);
+          const b = new THREE.Vector3(c.x, c.y, c.z).add(fwd);
+          if (a.distanceToSquared(b) < 1e-16) continue;
+          const name = (this.inputParams.featureID ? `${this.inputParams.featureID}_AXIS_${idx++}` : 'AXIS');
+          extrude.addCenterline([a.x, a.y, a.z], [b.x, b.y, b.z], name, { materialKey: 'OVERLAY' });
+        }
+      }
+    } catch (_) { /* best-effort centerlines */ }
+    extrude.visualize();
+
+    // Apply optional boolean operation via shared helper
+    const effects = await BREP.applyBooleanOperation(partHistory || {}, extrude, this.inputParams.boolean, this.inputParams.featureID);
+    const booleanRemoved = Array.isArray(effects.removed) ? effects.removed : [];
+    const removedArtifacts = [...removed, ...booleanRemoved];
+    // Flag removals (sketch parent + boolean effects) for PartHistory to collect
+    try { for (const obj of removedArtifacts) { if (obj) obj.__removeFlag = true; } } catch {}
+    const added = Array.isArray(effects.added) ? effects.added : [];
+    return { added, removed: removedArtifacts };
+  }
+}

package/src/features/fillet/FilletFeature.js

@@ -0,0 +1,197 @@
+import { clearFilletCaches } from "../../BREP/fillets/fillet.js";
+import {
+    collectEdgesFromSelection,
+    getSolidGeometryCounts,
+    resolveSingleSolidFromEdges,
+} from "../edgeFeatureUtils.js";
+
+const inputParamsSchema = {
+    id: {
+        type: "string",
+        default_value: null,
+        hint: "unique identifier for the fillet feature",
+    },
+    edges: {
+        type: "reference_selection",
+        selectionFilter: ["FACE", "EDGE"],
+        multiple: true,
+        default_value: null,
+        hint: "Select faces (or an edge) to fillet along shared edges",
+    },
+    radius: {
+        type: "number",
+        step: 0.1,
+        default_value: 1,
+        hint: "Fillet radius",
+    },
+    resolution: {
+        type: "number",
+        step: 1,
+        default_value: 32,
+        hint: "Segments around the fillet tube circumference",
+    },
+    inflate: {
+        type: "number",
+        step: 0.1,
+        default_value: 0.1,
+        hint: "Grow the cutting solid by this amount (units). Keep tiny (e.g. 0.0005). Closed loops ignore inflation to avoid self‑intersection.",
+    },
+    direction: {
+        type: "options",
+        options: ["INSET", "OUTSET"],
+        default_value: "INSET",
+        hint: "Prefer fillet inside (INSET) or outside (OUTSET)",
+    },
+    combineEdges: {
+        type: "boolean",
+        default_value: false,
+        hint: "Combine connected edges into a single fillet path when possible",
+    },
+    showTangentOverlays: {
+        type: "boolean",
+        default_value: false,
+        hint: "Show pre-inflate tangent overlays on the fillet tube",
+    },
+    debug: {
+        type: "boolean",
+        default_value: false,
+        hint: "Draw diagnostic vectors for section frames (u,v, bisector, tangency)",
+    },
+};
+
+export class FilletFeature {
+    static shortName = "F";
+    static longName = "Fillet";
+    static inputParamsSchema = inputParamsSchema;
+
+    constructor() {
+        this.inputParams = {};
+        this.persistentData = {};
+    }
+
+    uiFieldsTest(context) {
+        const params = this.inputParams || context?.params || {};
+        const dir = String(params?.direction || 'INSET').toUpperCase();
+        return dir === 'INSET' ? ['combineEdges'] : [];
+    }
+
+    async run(partHistory) {
+        console.log('[FilletFeature] Starting fillet run...', {
+            featureID: this.inputParams?.featureID,
+            direction: this.inputParams?.direction,
+            combineEdges: this.inputParams?.combineEdges,
+            radius: this.inputParams?.radius,
+            resolution: this.inputParams?.resolution,
+            inflate: this.inputParams?.inflate,
+            showTangentOverlays: this.inputParams?.showTangentOverlays,
+            debug: this.inputParams?.debug,
+        });
+        try { clearFilletCaches(); } catch { }
+        const added = [];
+        const removed = [];
+
+        // Resolve inputs from sanitizeInputParams()
+        const inputObjects = Array.isArray(this.inputParams.edges) ? this.inputParams.edges.filter(Boolean) : [];
+        const edgeObjs = collectEdgesFromSelection(inputObjects);
+        if (edgeObjs.length === 0) {
+            console.warn('[FilletFeature] No edges resolved for fillet feature; aborting.');
+            return { added: [], removed: [] };
+        }
+
+        const { solid: targetSolid, solids } = resolveSingleSolidFromEdges(edgeObjs);
+        if (!targetSolid) {
+            if (solids.size > 1) {
+                console.warn('[FilletFeature] Edges reference multiple solids; aborting fillet.', { solids: Array.from(solids).map(s => s?.name) });
+            } else {
+                console.warn('[FilletFeature] Edges do not reference a target solid; aborting fillet.');
+            }
+            return { added: [], removed: [] };
+        }
+        console.log('[FilletFeature] Target solid resolved', {
+            name: targetSolid?.name,
+            edgeCount: edgeObjs.length,
+            edgeNames: edgeObjs.map(e => e?.name).filter(Boolean),
+        });
+
+        const dir = String(this.inputParams.direction || 'INSET').toUpperCase();
+        const r = Number(this.inputParams.radius);
+        if (!Number.isFinite(r) || !(r > 0)) {
+            console.warn('[FilletFeature] Invalid radius supplied; aborting.', { radius: this.inputParams.radius });
+            return { added: [], removed: [] };
+        }
+
+        const fid = this.inputParams.featureID;
+        let result = null;
+        try {
+            result = await targetSolid.fillet({
+                radius: r,
+                combineEdges: this.inputParams?.combineEdges,
+                resolution: this.inputParams?.resolution,
+                edges: edgeObjs,
+                featureID: fid,
+                direction: dir,
+                inflate: Number(this.inputParams.inflate) || 0,
+                debug: !!this.inputParams.debug,
+                showTangentOverlays: !!this.inputParams.showTangentOverlays,
+                cleanupTinyFaceIslandsArea: this.inputParams?.cleanupTinyFaceIslandsArea,
+            });
+        } catch (err) {
+            console.error('[FilletFeature] Fillet threw an error; attempting to continue with debug solids.', {
+                featureID: fid,
+                error: err?.message || err,
+            });
+        }
+        const collectDebugSolids = (res) => {
+            const out = [];
+            if (!this.inputParams.debug || !Array.isArray(res?.__debugAddedSolids)) return out;
+            for (const dbg of res.__debugAddedSolids) {
+                if (!dbg) continue;
+                try { dbg.name = `${fid}_${dbg.name || 'DEBUG'}`; } catch { }
+                console.log('[FilletFeature] Adding fillet debug solid', { featureID: fid, name: dbg.name });
+                out.push(dbg);
+            }
+            return out;
+        };
+        const debugSolids = collectDebugSolids(result);
+        const { triCount, vertCount } = getSolidGeometryCounts(result);
+        if (!result) {
+            console.error('[FilletFeature] Fillet returned no result; skipping scene replacement.', { featureID: fid });
+            if (debugSolids.length) {
+                console.warn('[FilletFeature] Returning fillet debug solids despite failure.', {
+                    featureID: fid,
+                    debugSolidCount: debugSolids.length,
+                });
+                added.push(...debugSolids);
+            }
+            return { added, removed };
+        }
+        if (triCount === 0 || vertCount === 0) {
+            console.error('[FilletFeature] Fillet produced an empty solid; skipping scene replacement.', {
+                featureID: fid,
+                triangleCount: triCount,
+                vertexCount: vertCount,
+                direction: dir,
+                radius: r,
+                inflate: this.inputParams.inflate,
+            });
+            if (debugSolids.length) {
+                console.warn('[FilletFeature] Returning fillet debug solids despite empty result.', {
+                    featureID: fid,
+                    debugSolidCount: debugSolids.length,
+                });
+                added.push(...debugSolids);
+            }
+            return { added, removed };
+        }
+        console.log('[FilletFeature] Fillet succeeded; replacing target solid.', {
+            featureID: fid,
+            triangles: triCount,
+            vertices: vertCount,
+        });
+        added.push(result);
+        added.push(...debugSolids);
+        // Replace the original geometry in the scene
+        removed.push(targetSolid);
+        return { added, removed };
+    }
+}