brep-io-kernel 1.0.0-ci.9

package/src/features/sheetMetal/SheetMetalFlangeFeature.js

@@ -0,0 +1,1568 @@
+import { BREP } from "../../BREP/BREP.js";
+import {
+  SHEET_METAL_FACE_TYPES,
+  resolveSheetMetalFaceType as resolveSMFaceType,
+  propagateSheetMetalFaceTypesToEdges,
+} from "./sheetMetalFaceTypes.js";
+import { applySheetMetalMetadata } from "./sheetMetalMetadata.js";
+import { normalizeSelectionList } from "../selectionUtils.js";
+import { cleanupSheetMetalOppositeEdgeFaces } from "./sheetMetalCleanup.js";
+import { computeBoundsFromVertices } from "../../BREP/boundsUtils.js";
+import { SheetMetalObject } from "./SheetMetalObject.js";
+import { cloneSheetMetalTree, createSheetMetalFlangeNode } from "./sheetMetalTree.js";
+
+const inputParamsSchema = {
+  id: {
+    type: "string",
+    default_value: null,
+    hint: "Unique identifier for the flange feature",
+  },
+  faces: {
+    type: "reference_selection",
+    selectionFilter: ["FACE"],
+    multiple: true,
+    default_value: null,
+    hint: "Select one or more thin side faces where the flange will be constructed.",
+  },
+  useOppositeCenterline: {
+    label: "Reverse direction",
+    type: "boolean",
+    default_value: false,
+    hint: "Flip to use the opposite edge for the hinge centerline.",
+  },
+  flangeLength: {
+    type: "number",
+    default_value: 10,
+    min: 0,
+    hint: "Placeholder: retained for UI compatibility (currently unused).",
+  },
+  flangeLengthReference: {
+    type: "options",
+    options: ["inside", "outside", "web"],
+    default_value: "outside",
+    hint: "Placeholder: retained for UI compatibility (currently unused).",
+  },
+  angle: {
+    type: "number",
+    default_value: 90,
+    min: 0,
+    max: 180,
+    hint: "Flange angle relative to the parent sheet (0° = flat, 90° = perpendicular).",
+  },
+  inset: {
+    type: "options",
+    options: ["material_inside", "material_outside", "bend_outside"],
+    default_value: "material_inside",
+    hint: "Placeholder: retained for UI compatibility (currently unused).",
+  },
+  reliefWidth: {
+    type: "number",
+    default_value: 0,
+    step: 0.1,
+    min: 0,
+    hint: "Placeholder reserved for future relief cut options.",
+  },
+  bendRadius: {
+    type: "number",
+    default_value: 0,
+    min: 0,
+    hint: "Placeholder reserved for future bend radius overrides.",
+  },
+
+  offset: {
+    type: "number",
+    default_value: 0,
+    hint: "Placeholder reserved for future offset support.",
+  },
+  debugSkipUnion: {
+    type: "boolean",
+    default_value: false,
+    hint: "Debug: Skip boolean union with the parent sheet metal.",
+  },
+};
+
+export class SheetMetalFlangeFeature {
+  static shortName = "SM.F";
+  static longName = "Sheet Metal Flange";
+  static inputParamsSchema = inputParamsSchema;
+  static baseType = "FLANGE";
+  static logTag = "SheetMetalFlange";
+  static defaultAngle = 90;
+  static angleOverride = null;
+  static defaultBendRadius = null;
+
+  constructor() {
+    this.inputParams = {};
+    this.persistentData = {};
+  }
+
+  async run(partHistory) {
+    const FeatureClass = this?.constructor || {};
+    const featureLabel = FeatureClass.longName || "Sheet Metal Flange";
+    const logTag = FeatureClass.logTag || "SheetMetalFlange";
+    const baseType = FeatureClass.baseType || "FLANGE";
+    const defaultAngle = Number.isFinite(FeatureClass.defaultAngle)
+      ? FeatureClass.defaultAngle
+      : 90;
+    const angleOverride = Number.isFinite(FeatureClass.angleOverride)
+      ? FeatureClass.angleOverride
+      : null;
+    const defaultBendRadius = Number.isFinite(FeatureClass.defaultBendRadius)
+      ? FeatureClass.defaultBendRadius
+      : null;
+
+    const faces = resolveSelectedFaces(this.inputParams?.faces, partHistory?.scene);
+    if (!faces.length) {
+      throw new Error(`${featureLabel} requires selecting at least one FACE.`);
+    }
+
+    const parentSolid = findAncestorSolid(faces[0]);
+    const sameParentFaces = faces.filter((face) => findAncestorSolid(face) === parentSolid);
+    if (!parentSolid || sameParentFaces.length !== faces.length) {
+      throw new Error(`${featureLabel} selections must belong to a single sheet metal solid.`);
+    }
+
+    const tree = parentSolid?.userData?.sheetMetalTree
+      || parentSolid?.userData?.sheetMetal?.tree
+      || null;
+
+    if (!tree) {
+      const result = await buildSheetMetalFlangeSolids({
+        params: this.inputParams,
+        partHistory,
+        faces,
+        featureClass: this?.constructor,
+        applyMetadata: true,
+      });
+      this.persistentData = this.persistentData || {};
+      if (result?.persistentData) {
+        this.persistentData.sheetMetal = result.persistentData;
+      }
+      return { added: result.added || [], removed: result.removed || [] };
+    }
+
+    const baseFace = sameParentFaces[0];
+    const parentSolidName = parentSolid?.name || null;
+    const thicknessInfo = resolveThickness(baseFace, parentSolid, partHistory?.metadataManager);
+    const thickness = thicknessInfo?.thickness ?? 1;
+    const baseBendRadius = thicknessInfo?.defaultBendRadius ?? thickness;
+
+    const angleDeg = angleOverride != null ? angleOverride : this.inputParams.angle;
+    const angleFallback = Math.max(0, Math.min(180, defaultAngle));
+    const appliedAngle = Number.isFinite(angleDeg)
+      ? Math.max(0, Math.min(180, angleDeg))
+      : angleFallback;
+    const bendRadiusFallback = defaultBendRadius != null ? defaultBendRadius : 0;
+    const bendRadiusInput = Math.max(0, Number(this.inputParams?.bendRadius ?? bendRadiusFallback));
+    const bendRadiusOverride = bendRadiusInput > 0 ? bendRadiusInput : null;
+    const bendRadiusUsed = bendRadiusOverride ?? baseBendRadius;
+    const useOppositeCenterline = this.inputParams?.useOppositeCenterline === true;
+
+    try {
+      const radiusSource = bendRadiusOverride != null ? "feature_override" : "parent_solid";
+      console.log(`[${logTag}] Bend radius resolved`, {
+        featureId: this.inputParams?.featureID || this.inputParams?.id || null,
+        parentSolid: parentSolidName,
+        bendRadiusInput,
+        baseBendRadius,
+        bendRadiusUsed,
+        radiusSource,
+      });
+    } catch { /* logging best-effort */ }
+
+    let insetOffsetValue = 0;
+    if (this.inputParams?.inset === "material_inside") insetOffsetValue = -bendRadiusUsed - thickness;
+    if (this.inputParams?.inset === "material_outside") insetOffsetValue = -bendRadiusUsed;
+    if (this.inputParams?.inset === "bend_outside") insetOffsetValue = 0;
+    const offsetValue = Number(this.inputParams?.offset ?? 0) + insetOffsetValue;
+
+    const sheetMetalMetadata = {
+      featureID: this.inputParams?.featureID || null,
+      thickness,
+      bendRadius: baseBendRadius,
+      baseType,
+      extra: {
+        angleDegrees: appliedAngle,
+        insetMode: this.inputParams?.inset || null,
+        useOppositeCenterline,
+        offsetValue,
+        bendRadiusOverride,
+        bendRadiusUsed,
+        baseBendRadius,
+      },
+    };
+    const persistentData = {
+      baseType,
+      thickness,
+      bendRadius: bendRadiusUsed,
+      defaultBendRadius: baseBendRadius,
+      bendRadiusOverride,
+      angleDegrees: appliedAngle,
+      insetMode: this.inputParams?.inset || null,
+      useOppositeCenterline,
+      offsetValue,
+    };
+
+    const baseMeta = parentSolid?.userData?.sheetMetal || {};
+    const sheetMetal = new SheetMetalObject({
+      tree,
+      kFactor: baseMeta.neutralFactor ?? parentSolid?.userData?.sheetMetalNeutralFactor ?? null,
+      thickness: baseMeta.thickness ?? parentSolid?.userData?.sheetThickness ?? null,
+      bendRadius: baseMeta.bendRadius ?? parentSolid?.userData?.sheetBendRadius ?? null,
+    });
+    const flangeNode = createSheetMetalFlangeNode({
+      featureID: this.inputParams?.featureID || null,
+      faceRefs: normalizeSelectionList(this.inputParams?.faces),
+      useOppositeCenterline: this.inputParams?.useOppositeCenterline === true,
+      flangeLength: this.inputParams?.flangeLength,
+      flangeLengthReference: this.inputParams?.flangeLengthReference,
+      angle: this.inputParams?.angle,
+      inset: this.inputParams?.inset,
+      reliefWidth: this.inputParams?.reliefWidth,
+      bendRadius: this.inputParams?.bendRadius,
+      offset: this.inputParams?.offset,
+      debugSkipUnion: this.inputParams?.debugSkipUnion === true,
+      baseType,
+      defaultAngle,
+      angleOverride,
+      defaultBendRadius,
+    });
+    sheetMetal.appendNode(flangeNode);
+    await sheetMetal.generate({
+      partHistory,
+      metadataManager: partHistory?.metadataManager,
+      mode: "solid",
+    });
+    if (parentSolidName) {
+      try { sheetMetal.name = parentSolidName; } catch { /* ignore */ }
+    }
+
+    const added = [sheetMetal];
+    let removed = [parentSolid];
+    if (this.inputParams?.debug) removed = [];
+
+    cleanupSheetMetalOppositeEdgeFaces(added);
+    propagateSheetMetalFaceTypesToEdges(added);
+    applySheetMetalMetadata(added, partHistory?.metadataManager, {
+      ...sheetMetalMetadata,
+      forceBaseOverwrite: false,
+    });
+
+    for (const solid of added) {
+      if (!solid) continue;
+      solid.userData = solid.userData || {};
+      solid.userData.sheetMetalTree = cloneSheetMetalTree(sheetMetal.tree);
+      solid.userData.sheetMetalKFactor = sheetMetal.kFactor ?? null;
+    }
+
+    this.persistentData = this.persistentData || {};
+    this.persistentData.sheetMetal = {
+      ...persistentData,
+      tree: sheetMetal.tree,
+    };
+
+    return { added, removed };
+  }
+}
+
+export async function buildSheetMetalFlangeSolids({
+  params,
+  partHistory,
+  faces = null,
+  featureClass = null,
+  applyMetadata = true,
+} = {}) {
+  const FeatureClass = featureClass || {};
+  const featureLabel = FeatureClass.longName || "Sheet Metal Flange";
+  const logTag = FeatureClass.logTag || "SheetMetalFlange";
+  const baseType = FeatureClass.baseType || "FLANGE";
+  const defaultAngle = Number.isFinite(FeatureClass.defaultAngle)
+    ? FeatureClass.defaultAngle
+    : 90;
+  const angleOverride = Number.isFinite(FeatureClass.angleOverride)
+    ? FeatureClass.angleOverride
+    : null;
+  const defaultBendRadius = Number.isFinite(FeatureClass.defaultBendRadius)
+    ? FeatureClass.defaultBendRadius
+    : null;
+
+  const resolvedFaces = Array.isArray(faces)
+    ? faces.filter(Boolean)
+    : resolveSelectedFaces(params?.faces, partHistory?.scene);
+  if (!resolvedFaces.length) {
+    throw new Error(`${featureLabel} requires selecting at least one FACE.`);
+  }
+
+  const featureID = params?.featureID || params?.id || null;
+
+  // Assume all selected faces share the same sheet thickness; resolve it once up front.
+  const baseFace = resolvedFaces[0];
+  const baseParentSolid = findAncestorSolid(baseFace);
+  const parentSolidName = baseParentSolid?.name || null;
+  const thicknessInfo = resolveThickness(baseFace, baseParentSolid, partHistory?.metadataManager);
+  const thickness = thicknessInfo?.thickness ?? 1;
+  const baseBendRadius = thicknessInfo?.defaultBendRadius ?? thickness;
+
+  const angleDeg = angleOverride != null ? angleOverride : params?.angle;
+  const angleFallback = Math.max(0, Math.min(180, defaultAngle));
+  let angle = Number.isFinite(angleDeg) ? Math.max(0, Math.min(180, angleDeg)) : angleFallback;
+  const bendRadiusFallback = defaultBendRadius != null ? defaultBendRadius : 0;
+  const bendRadiusInput = Math.max(0, Number(params?.bendRadius ?? bendRadiusFallback));
+  const bendRadiusOverride = bendRadiusInput > 0 ? bendRadiusInput : null;
+  const bendRadiusUsed = bendRadiusOverride ?? baseBendRadius;
+  const useOppositeCenterline = params?.useOppositeCenterline === true;
+
+  try {
+    const radiusSource = bendRadiusOverride != null ? "feature_override" : "parent_solid";
+    console.log(`[${logTag}] Bend radius resolved`, {
+      featureId: featureID,
+      parentSolid: parentSolidName,
+      bendRadiusInput,
+      baseBendRadius,
+      bendRadiusUsed,
+      radiusSource,
+    });
+  } catch { /* logging best-effort */ }
+
+  const skipUnion = params?.debugSkipUnion === true;
+
+  let insetOffsetValue = 0;
+  if (params?.inset === "material_inside") insetOffsetValue = -bendRadiusUsed - thickness;
+  if (params?.inset === "material_outside") insetOffsetValue = -bendRadiusUsed;
+  if (params?.inset === "bend_outside") insetOffsetValue = 0;
+
+  const offsetValue = Number(params?.offset ?? 0) + insetOffsetValue;
+  const shouldExtrudeOffset = Number.isFinite(offsetValue) && offsetValue !== 0;
+
+  const appliedAngle = angle;
+  const sheetMetalMetadata = {
+    featureID,
+    thickness,
+    bendRadius: baseBendRadius,
+    baseType,
+    extra: {
+      angleDegrees: appliedAngle,
+      insetMode: params?.inset || null,
+      useOppositeCenterline,
+      offsetValue,
+      bendRadiusOverride,
+      bendRadiusUsed,
+      baseBendRadius,
+    },
+  };
+  const persistentData = {
+    baseType,
+    thickness,
+    bendRadius: bendRadiusUsed,
+    defaultBendRadius: baseBendRadius,
+    bendRadiusOverride,
+    angleDegrees: appliedAngle,
+    insetMode: params?.inset || null,
+    useOppositeCenterline,
+    offsetValue,
+  };
+
+  const generatedSolids = [];
+  const parentSolidStates = new Map();
+  const orphanSolids = [];
+  const solidParentNames = new WeakMap();
+  const recordParentName = (solid, parentSolid) => {
+    try {
+      if (solid && parentSolid?.name) solidParentNames.set(solid, parentSolid.name);
+    } catch { /* ignore */ }
+  };
+  const registerSolid = (solid, parentSolid) => {
+    if (!solid) return;
+    generatedSolids.push(solid);
+    if (parentSolid) {
+      const state = getParentState(parentSolidStates, parentSolid);
+      if (state) state.solids.push(solid);
+      recordParentName(solid, parentSolid);
+    } else {
+      orphanSolids.push(solid);
+    }
+  };
+  const subtractRemoved = [];
+  const debugSubtractionSolids = [];
+
+  let faceIndex = 0;
+  for (const face of resolvedFaces) {
+    const context = analyzeFace(face);
+    if (!context) continue;
+    const orientationInfo = resolveABOrientation(face, context);
+    const desiredBendSide = useOppositeCenterline
+      ? SHEET_METAL_FACE_TYPES.B
+      : SHEET_METAL_FACE_TYPES.A;
+
+    const offsetNormal = shouldExtrudeOffset
+      ? resolveOffsetNormal(context, face)
+      : null;
+    const offsetVector = shouldExtrudeOffset
+      ? buildOffsetTranslationVector(offsetNormal || context.baseNormal, offsetValue)
+      : null;
+
+    const targetRadius = bendRadiusUsed;
+    const tolerance = Math.max(1e-4, targetRadius * 0.01);
+    const hingeOptions = [];
+    const primaryHinge = pickCenterlineEdge(face, context, useOppositeCenterline);
+    if (primaryHinge) hingeOptions.push(primaryHinge);
+    const altHinge = pickCenterlineEdge(face, context, !useOppositeCenterline);
+    if (altHinge) hingeOptions.push(altHinge);
+
+    let chosen = null;
+    for (const hingeEdge of hingeOptions) {
+      const defaultOffset = bendRadiusUsed + thickness;
+      const primary = evaluateFlangeCandidate({
+        raw: buildFlangeRevolve({
+          face,
+          context,
+          hingeEdge,
+          appliedAngle,
+          bendRadiusUsed,
+          thickness,
+          offsetVector,
+          featureID,
+          offsetMagnitudeOverride: defaultOffset,
+        }),
+        targetRadius,
+        desiredBendSide,
+        orientationInfo,
+      });
+      chosen = pickBetterFlangeCandidate(chosen, primary);
+
+      if ((primary?.radiusErr ?? Infinity) > tolerance) {
+        const tighter = evaluateFlangeCandidate({
+          raw: buildFlangeRevolve({
+            face,
+            context,
+            hingeEdge,
+            appliedAngle,
+            bendRadiusUsed,
+            thickness,
+            offsetVector,
+            featureID,
+            offsetMagnitudeOverride: bendRadiusUsed,
+          }),
+          targetRadius,
+          desiredBendSide,
+          orientationInfo,
+        });
+        chosen = pickBetterFlangeCandidate(chosen, tighter);
+      }
+      if (chosen?.revolve
+        && (chosen.orientationPenalty ?? 0) === 0
+        && (chosen.radiusErr ?? Infinity) <= tolerance) {
+        break;
+      }
+    }
+
+    if (!chosen?.revolve) continue;
+
+    const revolve = chosen.revolve;
+    const bendEndFace = chosen.bendEndFace;
+    registerSolid(revolve, context.parentSolid);
+
+    const zFightNudge = Math.max(1e-6, Math.min(0.001, thickness * 0.0001));
+
+    if (offsetVector) {
+      const useForSubtraction = offsetValue < 0 && !!context.parentSolid;
+      // Avoid inflating the subtraction cutter; it creates visible clearance gaps.
+      const reliefPushDistance = useForSubtraction ? 0 : zFightNudge;
+      const offsetSolid = createOffsetExtrudeSolid({
+        face,
+        faceNormal: offsetNormal || context.baseNormal,
+        lengthValue: offsetValue,
+        featureID,
+        faceIndex,
+        applyReliefPush: !useForSubtraction,
+        reliefPushDistance,
+        reliefPushNormal: context.baseNormal,
+      });
+      if (offsetSolid) {
+        let usedForSubtraction = false;
+        if (useForSubtraction) {
+          const state = getParentState(parentSolidStates, context.parentSolid);
+          const subtractionTarget = state?.target || context.parentSolid;
+          if (subtractionTarget) {
+            try {
+              const subtraction = await BREP.applyBooleanOperation(
+                partHistory || {},
+                offsetSolid,
+                { operation: "SUBTRACT", targets: [subtractionTarget] },
+                featureID,
+              );
+              if (Array.isArray(subtraction?.removed)) subtractRemoved.push(...subtraction.removed);
+              const replacement = pickReplacementSolid(subtraction?.added);
+              if (replacement) {
+                state.target = replacement;
+                usedForSubtraction = true;
+              }
+            } catch {
+              usedForSubtraction = false;
+            }
+          }
+        }
+        if (usedForSubtraction && skipUnion) {
+          debugSubtractionSolids.push(offsetSolid);
+        }
+        if (!usedForSubtraction) {
+          registerSolid(offsetSolid, context.parentSolid);
+        }
+      }
+    }
+    const flangeRef = String(params?.flangeLengthReference || "web").toLowerCase();
+    let flangeLength = Number(params?.flangeLength ?? 0);
+    if (!Number.isFinite(flangeLength)) flangeLength = 0;
+    if (flangeRef === "inside") flangeLength = flangeLength - bendRadiusUsed;
+    if (flangeRef === "outside") flangeLength = flangeLength - bendRadiusUsed - thickness;
+    if (flangeRef === "web") flangeLength = flangeLength;
+    if (bendEndFace && Number.isFinite(flangeLength) && flangeLength !== 0) {
+      const flatSolid = createOffsetExtrudeSolid({
+        face: bendEndFace,
+        faceNormal: bendEndFace?.getAverageNormal ? bendEndFace.getAverageNormal() : null,
+        lengthValue: flangeLength,
+        featureID,
+        faceIndex,
+        reliefPushDistance: zFightNudge,
+      });
+      if (flatSolid) {
+        if (offsetVector) {
+          applyTranslationToSolid(flatSolid, offsetVector);
+        }
+        registerSolid(flatSolid, context.parentSolid);
+      }
+    }
+    faceIndex++;
+  }
+
+  if (!generatedSolids.length) {
+    throw new Error(`${featureLabel} failed to generate any geometry for the selected faces.`);
+  }
+
+  if (skipUnion || parentSolidStates.size === 0) {
+    const added = skipUnion && debugSubtractionSolids.length
+      ? [...generatedSolids, ...debugSubtractionSolids]
+      : generatedSolids;
+    cleanupSheetMetalOppositeEdgeFaces(added);
+    if (applyMetadata) {
+      applySheetMetalMetadata(added, partHistory?.metadataManager, sheetMetalMetadata);
+    }
+    return { added, removed: subtractRemoved, persistentData };
+  }
+
+  const unionResults = [];
+  const unionRemoved = [];
+  const fallbackSolids = [...orphanSolids];
+  let groupIndex = 0;
+
+  for (const state of parentSolidStates.values()) {
+    const parentSolid = state?.target || state?.original;
+    const solids = state?.solids || [];
+    if (!parentSolid || !Array.isArray(solids) || !solids.length) continue;
+    const baseSolid = solids.length === 1
+      ? solids[0]
+      : combineSolids({
+        solids,
+        featureID,
+        groupIndex: groupIndex++,
+      });
+    recordParentName(baseSolid, parentSolid);
+    if (!baseSolid) {
+      fallbackSolids.push(...solids);
+      continue;
+    }
+
+    let unionSucceeded = false;
+    try {
+      const effects = await BREP.applyBooleanOperation(
+        partHistory || {},
+        baseSolid,
+        { operation: "UNION", targets: [parentSolid] },
+        featureID,
+      );
+      if (Array.isArray(effects?.added)) {
+        for (const addedSolid of effects.added) {
+          if (parentSolid?.name) setSolidNameSafe(addedSolid, parentSolid.name);
+          recordParentName(addedSolid, parentSolid);
+        }
+        unionResults.push(...effects.added);
+      }
+      if (Array.isArray(effects?.removed)) unionRemoved.push(...effects.removed);
+      unionSucceeded = Array.isArray(effects?.removed)
+        && effects.removed.some((solid) => solidsMatch(solid, parentSolid));
+    } catch {
+      unionSucceeded = false;
+    }
+
+    if (!unionSucceeded) {
+      fallbackSolids.push(...solids);
+    }
+  }
+
+  const finalAdded = [];
+  if (unionResults.length) finalAdded.push(...unionResults);
+  if (fallbackSolids.length) finalAdded.push(...fallbackSolids);
+  if (!finalAdded.length) finalAdded.push(...generatedSolids);
+
+  // Preserve parent solid names on outputs derived from that parent.
+  for (const state of parentSolidStates.values()) {
+    const parentName = state?.original?.name;
+    if (!parentName || !Array.isArray(state?.solids)) continue;
+    const known = new Set(state.solids);
+    for (const solid of finalAdded) {
+      if (known.has(solid)) setSolidNameSafe(solid, parentName);
+    }
+  }
+  for (const solid of finalAdded) {
+    const name = solidParentNames.get(solid);
+    if (name) setSolidNameSafe(solid, name);
+  }
+
+  cleanupSheetMetalOppositeEdgeFaces(finalAdded);
+  if (applyMetadata) {
+    applySheetMetalMetadata(finalAdded, partHistory?.metadataManager, sheetMetalMetadata);
+  }
+
+  // Ensure final solids keep the original parent solid name (never the feature ID).
+  for (const solid of finalAdded) {
+    if (parentSolidName) setSolidNameSafe(solid, parentSolidName);
+  }
+
+  let removed = [...subtractRemoved, ...unionRemoved];
+
+  if (params?.debug) removed = [];
+
+  return { added: finalAdded, removed, persistentData };
+}
+
+function resolveSelectedFaces(selectionRefs, scene) {
+  const refs = Array.isArray(selectionRefs) ? selectionRefs : (selectionRefs ? [selectionRefs] : []);
+  const out = [];
+  for (const ref of refs) {
+    let face = ref;
+    if (typeof face === "string" && scene?.getObjectByName) {
+      face = scene.getObjectByName(face);
+    }
+    if (!face || face.type !== "FACE") continue;
+    out.push(face);
+  }
+  return out;
+}
+
+function analyzeFace(face) {
+  try {
+    if (!face || face.type !== "FACE") return null;
+    const THREE = BREP.THREE;
+    const loops = Array.isArray(face?.userData?.boundaryLoopsWorld) ? face.userData.boundaryLoopsWorld : null;
+    const outer = loops?.find((loop) => !loop?.isHole) || loops?.[0];
+    const rawPoints = Array.isArray(outer?.pts) ? outer.pts : null;
+    const points = rawPoints && rawPoints.length
+      ? rawPoints.map((p) => new THREE.Vector3(p[0], p[1], p[2]))
+      : extractFacePointsFromGeometry(face);
+    if (!points || points.length < 2) return null;
+
+    const baseNormal = (typeof face.getAverageNormal === "function")
+      ? face.getAverageNormal().clone()
+      : new THREE.Vector3(0, 0, 1);
+    if (baseNormal.lengthSq() < 1e-10) baseNormal.set(0, 0, 1);
+    baseNormal.normalize();
+
+    const origin = points.reduce((acc, pt) => acc.add(pt), new THREE.Vector3()).multiplyScalar(1 / points.length);
+    let axisGuess = points[points.length - 1].clone().sub(points[0]);
+    axisGuess.sub(baseNormal.clone().multiplyScalar(axisGuess.dot(baseNormal)));
+    if (axisGuess.lengthSq() < 1e-10) {
+      axisGuess = new THREE.Vector3().crossVectors(baseNormal, new THREE.Vector3(1, 0, 0));
+    }
+    if (axisGuess.lengthSq() < 1e-10) {
+      axisGuess = new THREE.Vector3().crossVectors(baseNormal, new THREE.Vector3(0, 1, 0));
+    }
+    axisGuess.normalize();
+    let perpGuess = new THREE.Vector3().crossVectors(baseNormal, axisGuess).normalize();
+    if (perpGuess.lengthSq() < 1e-10) {
+      perpGuess = new THREE.Vector3().crossVectors(baseNormal, new THREE.Vector3(0, 0, 1)).normalize();
+    }
+
+    const projectSpan = (axis) => {
+      let min = Infinity;
+      let max = -Infinity;
+      for (const pt of points) {
+        const value = pt.clone().sub(origin).dot(axis);
+        if (value < min) min = value;
+        if (value > max) max = value;
+      }
+      return { min, max, span: max - min };
+    };
+
+    let tangent = axisGuess.clone();
+    let tangentSpan = projectSpan(tangent);
+    let secondaryAxis = perpGuess.clone();
+    let secondarySpan = projectSpan(secondaryAxis);
+    if (secondarySpan.span > tangentSpan.span) {
+      tangent = secondaryAxis.clone();
+      tangentSpan = secondarySpan;
+      secondaryAxis = axisGuess.clone();
+      secondarySpan = projectSpan(secondaryAxis);
+    }
+    if (tangentSpan.span < 1e-6) return null;
+
+    tangent.normalize();
+    let sheetDir = new THREE.Vector3().crossVectors(baseNormal, tangent).normalize();
+    const orientOrigin = origin.clone();
+    sheetDir = orientSheetDir(face, sheetDir, orientOrigin);
+    const sheetSpan = projectSpan(sheetDir);
+
+    const hingeStart = origin.clone()
+      .add(tangent.clone().multiplyScalar(tangentSpan.min))
+      .add(sheetDir.clone().multiplyScalar(sheetSpan.max));
+    const hingeEnd = origin.clone()
+      .add(tangent.clone().multiplyScalar(tangentSpan.max))
+      .add(sheetDir.clone().multiplyScalar(sheetSpan.max));
+
+    return {
+      hingeLine: { start: hingeStart, end: hingeEnd },
+      baseNormal,
+      sheetDir,
+      sheetSpan,
+      origin,
+      parentSolid: findAncestorSolid(face),
+    };
+  } catch {
+    return null;
+  }
+}
+
+function resolveOffsetNormal(context, face) {
+  const THREE = BREP.THREE;
+  const baseNormal = (context?.baseNormal && typeof context.baseNormal.clone === "function")
+    ? context.baseNormal.clone()
+    : (typeof face?.getAverageNormal === "function"
+      ? face.getAverageNormal().clone()
+      : new THREE.Vector3(0, 0, 1));
+  if (!baseNormal || baseNormal.lengthSq() < 1e-12) return null;
+  baseNormal.normalize();
+
+  const parentSolid = context?.parentSolid || findAncestorSolid(face);
+  const faceCenter = context?.origin?.clone?.() || computeFaceCenter(face);
+  const solidCenter = computeSolidCenter(parentSolid);
+  if (faceCenter && solidCenter) {
+    const toCenter = solidCenter.clone().sub(faceCenter);
+    if (toCenter.lengthSq() > 1e-12) {
+      const dot = baseNormal.dot(toCenter);
+      if (Math.abs(dot) > 1e-9 && dot < 0) {
+        baseNormal.multiplyScalar(-1);
+      }
+    }
+  }
+  return baseNormal;
+}
+
+function computeSolidCenter(solid) {
+  if (!solid) return null;
+  const THREE = BREP.THREE;
+  let center = null;
+  let fromLocal = false;
+  try {
+    const verts = solid._vertProperties || null;
+    const bounds = computeBoundsFromVertices(verts);
+    if (bounds) {
+      center = new THREE.Vector3(
+        (bounds.min[0] + bounds.max[0]) * 0.5,
+        (bounds.min[1] + bounds.max[1]) * 0.5,
+        (bounds.min[2] + bounds.max[2]) * 0.5,
+      );
+      fromLocal = true;
+    }
+  } catch { /* best effort */ }
+
+  if (!center) {
+    try {
+      const box = new THREE.Box3().setFromObject(solid);
+      if (box && box.min && box.max) {
+        center = new THREE.Vector3(
+          (box.min.x + box.max.x) * 0.5,
+          (box.min.y + box.max.y) * 0.5,
+          (box.min.z + box.max.z) * 0.5,
+        );
+      }
+    } catch { /* ignore */ }
+  }
+
+  if (center && fromLocal) {
+    try {
+      if (solid.matrixWorld) center.applyMatrix4(solid.matrixWorld);
+    } catch { /* ignore */ }
+  }
+
+  return center;
+}
+
+function extractFacePointsFromGeometry(face) {
+  const pts = [];
+  try {
+    const pos = face?.geometry?.getAttribute?.("position");
+    if (!pos) return pts;
+    const THREE = BREP.THREE;
+    const v = new THREE.Vector3();
+    for (let i = 0; i < pos.count; i++) {
+      v.set(pos.getX(i), pos.getY(i), pos.getZ(i)).applyMatrix4(face.matrixWorld);
+      pts.push(v.clone());
+    }
+  } catch { /* best effort */ }
+  return pts;
+}
+
+function findAncestorSolid(obj) {
+  let current = obj;
+  while (current) {
+    if (current.type === "SOLID") return current;
+    current = current.parent;
+  }
+  return null;
+}
+
+function resolveThickness(face, parentSolid, metadataManager) {
+  const thicknessCandidates = [];
+  const radiusCandidates = [];
+  const metaSources = [];
+  const metaKeys = new Set();
+  const pushMeta = (key) => {
+    if (!key || !metadataManager || typeof metadataManager.getOwnMetadata !== "function") return;
+    const normalized = String(key).trim();
+    if (!normalized || metaKeys.has(normalized)) return;
+    metaKeys.add(normalized);
+    const entry = metadataManager.getOwnMetadata(normalized);
+    if (entry && typeof entry === "object") metaSources.push(entry);
+  };
+  pushMeta(parentSolid?.name);
+  pushMeta(parentSolid?.userData?.sheetMetal?.featureID);
+  pushMeta(parentSolid?.owningFeatureID);
+  pushMeta(face?.name);
+  pushMeta(face?.userData?.sheetMetal?.featureID);
+  pushMeta(face?.owningFeatureID);
+
+  const addIfValid = (arr, value, validator) => {
+    const num = Number(value);
+    if (validator(num)) arr.push(num);
+  };
+
+  for (const meta of metaSources) {
+    addIfValid(thicknessCandidates, meta?.sheetMetalThickness, (v) => Number.isFinite(v) && v > 0);
+  }
+  addIfValid(thicknessCandidates, face?.userData?.sheetThickness, (v) => Number.isFinite(v) && v > 0);
+  addIfValid(thicknessCandidates, parentSolid?.userData?.sheetThickness, (v) => Number.isFinite(v) && v > 0);
+  addIfValid(thicknessCandidates, face?.userData?.sheetMetal?.baseThickness, (v) => Number.isFinite(v) && v > 0);
+  addIfValid(thicknessCandidates, parentSolid?.userData?.sheetMetal?.baseThickness, (v) => Number.isFinite(v) && v > 0);
+  addIfValid(thicknessCandidates, parentSolid?.userData?.sheetMetal?.thickness, (v) => Number.isFinite(v) && v > 0);
+  const thicknessVal = thicknessCandidates.find((t) => Number.isFinite(t) && t > 0);
+  const thickness = thicknessVal ? Number(thicknessVal) : 1;
+
+  // Prefer base bend radius first so overrides never change the base attribute chain.
+  for (const meta of metaSources) {
+    addIfValid(radiusCandidates, meta?.sheetMetalBendRadius, (v) => Number.isFinite(v) && v >= 0);
+  }
+  addIfValid(radiusCandidates, face?.userData?.sheetMetal?.baseBendRadius, (v) => Number.isFinite(v) && v >= 0);
+  addIfValid(radiusCandidates, parentSolid?.userData?.sheetMetal?.baseBendRadius, (v) => Number.isFinite(v) && v >= 0);
+  addIfValid(radiusCandidates, parentSolid?.userData?.sheetMetal?.bendRadius, (v) => Number.isFinite(v) && v >= 0);
+  addIfValid(radiusCandidates, face?.userData?.sheetMetal?.bendRadius, (v) => Number.isFinite(v) && v >= 0);
+  addIfValid(radiusCandidates, parentSolid?.userData?.sheetBendRadius, (v) => Number.isFinite(v) && v >= 0);
+  addIfValid(radiusCandidates, face?.userData?.sheetBendRadius, (v) => Number.isFinite(v) && v >= 0);
+  const radiusVal = radiusCandidates.find((r) => Number.isFinite(r) && r >= 0);
+  const defaultBendRadius = radiusVal != null ? Number(radiusVal) : thickness;
+  return { thickness, defaultBendRadius };
+}
+
+function pickCenterlineEdge(face, context, useOppositeEdge) {
+  const sheetDir = context.sheetDir.clone().normalize();
+  const origin = context.origin.clone();
+  const sheetSpan = context.sheetSpan || { min: -1, max: 1 };
+  const segments = collectFaceEdgeSegments(face);
+  const targetFaceType = useOppositeEdge
+    ? SHEET_METAL_FACE_TYPES.B
+    : SHEET_METAL_FACE_TYPES.A;
+  if (!segments.length) {
+    const fallback = context.hingeLine;
+    return fallback
+      ? { start: fallback.start.clone(), end: fallback.end.clone(), target: useOppositeEdge ? "MAX" : "MIN" }
+      : null;
+  }
+
+  const alignmentThreshold = 0.5;
+  const notThicknessEdges = segments.filter((seg) => {
+    const dir = seg.end.clone().sub(seg.start).normalize();
+    const alignment = Math.abs(dir.dot(sheetDir));
+    return alignment < alignmentThreshold;
+  });
+  const candidates = notThicknessEdges.length ? notThicknessEdges : segments;
+  const sheetTagged = candidates.filter((seg) => seg.sheetFaceType === targetFaceType);
+  const adjacentMatches = !sheetTagged.length
+    ? candidates.filter((seg) => Array.isArray(seg.adjacentSheetFaceTypes)
+      && seg.adjacentSheetFaceTypes.includes(targetFaceType))
+    : sheetTagged;
+  const anySheetSegments = adjacentMatches.length
+    ? adjacentMatches
+    : candidates.filter((seg) => !!seg.sheetFaceType);
+  const pool = anySheetSegments.length ? anySheetSegments : candidates;
+  const targetValue = useOppositeEdge ? sheetSpan.max : sheetSpan.min;
+  const midPlane = (sheetSpan.min + sheetSpan.max) * 0.5;
+
+  let best = null;
+  let bestScore = Infinity;
+  for (const seg of pool) {
+    const mid = seg.start.clone().add(seg.end).multiplyScalar(0.5);
+    const value = mid.clone().sub(origin).dot(sheetDir);
+    const score = Math.abs(value - targetValue);
+    if (score < bestScore) {
+      bestScore = score;
+      best = {
+        start: seg.start.clone(),
+        end: seg.end.clone(),
+        target: value < midPlane ? "MIN" : "MAX",
+      };
+    }
+  }
+  return best;
+}
+
+function collectFaceEdgeSegments(face) {
+  const result = [];
+  const edges = Array.isArray(face?.edges) ? face.edges : [];
+  for (const edge of edges) {
+    const pts = extractEdgePolyline(edge);
+    if (pts.length < 2) continue;
+    const start = pts[0];
+    const end = pts[pts.length - 1];
+    const length = start.distanceTo(end);
+    const adjacency = classifyEdgeSheetMetalTypes(edge, face);
+    result.push({
+      start,
+      end,
+      length,
+      sourceEdge: edge,
+      sheetFaceType: adjacency.primaryType,
+      adjacentSheetFaceTypes: adjacency.adjacentTypes,
+    });
+  }
+  return result;
+}
+
+function extractEdgePolyline(edge) {
+  const pts = [];
+  if (!edge) return pts;
+  const tmp = new BREP.THREE.Vector3();
+  const local = Array.isArray(edge?.userData?.polylineLocal) ? edge.userData.polylineLocal : null;
+  const isWorld = !!edge?.userData?.polylineWorld;
+  if (local && local.length >= 2) {
+    for (const pt of local) {
+      if (isWorld) {
+        pts.push(new BREP.THREE.Vector3(pt[0], pt[1], pt[2]));
+      } else {
+        tmp.set(pt[0], pt[1], pt[2]).applyMatrix4(edge.matrixWorld);
+        pts.push(tmp.clone());
+      }
+    }
+    return pts;
+  }
+
+  const pos = edge?.geometry?.getAttribute?.("position");
+  if (pos && pos.itemSize === 3 && pos.count >= 2) {
+    for (let i = 0; i < pos.count; i++) {
+      tmp.set(pos.getX(i), pos.getY(i), pos.getZ(i)).applyMatrix4(edge.matrixWorld);
+      pts.push(tmp.clone());
+    }
+  }
+  return pts;
+}
+
+function orientSheetDir(face, sheetDir, originFallback) {
+  const origin = originFallback || computeFaceCenter(face) || new BREP.THREE.Vector3();
+  const neighbors = new Set();
+  for (const edge of face?.edges || []) {
+    if (!edge?.faces) continue;
+    for (const neighbor of edge.faces) {
+      if (neighbor && neighbor !== face) neighbors.add(neighbor);
+    }
+  }
+  for (const neighbor of neighbors) {
+    const normal = typeof neighbor.getAverageNormal === "function"
+      ? neighbor.getAverageNormal().clone()
+      : null;
+    if (!normal || normal.lengthSq() < 1e-10) continue;
+    normal.normalize();
+    const alignment = Math.abs(normal.dot(sheetDir));
+    if (alignment > 0.9) {
+      const neighborCenter = computeFaceCenter(neighbor);
+      if (!neighborCenter) continue;
+      const toNeighbor = neighborCenter.clone().sub(origin);
+      if (toNeighbor.dot(sheetDir) < 0) {
+        sheetDir.multiplyScalar(-1);
+      }
+      break;
+    }
+  }
+  return sheetDir;
+}
+
+function computeFaceCenter(face) {
+  try {
+    const pos = face?.geometry?.getAttribute?.("position");
+    if (pos && pos.count >= 1) {
+      const v = new BREP.THREE.Vector3();
+      const center = new BREP.THREE.Vector3();
+      for (let i = 0; i < pos.count; i++) {
+        v.set(pos.getX(i), pos.getY(i), pos.getZ(i)).applyMatrix4(face.matrixWorld);
+        center.add(v);
+      }
+      return center.multiplyScalar(1 / pos.count);
+    }
+  } catch { /* ignore */ }
+  const loops = Array.isArray(face?.userData?.boundaryLoopsWorld) ? face.userData.boundaryLoopsWorld : null;
+  const loop = loops?.find((l) => Array.isArray(l?.pts) && l.pts.length);
+  if (loop) {
+    const center = new BREP.THREE.Vector3();
+    let count = 0;
+    for (const pt of loop.pts) {
+      center.add(new BREP.THREE.Vector3(pt[0], pt[1], pt[2]));
+      count++;
+    }
+    if (count) {
+      return center.multiplyScalar(1 / count);
+    }
+  }
+  return null;
+}
+
+function collectNeighborFaces(face) {
+  const neighbors = new Set();
+  for (const edge of face?.edges || []) {
+    if (!edge?.faces) continue;
+    for (const neighbor of edge.faces) {
+      if (neighbor && neighbor !== face) neighbors.add(neighbor);
+    }
+  }
+  return Array.from(neighbors);
+}
+
+function resolveABOrientation(face, context) {
+  try {
+    const THREE = BREP.THREE;
+    const origin = context?.origin?.clone?.() || computeFaceCenter(face) || new THREE.Vector3();
+    const neighbors = collectNeighborFaces(face);
+    let centerA = null;
+    let centerB = null;
+    let countA = 0;
+    let countB = 0;
+    let normalA = null;
+    let normalB = null;
+    const accumulate = (acc, vec) => {
+      if (!vec || typeof vec.clone !== "function") return acc;
+      const clone = vec.clone();
+      if (clone.lengthSq && clone.lengthSq() < 1e-12) return acc;
+      return acc ? acc.add(clone) : clone;
+    };
+    for (const neighbor of neighbors) {
+      const type = resolveSMFaceType(neighbor);
+      if (type !== SHEET_METAL_FACE_TYPES.A && type !== SHEET_METAL_FACE_TYPES.B) continue;
+      const center = computeFaceCenter(neighbor);
+      const normal = typeof neighbor.getAverageNormal === "function"
+        ? neighbor.getAverageNormal().clone()
+        : null;
+      if (type === SHEET_METAL_FACE_TYPES.A) {
+        if (center) { centerA = accumulate(centerA, center); countA++; }
+        if (normal) normalA = accumulate(normalA, normal);
+      } else if (type === SHEET_METAL_FACE_TYPES.B) {
+        if (center) { centerB = accumulate(centerB, center); countB++; }
+        if (normal) normalB = accumulate(normalB, normal);
+      }
+    }
+    const average = (vec, count) => (vec && count ? vec.multiplyScalar(1 / count) : null);
+    centerA = average(centerA, countA);
+    centerB = average(centerB, countB);
+    if (normalA && normalA.lengthSq() > 1e-12) normalA.normalize(); else normalA = null;
+    if (normalB && normalB.lengthSq() > 1e-12) normalB.normalize(); else normalB = null;
+
+    let dir = null;
+    if (centerA && centerB) {
+      dir = centerA.clone().sub(centerB);
+    } else if (centerA && normalA) {
+      dir = normalA.clone();
+    } else if (centerB && normalB) {
+      dir = normalB.clone().multiplyScalar(-1);
+    }
+    if (dir && dir.lengthSq() > 1e-12) {
+      dir.normalize();
+    } else {
+      dir = null;
+    }
+
+    if (!dir && !centerA && !centerB) return null;
+    return {
+      dir,
+      origin,
+      hasA: countA > 0,
+      hasB: countB > 0,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function buildAxisEdge(start, end, featureID) {
+  const geom = new BREP.THREE.BufferGeometry();
+  const positions = new Float32Array([
+    start.x, start.y, start.z,
+    end.x, end.y, end.z,
+  ]);
+  geom.setAttribute("position", new BREP.THREE.BufferAttribute(positions, 3));
+  const edge = new BREP.Edge(geom);
+  edge.name = featureID ? `${featureID}:AXIS` : "SM.FLANGE_AXIS";
+  edge.userData = {
+    polylineLocal: [
+      [start.x, start.y, start.z],
+      [end.x, end.y, end.z],
+    ],
+    polylineWorld: true,
+  };
+  edge.matrixWorld = new BREP.THREE.Matrix4();
+  edge.updateWorldMatrix = () => { };
+  return edge;
+}
+
+function classifyEdgeSheetMetalTypes(edge, sourceFace) {
+  const adjacentTypes = new Set();
+  const neighbors = Array.isArray(edge?.faces) ? edge.faces : [];
+  for (const neighbor of neighbors) {
+    if (!neighbor || neighbor === sourceFace) continue;
+    const type = resolveSMFaceType(neighbor);
+    if (type) adjacentTypes.add(type);
+  }
+
+  const hasA = adjacentTypes.has(SHEET_METAL_FACE_TYPES.A);
+  const hasB = adjacentTypes.has(SHEET_METAL_FACE_TYPES.B);
+  let primaryType = null;
+  if (hasA && !hasB) {
+    primaryType = SHEET_METAL_FACE_TYPES.A;
+  } else if (hasB && !hasA) {
+    primaryType = SHEET_METAL_FACE_TYPES.B;
+  }
+
+  return {
+    primaryType,
+    adjacentTypes: Array.from(adjacentTypes),
+  };
+}
+
+function getParentState(stateMap, parentSolid) {
+  if (!parentSolid || !stateMap) return null;
+  let state = stateMap.get(parentSolid);
+  if (!state) {
+    state = { original: parentSolid, target: parentSolid, solids: [] };
+    stateMap.set(parentSolid, state);
+  }
+  return state;
+}
+
+function pickReplacementSolid(addedList) {
+  if (!Array.isArray(addedList) || !addedList.length) return null;
+  for (const solid of addedList) {
+    if (solid) return solid;
+  }
+  return null;
+}
+
+function applyTranslationToSolid(solid, vector) {
+  if (!solid || !vector || typeof vector.x !== "number" || typeof vector.y !== "number" || typeof vector.z !== "number") {
+    return;
+  }
+  try {
+    if (typeof solid.bakeTransform === "function") {
+      const translation = new BREP.THREE.Matrix4().makeTranslation(vector.x, vector.y, vector.z);
+      solid.bakeTransform(translation);
+      return;
+    }
+  } catch { /* fallthrough to try Object3D translation */ }
+  try {
+    if (typeof solid.applyMatrix4 === "function") {
+      const translation = new BREP.THREE.Matrix4().makeTranslation(vector.x, vector.y, vector.z);
+      solid.applyMatrix4(translation);
+      return;
+    }
+  } catch { /* ignore */ }
+  try {
+    if (solid.position && typeof solid.position.add === "function") {
+      solid.position.add(vector);
+    }
+  } catch { /* ignore */ }
+}
+
+function buildOffsetTranslationVector(baseNormal, offsetValue) {
+  if (!Number.isFinite(offsetValue) || offsetValue === 0) return null;
+  const THREE = BREP.THREE;
+  const normal = (baseNormal && typeof baseNormal.clone === "function" && baseNormal.lengthSq() > 1e-12)
+    ? baseNormal.clone()
+    : new THREE.Vector3(0, 0, 1);
+  if (!normal || normal.lengthSq() < 1e-12) return null;
+  normal.normalize();
+  const vector = normal.multiplyScalar(-offsetValue);
+  if (vector.lengthSq() < 1e-18) return null;
+  return vector;
+}
+
+function findRevolveEndFace(revolveSolid) {
+  if (!revolveSolid || !Array.isArray(revolveSolid.faces)) return null;
+  for (const face of revolveSolid.faces) {
+    const meta = typeof face.getMetadata === "function" ? face.getMetadata() : null;
+    if (meta?.faceType === "ENDCAP") return face;
+  }
+  return revolveSolid.faces[revolveSolid.faces.length - 1] || null;
+}
+
+function createOffsetExtrudeSolid(params = {}) {
+  const {
+    face,
+    faceNormal,
+    lengthValue,
+    featureID,
+    faceIndex,
+    applyReliefPush = true,
+    reliefPushDistance = null,
+    reliefPushNormal = null,
+  } = params;
+  if (!face || !Number.isFinite(lengthValue) || lengthValue === 0) return null;
+  const THREE = BREP.THREE;
+  const normal = (faceNormal && typeof faceNormal.clone === "function" && faceNormal.lengthSq() > 1e-12)
+    ? faceNormal.clone()
+    : (typeof face?.getAverageNormal === "function"
+      ? face.getAverageNormal().clone()
+      : new THREE.Vector3(0, 0, 1));
+  if (!normal || normal.lengthSq() < 1e-12) return null;
+  normal.normalize();
+
+  // This is working correctly. Don't change how it inverts the lengthValue.
+  const distance = normal.multiplyScalar(-lengthValue);
+  if (distance.lengthSq() < 1e-18) return null;
+  const suffix = Number.isFinite(faceIndex) ? `:${faceIndex}` : "";
+  const sweep = new BREP.Sweep({
+    face,
+    distance,
+    mode: "translate",
+    name: featureID ? `${featureID}:OFFSET${suffix}` : "SM.FLANGE_OFFSET",
+    omitBaseCap: false,
+  });
+  sweep.visualize();
+
+  applyFaceSheetMetalData(face, sweep);
+
+  const tinyPush = Number.isFinite(reliefPushDistance)
+    ? Math.max(0, reliefPushDistance)
+    : 0;
+  let pushNormal = null;
+  if (reliefPushNormal && typeof reliefPushNormal.clone === "function") {
+    pushNormal = reliefPushNormal.clone();
+  } else if (reliefPushNormal && Number.isFinite(reliefPushNormal.x)) {
+    pushNormal = new THREE.Vector3(reliefPushNormal.x, reliefPushNormal.y, reliefPushNormal.z);
+  }
+  if (pushNormal && pushNormal.lengthSq() > 1e-12) pushNormal.normalize();
+  else pushNormal = null;
+
+  // use the solid.pushFace() method to nudge the A/B faces outward by a tiny amount to avoid z-fighting
+  if (applyReliefPush && 0 > lengthValue && tinyPush > 0) {
+    for (const solidFace of sweep.faces) {
+      const faceMetadata = solidFace.getMetadata();
+      if (faceMetadata?.faceType === "STARTCAP" || faceMetadata?.faceType === "ENDCAP") continue;
+      const sheetType = faceMetadata?.sheetMetalFaceType;
+      let shouldPush = sheetType === SHEET_METAL_FACE_TYPES.A || sheetType === SHEET_METAL_FACE_TYPES.B;
+      if (!shouldPush && pushNormal && typeof solidFace.getAverageNormal === "function") {
+        const faceNormal = solidFace.getAverageNormal();
+        if (faceNormal && faceNormal.lengthSq() > 1e-12) {
+          faceNormal.normalize();
+          const align = Math.abs(faceNormal.dot(pushNormal));
+          if (align > 0.95) shouldPush = true;
+        }
+      }
+      if (!shouldPush) continue;
+      sweep.pushFace(solidFace.name, tinyPush);
+    }
+  }
+  return sweep;
+}
+
+function applyCylMetadataToRevolve(revolve, axisEdge, radiusValue, baseNormal, offsetVector = null) {
+  if (!revolve || !Array.isArray(revolve.faces) || !axisEdge) return;
+  const THREE = BREP.THREE;
+  try {
+    const posAttr = axisEdge?.geometry?.getAttribute?.("position");
+    const mat = axisEdge.matrixWorld || new THREE.Matrix4();
+    const A = new THREE.Vector3(0, 0, 0);
+    const B = new THREE.Vector3(0, 1, 0);
+    if (posAttr && posAttr.count >= 2) {
+      A.set(posAttr.getX(0), posAttr.getY(0), posAttr.getZ(0)).applyMatrix4(mat);
+      B.set(posAttr.getX(posAttr.count - 1), posAttr.getY(posAttr.count - 1), posAttr.getZ(posAttr.count - 1)).applyMatrix4(mat);
+    }
+    if (offsetVector && offsetVector.x !== undefined) {
+      A.add(offsetVector);
+      B.add(offsetVector);
+    }
+    const axisDir = B.clone().sub(A);
+    const height = axisDir.length();
+    if (height < 1e-9) return;
+    axisDir.normalize();
+    const center = A.clone().addScaledVector(axisDir, height * 0.5);
+
+    // Fit radius/center per side face from geometry to avoid relying on input radius alone.
+    const axisOrigin = A.clone();
+    const tmp = new THREE.Vector3();
+    for (const face of revolve.faces) {
+      const meta = face.getMetadata?.() || {};
+      if (meta.faceType && meta.faceType !== "SIDEWALL") continue;
+      const pos = face.geometry?.getAttribute?.("position");
+      if (!pos || pos.itemSize !== 3 || pos.count < 3) continue;
+      let projMin = Infinity;
+      let projMax = -Infinity;
+      let sumRadius = 0;
+      for (let i = 0; i < pos.count; i++) {
+        tmp.set(pos.getX(i), pos.getY(i), pos.getZ(i)).applyMatrix4(face.matrixWorld);
+        const t = tmp.clone().sub(axisOrigin).dot(axisDir);
+        if (t < projMin) projMin = t;
+        if (t > projMax) projMax = t;
+        const proj = axisOrigin.clone().add(axisDir.clone().multiplyScalar(t));
+        sumRadius += tmp.distanceTo(proj);
+      }
+      const fitRadius = sumRadius / pos.count;
+      const midT = (projMin + projMax) * 0.5;
+      const fitCenter = axisOrigin.clone().add(axisDir.clone().multiplyScalar(midT));
+      // Keep a slight preference for the intended radius but store the fit value so PMI reads geometry.
+      const radius = Number.isFinite(fitRadius) && fitRadius > 1e-6 ? fitRadius : radiusValue;
+      revolve.setFaceMetadata(face.name, {
+        type: "cylindrical",
+        radius,
+        height: projMax - projMin,
+        axis: [axisDir.x, axisDir.y, axisDir.z],
+        center: [fitCenter.x, fitCenter.y, fitCenter.z],
+        pmiRadiusOverride: radius,
+      });
+    }
+  } catch { /* ignore cyl metadata errors */ }
+}
+
+function setSolidNameSafe(solid, name) {
+  try {
+    if (solid && name && typeof name === "string" && name.length) {
+      solid.name = name;
+    }
+  } catch { /* ignore naming errors */ }
+}
+
+function applyFaceSheetMetalData(inputFace, inputSolid) {
+  //console.log(inputFace, inputFace.getMetadata());
+  const inputFaceMetadata = inputFace.getMetadata();
+  //console.log(inputSolid.visualize());
+  inputSolid.visualize();
+
+
+
+  // extract all the faces of the input solid
+  for (const solidFace of inputSolid.faces) {
+    const faceMetadata = solidFace.getMetadata();
+    //console.log("Comparing Solid Face:", solidFace.name, "with Input Face:", inputFace.name);
+    if (faceMetadata.faceType == "STARTCAP" || faceMetadata.faceType == "ENDCAP") {
+      solidFace.setMetadata(inputFaceMetadata);
+      continue;
+    }
+
+
+    solidFace.setMetadata({ sheetMetalFaceType: "THICKNESS" });
+
+  }
+
+
+
+  // loop over each edge of the input face
+  for (const edge of inputFace.edges) {
+    const edgeMetadata = edge.getMetadata();
+    //console.log("Input Face Edge Metadata:", edge.name, edgeMetadata);
+
+    // copy over the metadata from the input face edge to all edges in the solid that have a name that starts with the input edge name
+    for (const solidFace of inputSolid.faces) {
+      // look at the sourceEdgeName metadata for each face of the solid. Compare the faces to the current edge name
+      if (solidFace.getMetadata()?.sourceEdgeName === edge.name) {
+        //console.log("Matching Solid Face Edge found:", solidFace.name, "for Input Edge:", edge.name);
+
+        if (edgeMetadata?.sheetMetalEdgeType) {
+          solidFace.setMetadata({ sheetMetalFaceType: edgeMetadata?.sheetMetalEdgeType });
+        }
+      }
+    }
+  }
+
+}
+
+function buildFlangeRevolve({
+  face,
+  context,
+  hingeEdge,
+  appliedAngle,
+  bendRadiusUsed,
+  thickness,
+  offsetVector,
+  featureID,
+  offsetMagnitudeOverride = null,
+}) {
+  //console.log(appliedAngle);
+  if (!hingeEdge?.start || !hingeEdge?.end || !context) return null;
+  const hingeDir = hingeEdge.end.clone().sub(hingeEdge.start).normalize();
+  let sheetDir = new BREP.THREE.Vector3().crossVectors(context.baseNormal, hingeDir);
+  if (sheetDir.lengthSq() < 1e-10) {
+    sheetDir = context.sheetDir.clone();
+  }
+  sheetDir.normalize();
+  const offsetSign = hingeEdge.target === "MIN" ? 1 : -1;
+  const offsetMagnitude = Number.isFinite(offsetMagnitudeOverride) && offsetMagnitudeOverride >= 0
+    ? offsetMagnitudeOverride
+    : bendRadiusUsed + thickness;
+  const offsetVec = sheetDir.clone().multiplyScalar(offsetSign * offsetMagnitude);
+  const axisEdge = buildAxisEdge(
+    hingeEdge.start.clone().add(offsetVec),
+    hingeEdge.end.clone().add(offsetVec),
+    featureID,
+  );
+
+  const revolve = new BREP.Revolve({
+    face,
+    axis: axisEdge,
+    angle: appliedAngle,
+    resolution: 128,
+    name: featureID ? `${featureID}:BEND` : "SM.FLANGE_BEND",
+  }).visualize();
+  const bendEndFace = findRevolveEndFace(revolve);
+
+  applyFaceSheetMetalData(face, revolve);
+  if (offsetVector) {
+    applyTranslationToSolid(revolve, offsetVector);
+  }
+  applyCylMetadataToRevolve(
+    revolve,
+    axisEdge,
+    bendRadiusUsed + thickness,
+    context.baseNormal,
+    offsetVector,
+  );
+  revolve.visualize();
+
+  const measuredRadius = measureSmallestCylRadius(revolve);
+
+  return { revolve, bendEndFace, hingeEdge, measuredRadius };
+}
+
+function measureSmallestCylRadius(solid) {
+  if (!solid || !Array.isArray(solid.faces)) return null;
+  let minRadius = null;
+  for (const face of solid.faces) {
+    const meta = face.getMetadata?.() || {};
+    const r = Number(meta.radius ?? meta.pmiRadiusOverride ?? meta.pmiRadius ?? meta.sheetMetalRadius);
+    if (Number.isFinite(r) && r > 0) {
+      if (minRadius == null || r < minRadius) minRadius = r;
+    }
+  }
+  return minRadius;
+}
+
+function radiusError(measured, target) {
+  if (!Number.isFinite(target)) return Infinity;
+  if (!Number.isFinite(measured)) return Infinity;
+  return Math.abs(measured - target);
+}
+
+function evaluateFlangeCandidate({
+  raw,
+  targetRadius,
+  desiredBendSide = null,
+  orientationInfo = null,
+}) {
+  if (!raw?.revolve) return null;
+  const result = {
+    ...raw,
+    radiusErr: radiusError(raw.measuredRadius, targetRadius),
+    orientationPenalty: 0,
+    bendSide: null,
+  };
+  const bendOrientation = determineBendSide(raw, orientationInfo);
+  if (bendOrientation?.side) {
+    result.bendSide = bendOrientation.side;
+    if (desiredBendSide) {
+      result.orientationPenalty = bendOrientation.side === desiredBendSide ? 0 : 1;
+    }
+  }
+  return result;
+}
+
+function determineBendSide(candidate, orientationInfo) {
+  const dir = orientationInfo?.dir;
+  const origin = orientationInfo?.origin;
+  if (!candidate?.bendEndFace || !dir || typeof dir.dot !== "function" || dir.lengthSq() < 1e-12) {
+    return null;
+  }
+  const center = computeFaceCenter(candidate.bendEndFace);
+  if (!center || !origin) return null;
+  const offset = center.clone().sub(origin);
+  const dot = offset.dot(dir);
+  if (!Number.isFinite(dot) || Math.abs(dot) < 1e-9) return null;
+  const side = dot >= 0 ? SHEET_METAL_FACE_TYPES.A : SHEET_METAL_FACE_TYPES.B;
+  return { side, alignment: Math.abs(dot) };
+}
+
+function pickBetterFlangeCandidate(current, candidate) {
+  if (!candidate?.revolve) return current;
+  if (!current?.revolve) return candidate;
+  if (candidate.orientationPenalty !== current.orientationPenalty) {
+    return candidate.orientationPenalty < current.orientationPenalty ? candidate : current;
+  }
+  const currErr = current.radiusErr ?? Infinity;
+  const candErr = candidate.radiusErr ?? Infinity;
+  return candErr + 1e-9 < currErr ? candidate : current;
+}
+
+function combineSolids(params = {}) {
+  const {
+    solids,
+    featureID,
+    groupIndex = 0,
+  } = params;
+  if (!Array.isArray(solids) || solids.length === 0) return null;
+  let combined = null;
+  for (const solid of solids) {
+    if (!solid) continue;
+    if (!combined) {
+      combined = solid;
+      continue;
+    }
+    let merged = null;
+    try {
+      merged = combined.union(solid);
+    } catch {
+      try {
+        merged = solid.union(combined);
+      } catch {
+        merged = null;
+      }
+    }
+    if (!merged) return null;
+    combined = merged;
+  }
+  if (!combined) return null;
+  try {
+    const suffix = Number.isFinite(groupIndex) ? `_${groupIndex}` : "";
+    combined.name = featureID
+      ? `${featureID}:BENDS${suffix}`
+      : combined.name || `SM.FLANGE_BENDS${suffix}`;
+  } catch { /* optional */ }
+  try { combined.visualize(); } catch { }
+  return combined;
+}
+
+function solidsMatch(a, b) {
+  if (!a || !b) return false;
+  if (a === b) return true;
+  if (a.uuid && b.uuid && a.uuid === b.uuid) return true;
+  if (a.name && b.name && a.name === b.name) return true;
+  return false;
+}