brep-io-kernel 1.0.0

package/src/features/sheetMetal/SheetMetalContourFlangeFeature.js

@@ -0,0 +1,1656 @@
+import { BREP } from "../../BREP/BREP.js";
+import { selectionHasSketch } from "../selectionUtils.js";
+import {
+  normalizeThickness,
+  normalizeBendRadius,
+  normalizeNeutralFactor,
+  applySheetMetalMetadata,
+} from "./sheetMetalMetadata.js";
+import { setSheetMetalFaceTypeMetadata, SHEET_METAL_FACE_TYPES, propagateSheetMetalFaceTypesToEdges } from "./sheetMetalFaceTypes.js";
+import { cleanupSheetMetalOppositeEdgeFaces } from "./sheetMetalCleanup.js";
+import { SheetMetalObject } from "./SheetMetalObject.js";
+import { cloneSheetMetalTree, createSheetMetalContourFlangeNode, createSheetMetalTree } from "./sheetMetalTree.js";
+
+const THREE = BREP.THREE;
+
+const inputParamsSchema = {
+  id: {
+    type: "string",
+    default_value: null,
+    hint: "Unique identifier for the contour flange feature",
+  },
+  path: {
+    type: "reference_selection",
+    selectionFilter: ["SKETCH", "EDGE"],
+    multiple: true,
+    default_value: null,
+    hint: "Open sketch (or connected edges) defining the flange centerline.",
+  },
+  distance: {
+    type: "number",
+    default_value: 20,
+    min: 0,
+    hint: "How far the sheet extends from the selected path (strip width).",
+  },
+  thickness: {
+    type: "number",
+    default_value: 2,
+    min: 0,
+    hint: "Sheet metal thickness (extruded normal to the sketch plane).",
+  },
+  reverseSheetSide: {
+    type: "boolean",
+    default_value: false,
+    hint: "Flip the sheet offset to the opposite side of the sketch.",
+  },
+  bendRadius: {
+    type: "number",
+    default_value: 2,
+    min: 0,
+    hint: "Default inside bend radius inserted wherever two lines meet.",
+  },
+  neutralFactor: {
+    type: "number",
+    default_value: 0.5,
+    min: 0,
+    max: 1,
+    step: 0.01,
+    hint: "Neutral factor used for flat pattern bend allowance (0-1).",
+  },
+  consumePathSketch: {
+    type: "boolean",
+    default_value: true,
+    hint: "Remove the referenced sketch after creating the flange. Turn off to keep it in the scene.",
+  },
+};
+
+export class SheetMetalContourFlangeFeature {
+  static shortName = "SM.CF";
+  static longName = "Sheet Metal Contour Flange";
+  static inputParamsSchema = inputParamsSchema;
+
+  constructor() {
+    this.inputParams = {};
+    this.persistentData = {};
+  }
+
+  uiFieldsTest(context) {
+    const params = this.inputParams || context?.params || {};
+    const partHistory = context?.history || null;
+    const pathRef = params.path ?? params.profile;
+    return selectionHasSketch(pathRef, partHistory) ? [] : ["consumePathSketch"];
+  }
+
+  async run(partHistory) {
+    const pathRef = this.inputParams?.path ?? this.inputParams?.profile;
+    const { edges, sketches } = resolvePathSelection(pathRef, partHistory);
+    if (!edges.length) {
+      throw new Error("Contour Flange requires selecting a SKETCH or one or more connected EDGEs.");
+    }
+
+    const { magnitude: thicknessAbs, signed: signedThickness } = normalizeThickness(
+      this.inputParams?.thickness ?? 1,
+    );
+    const bendRadius = normalizeBendRadius(this.inputParams?.bendRadius ?? 0);
+    const neutralFactor = normalizeNeutralFactor(this.inputParams?.neutralFactor ?? 0.5);
+    const rawDistance = Number(this.inputParams?.distance ?? 0);
+    if (!Number.isFinite(rawDistance) || rawDistance === 0) {
+      throw new Error("Contour Flange distance must be a non-zero number.");
+    }
+    const distance = Math.abs(rawDistance);
+
+    const { sheetSide, reverseSheetSide } = resolveSheetSideOption(this.inputParams);
+
+    const sheetMetal = new SheetMetalObject({
+      tree: createSheetMetalTree(),
+      kFactor: neutralFactor,
+      thickness: thicknessAbs,
+      bendRadius,
+    });
+    const contourNode = createSheetMetalContourFlangeNode({
+      featureID: this.inputParams?.featureID || null,
+      pathRefs: pathRef,
+      distance: rawDistance,
+      thickness: thicknessAbs,
+      signedThickness,
+      signedDistance: rawDistance,
+      reverseSheetSide,
+      sheetSide,
+      bendRadius,
+      neutralFactor,
+      consumePathSketch: this.inputParams?.consumePathSketch !== false,
+    });
+    sheetMetal.appendNode(contourNode);
+    await sheetMetal.generate({
+      partHistory,
+      metadataManager: partHistory?.metadataManager,
+      mode: "solid",
+    });
+
+    const consumeSketch = this.inputParams?.consumePathSketch !== false;
+    const removed = consumeSketch ? sketches : [];
+    try {
+      for (const obj of removed) {
+        if (obj) obj.__removeFlag = true;
+      }
+    } catch { /* best effort */ }
+
+    const added = [sheetMetal];
+    cleanupSheetMetalOppositeEdgeFaces(added);
+    propagateSheetMetalFaceTypesToEdges(added);
+    applySheetMetalMetadata(added, partHistory?.metadataManager, {
+      featureID: this.inputParams?.featureID || null,
+      thickness: thicknessAbs,
+      bendRadius,
+      neutralFactor,
+      baseType: "CONTOUR_FLANGE",
+      extra: {
+        signedThickness,
+        sheetSide,
+        reverseSheetSide,
+        signedDistance: rawDistance,
+        distance,
+        pathRefCount: Array.isArray(contourNode?.params?.pathRefs)
+          ? contourNode.params.pathRefs.length
+          : null,
+      },
+      forceBaseOverwrite: true,
+    });
+
+    for (const solid of added) {
+      if (!solid) continue;
+      solid.userData = solid.userData || {};
+      solid.userData.sheetMetalTree = cloneSheetMetalTree(sheetMetal.tree);
+      solid.userData.sheetMetalKFactor = neutralFactor;
+    }
+
+    this.persistentData = this.persistentData || {};
+    this.persistentData.sheetMetal = {
+      baseType: "CONTOUR_FLANGE",
+      thickness: thicknessAbs,
+      bendRadius,
+      neutralFactor,
+      signedThickness,
+      sheetSide,
+      reverseSheetSide,
+      signedDistance: rawDistance,
+      distance,
+      pathRefCount: Array.isArray(contourNode?.params?.pathRefs)
+        ? contourNode.params.pathRefs.length
+        : null,
+      tree: sheetMetal.tree,
+    };
+
+    return { added, removed };
+  }
+}
+
+export function buildContourFlangeSolidFromParams(params, partHistory) {
+  const { edges, sketches, basisHint, pathOverride } = resolvePathSelection(
+    params?.path ?? params?.profile,
+    partHistory,
+  );
+  if (!edges.length) {
+    throw new Error("Contour Flange requires selecting a SKETCH or one or more connected EDGEs.");
+  }
+
+  const { magnitude: thicknessAbs, signed: signedThickness } = normalizeThickness(
+    params?.thickness ?? 1,
+  );
+  const bendRadius = normalizeBendRadius(params?.bendRadius ?? 0);
+  const neutralFactor = normalizeNeutralFactor(params?.neutralFactor ?? 0.5);
+  const rawDistance = Number(params?.distance ?? 0);
+  if (!Number.isFinite(rawDistance) || rawDistance === 0) {
+    throw new Error("Contour Flange distance must be a non-zero number.");
+  }
+  const distance = Math.abs(rawDistance);
+  const extrudeDirectionSign = rawDistance >= 0 ? 1 : -1;
+
+  const { sheetSide, reverseSheetSide } = resolveSheetSideOption(params);
+
+  const pathData = buildPathPoints(edges);
+  let rawPath = pathData.points;
+  let pathSegmentNames = pathData.segmentNames;
+  if ((!rawPath || rawPath.length < 2) && Array.isArray(pathOverride) && pathOverride.length >= 2) {
+    rawPath = pathOverride.map((pt) => (pt instanceof THREE.Vector3)
+      ? pt.clone()
+      : new THREE.Vector3(pt.x ?? pt[0] ?? 0, pt.y ?? pt[1] ?? 0, pt.z ?? pt[2] ?? 0));
+    pathSegmentNames = buildDefaultSegmentNames(rawPath.length - 1);
+  }
+  if (!rawPath || rawPath.length < 2) {
+    throw new Error("Contour Flange path must contain at least two points.");
+  }
+  pathSegmentNames = normalizeSegmentNameCount(pathSegmentNames, rawPath.length - 1);
+
+  const planeBasis = computePlaneBasis(rawPath, basisHint);
+  const filletResult = bendRadius > 0
+    ? filletPolyline(rawPath, bendRadius, planeBasis, pathSegmentNames, sheetSide, thicknessAbs)
+    : { points: rawPath.map((pt) => pt.clone()), points2D: null, tangents2D: null, segmentNames: pathSegmentNames.slice(), arcs: [] };
+  const filletedPath = filletResult.points;
+  const filletedPath2D = Array.isArray(filletResult.points2D) ? filletResult.points2D : null;
+  const filletedTangents2D = Array.isArray(filletResult.tangents2D) ? filletResult.tangents2D : null;
+  const filletedArcs = Array.isArray(filletResult.arcs) ? filletResult.arcs : [];
+  const filletedSegmentNames = normalizeSegmentNameCount(
+    filletResult.segmentNames,
+    filletedPath.length - 1,
+  );
+
+  if (filletedPath.length < 2) {
+    throw new Error("Contour Flange requires at least two path points after filleting.");
+  }
+
+  const flangeFaces = buildContourFlangeStripFaces({
+    featureID: params?.featureID,
+    pathPoints: filletedPath,
+    pathSegmentNames: filletedSegmentNames,
+    planeBasis,
+    thickness: thicknessAbs,
+    sheetSide,
+    path2DOverride: filletedPath2D,
+    pathTangents2D: filletedTangents2D,
+  });
+
+  const converters = createPlaneBasisConverters(planeBasis);
+  const extrudeVector = planeBasis.planeNormal.clone().normalize().multiplyScalar(distance * extrudeDirectionSign);
+  const sweeps = flangeFaces.map((face) => {
+    const sweep = new BREP.Sweep({
+      face,
+      distance: extrudeVector,
+      mode: "translate",
+      name: params?.featureID,
+      omitBaseCap: false,
+    });
+    sweep.visualize();
+    tagContourFlangeFaceTypes(sweep);
+    // Add cylinder metadata and centerlines for bend arcs (if any).
+    const axisDir = extrudeVector.clone().normalize();
+    addCylMetadataToSideFaces(
+      sweep,
+      filletedArcs,
+      converters,
+      extrudeVector,
+      axisDir,
+      thicknessAbs,
+      bendRadius,
+      sheetSide,
+    );
+    return sweep;
+  });
+  if (!sweeps.length) {
+    throw new Error("Contour flange failed to generate any extrusions from the selected path.");
+  }
+  let combinedSweep = sweeps[0];
+  for (let i = 1; i < sweeps.length; i++) {
+    try {
+      combinedSweep = combinedSweep.union(sweeps[i]);
+    } catch {
+      combinedSweep = sweeps[i];
+    }
+  }
+
+  if (params?.featureID && combinedSweep) {
+    try { combinedSweep.name = params.featureID; } catch { /* best effort */ }
+  }
+
+  return {
+    solid: combinedSweep,
+    sketches,
+    meta: {
+      thicknessAbs,
+      signedThickness,
+      bendRadius,
+      neutralFactor,
+      sheetSide,
+      reverseSheetSide,
+      rawDistance,
+      distance,
+      pathPointCount: filletedPath.length,
+    },
+  };
+}
+
+function resolvePathSelection(pathRefs, partHistory) {
+  const refs = Array.isArray(pathRefs) ? pathRefs : (pathRefs ? [pathRefs] : []);
+  const edges = [];
+  const sketches = new Set();
+  const basisCandidates = [];
+  let overridePath = null;
+
+  for (const ref of refs) {
+    let obj = ref;
+    if (typeof obj === "string" && partHistory?.scene?.getObjectByName) {
+      obj = partHistory.scene.getObjectByName(obj);
+    }
+    if (!obj) continue;
+    if (obj.type === "EDGE") {
+      edges.push(obj);
+      const edgeBasis = extractBasisFromEdge(obj, partHistory);
+      if (edgeBasis) basisCandidates.push(edgeBasis);
+    } else if (obj.type === "SKETCH") {
+      sketches.add(obj);
+      const sketchBasis = extractBasisFromSketch(obj, partHistory);
+      if (sketchBasis) basisCandidates.push(sketchBasis);
+      if (!overridePath) {
+        const diagPath = buildPathFromSketchDiagnostics(obj, partHistory, sketchBasis);
+        if (diagPath && diagPath.points.length >= 2) {
+          overridePath = diagPath.points;
+          if (diagPath.basis) basisCandidates.push(diagPath.basis);
+        }
+      }
+      const stack = Array.isArray(obj.children) ? obj.children.slice() : [];
+      for (const child of stack) {
+        if (child?.type === "EDGE") {
+          edges.push(child);
+          const childBasis = extractBasisFromEdge(child, partHistory);
+          if (childBasis) basisCandidates.push(childBasis);
+        }
+      }
+    }
+  }
+
+  return {
+    edges,
+    sketches: Array.from(sketches),
+    basisHint: basisCandidates.find(Boolean) || null,
+    pathOverride: overridePath,
+  };
+}
+
+function extractBasisFromEdge(edge, partHistory) {
+  if (!edge) return null;
+  const direct = convertStoredBasis(edge.userData?.sheetMetalBasis || edge.userData?.basis);
+  if (direct) return direct;
+  const sketchId = edge.userData?.sketchFeatureId || edge.userData?.sketchId;
+  const basis = findSketchBasis(sketchId, partHistory);
+  return convertStoredBasis(basis);
+}
+
+function extractBasisFromSketch(sketchObj, partHistory) {
+  if (!sketchObj) return null;
+  const direct = convertStoredBasis(sketchObj.userData?.sheetMetalBasis || sketchObj.userData?.basis);
+  if (direct) return direct;
+  const sketchId = sketchObj.name || sketchObj.userData?.sketchFeatureId;
+  const basis = findSketchBasis(sketchId, partHistory);
+  return convertStoredBasis(basis);
+}
+
+function findSketchBasis(featureId, partHistory) {
+  const normalized = normalizeId(featureId);
+  if (!normalized || !partHistory) return null;
+  const entry = findSketchFeatureEntry(partHistory, normalized);
+  return entry?.persistentData?.basis || null;
+}
+
+function normalizeId(value) {
+  if (value == null) return null;
+  try {
+    const str = String(value).trim();
+    return str.length ? str : null;
+  } catch {
+    return null;
+  }
+}
+
+function findSketchFeatureEntry(partHistory, normalizedId) {
+  const list = Array.isArray(partHistory?.features) ? partHistory.features : [];
+  for (const entry of list) {
+    const entryId = normalizeId(entry?.inputParams?.id ?? entry?.id ?? entry?.inputParams?.featureID);
+    if (entryId && entryId === normalizedId) return entry;
+  }
+  return null;
+}
+
+function buildPathFromSketchDiagnostics(sketchObj, partHistory, basisOverride = null) {
+  if (!sketchObj || !partHistory) return null;
+  const sketchId = normalizeId(sketchObj.name || sketchObj.userData?.sketchFeatureId);
+  if (!sketchId) return null;
+  const featureEntry = findSketchFeatureEntry(partHistory, sketchId);
+  if (!featureEntry) return null;
+  const diag = featureEntry?.persistentData?.lastProfileDiagnostics;
+  const openChains = Array.isArray(diag?.openChains2D) ? diag.openChains2D : [];
+  if (!openChains.length) return null;
+  let selected = null;
+  for (const chain of openChains) {
+    if (!Array.isArray(chain) || chain.length < 2) continue;
+    if (!selected || chain.length > selected.length) selected = chain;
+  }
+  if (!selected) return null;
+  const basis = convertStoredBasis(basisOverride || featureEntry?.persistentData?.basis);
+  if (!basis) return null;
+  const worldPts = selected.map((point) => projectSketchUVToWorld(point, basis));
+  return { points: worldPts, basis };
+}
+
+function convertStoredBasis(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const origin = vectorFromArray(raw.origin) || new THREE.Vector3(0, 0, 0);
+  const xAxisRaw = vectorFromArray(raw.x || raw.xAxis) || new THREE.Vector3(1, 0, 0);
+  const zAxisRaw = vectorFromArray(raw.z || raw.zAxis || raw.planeNormal) || new THREE.Vector3(0, 0, 1);
+  if (xAxisRaw.lengthSq() < 1e-10 || zAxisRaw.lengthSq() < 1e-10) return null;
+  const zAxis = zAxisRaw.clone().normalize();
+  const xAxis = xAxisRaw.clone().sub(zAxis.clone().multiplyScalar(xAxisRaw.dot(zAxis))).normalize();
+  let yAxis = vectorFromArray(raw.y || raw.yAxis);
+  if (yAxis && yAxis.lengthSq() > 1e-10) {
+    yAxis = yAxis.clone().normalize();
+  } else {
+    yAxis = new THREE.Vector3().crossVectors(zAxis, xAxis).normalize();
+  }
+  return {
+    origin: origin.clone(),
+    xAxis,
+    yAxis,
+    planeNormal: zAxis,
+  };
+}
+
+function vectorFromArray(raw) {
+  if (raw instanceof THREE.Vector3) return raw.clone();
+  if (Array.isArray(raw) && raw.length >= 3) {
+    const x = Number(raw[0]) || 0;
+    const y = Number(raw[1]) || 0;
+    const z = Number(raw[2]) || 0;
+    return new THREE.Vector3(x, y, z);
+  }
+  return null;
+}
+
+function projectSketchUVToWorld(point, basis) {
+  if (!basis) return new THREE.Vector3();
+  const u = Array.isArray(point) ? Number(point[0]) || 0 : Number(point?.u || 0);
+  const v = Array.isArray(point) ? Number(point[1]) || 0 : Number(point?.v || 0);
+  return basis.origin.clone()
+    .add(basis.xAxis.clone().multiplyScalar(u))
+    .add(basis.yAxis.clone().multiplyScalar(v));
+}
+
+function buildPathPoints(edges) {
+  if (!Array.isArray(edges) || !edges.length) {
+    return { points: [], segmentNames: [] };
+  }
+
+  const tmp = new THREE.Vector3();
+  const toWorld = (edge, pt) => {
+    tmp.set(pt[0], pt[1], pt[2]);
+    if (edge && typeof edge.updateWorldMatrix === "function") {
+      edge.updateWorldMatrix(true, true);
+    }
+    return tmp.clone().applyMatrix4(edge.matrixWorld || new THREE.Matrix4());
+  };
+
+  const segments = [];
+  let edgeCounter = 0;
+  for (const edge of edges) {
+    const pts = Array.isArray(edge?.userData?.polylineLocal)
+      ? edge.userData.polylineLocal
+      : null;
+    let worldPts = null;
+    if (pts && pts.length >= 2) {
+      worldPts = pts.map((p) => toWorld(edge, p));
+    } else {
+      const pos = edge?.geometry?.getAttribute?.("position");
+      if (pos && pos.itemSize === 3 && pos.count >= 2) {
+        worldPts = [];
+        for (let i = 0; i < pos.count; i++) {
+          tmp.set(pos.getX(i), pos.getY(i), pos.getZ(i));
+          tmp.applyMatrix4(edge.matrixWorld || new THREE.Matrix4());
+          worldPts.push(tmp.clone());
+        }
+      }
+    }
+    if (!worldPts || worldPts.length < 2) continue;
+    const flat = worldPts.map((v) => [v.x, v.y, v.z]);
+    segments.push({
+      pts: flat,
+      startKey: `${flat[0][0].toFixed(6)},${flat[0][1].toFixed(6)},${flat[0][2].toFixed(6)}`,
+      endKey: `${flat[flat.length - 1][0].toFixed(6)},${flat[flat.length - 1][1].toFixed(6)},${flat[flat.length - 1][2].toFixed(6)}`,
+      name: deriveEdgeBaseName(edge, edgeCounter++),
+    });
+  }
+
+  if (!segments.length) {
+    return { points: [], segmentNames: [] };
+  }
+
+  const used = new Array(segments.length).fill(false);
+  let bestPoints = [];
+  let bestSegmentMeta = [];
+  const key = (p) => `${p[0].toFixed(6)},${p[1].toFixed(6)},${p[2].toFixed(6)}`;
+
+  for (let i = 0; i < segments.length; i++) {
+    if (used[i]) continue;
+    const base = segments[i];
+    const chain = base.pts.slice();
+    const chainSegments = [{ name: base.name, pts: base.pts.slice() }];
+    used[i] = true;
+    let grew = true;
+    while (grew) {
+      grew = false;
+      for (let j = 0; j < segments.length; j++) {
+        if (used[j]) continue;
+        const seg = segments[j];
+        const head = chain[0];
+        const tail = chain[chain.length - 1];
+        const headKey = key(head);
+        const tailKey = key(tail);
+        if (seg.startKey === tailKey) {
+          chain.push(...seg.pts.slice(1));
+          chainSegments.push({ name: seg.name, pts: seg.pts.slice() });
+          used[j] = true;
+          grew = true;
+        } else if (seg.endKey === tailKey) {
+          const ptsRev = seg.pts.slice().reverse();
+          chain.push(...ptsRev.slice(1));
+          chainSegments.push({ name: seg.name, pts: ptsRev });
+          used[j] = true;
+          grew = true;
+        } else if (seg.endKey === headKey) {
+          const pts = seg.pts.slice();
+          chain.unshift(...pts.slice(0, pts.length - 1));
+          chainSegments.unshift({ name: seg.name, pts: pts });
+          used[j] = true;
+          grew = true;
+        } else if (seg.startKey === headKey) {
+          const ptsRev = seg.pts.slice().reverse();
+          chain.unshift(...ptsRev.slice(0, ptsRev.length - 1));
+          chainSegments.unshift({ name: seg.name, pts: ptsRev });
+          used[j] = true;
+          grew = true;
+        }
+      }
+    }
+    if (chain.length > bestPoints.length) {
+      bestPoints = chain.slice();
+      bestSegmentMeta = chainSegments.map((entry) => ({ name: entry.name, pts: entry.pts.map((p) => p.slice()) }));
+    }
+  }
+
+  if (!bestPoints.length) {
+    return { points: [], segmentNames: [] };
+  }
+
+  const finalPoints = [];
+  const segmentNames = [];
+  for (const seg of bestSegmentMeta) {
+    const pts = seg.pts;
+    for (let i = 0; i < pts.length; i++) {
+      const p = pts[i];
+      if (!finalPoints.length) {
+        finalPoints.push(p);
+        continue;
+      }
+      const prev = finalPoints[finalPoints.length - 1];
+      if (prev[0] === p[0] && prev[1] === p[1] && prev[2] === p[2]) {
+        continue;
+      }
+      finalPoints.push(p);
+      segmentNames[finalPoints.length - 2] = seg.name || `SEGMENT_${segmentNames.length}`;
+    }
+  }
+
+  return {
+    points: finalPoints.map((p) => new THREE.Vector3(p[0], p[1], p[2])),
+    segmentNames,
+  };
+}
+
+function computePlaneBasis(points, hintBasis = null) {
+  if (hintBasis) {
+    const origin = hintBasis.origin instanceof THREE.Vector3
+      ? hintBasis.origin.clone()
+      : Array.isArray(hintBasis.origin)
+        ? new THREE.Vector3().fromArray(hintBasis.origin)
+        : new THREE.Vector3(0, 0, 0);
+    const zRaw = hintBasis.planeNormal || hintBasis.zAxis || hintBasis.z;
+    const xRaw = hintBasis.xAxis || hintBasis.x;
+    const yRaw = hintBasis.yAxis || hintBasis.y;
+    const z = zRaw instanceof THREE.Vector3 ? zRaw.clone()
+      : Array.isArray(zRaw) ? new THREE.Vector3().fromArray(zRaw)
+        : null;
+    const x = xRaw instanceof THREE.Vector3 ? xRaw.clone()
+      : Array.isArray(xRaw) ? new THREE.Vector3().fromArray(xRaw)
+        : null;
+    const y = yRaw instanceof THREE.Vector3 ? yRaw.clone()
+      : Array.isArray(yRaw) ? new THREE.Vector3().fromArray(yRaw)
+        : null;
+    if (z && z.lengthSq() > 1e-8 && x && x.lengthSq() > 1e-8) {
+      const zn = z.clone().normalize();
+      const xn = x.clone().normalize();
+      const yn = (y && y.lengthSq() > 1e-8)
+        ? y.clone().normalize()
+        : new THREE.Vector3().crossVectors(zn, xn).normalize();
+      return { origin, planeNormal: zn, xAxis: xn, yAxis: yn };
+    }
+  }
+
+  if (!Array.isArray(points) || points.length < 2) {
+    const origin = new THREE.Vector3(0, 0, 0);
+    return {
+      origin,
+      planeNormal: new THREE.Vector3(0, 0, 1),
+      xAxis: new THREE.Vector3(1, 0, 0),
+      yAxis: new THREE.Vector3(0, 1, 0),
+    };
+  }
+  const origin = points[0].clone();
+  const xAxis = points[1].clone().sub(points[0]);
+  if (xAxis.lengthSq() < 1e-8 && points.length > 2) {
+    xAxis.copy(points[2]).sub(points[1]);
+  }
+  if (xAxis.lengthSq() < 1e-8) xAxis.set(1, 0, 0);
+  xAxis.normalize();
+
+  let planeNormal = new THREE.Vector3(0, 0, 1);
+  for (let i = 0; i < points.length - 2; i++) {
+    const v0 = points[i + 1].clone().sub(points[i]);
+    const v1 = points[i + 2].clone().sub(points[i + 1]);
+    const n = v0.clone().cross(v1);
+    if (n.lengthSq() > 1e-8) {
+      planeNormal = n.normalize();
+      break;
+    }
+  }
+  if (planeNormal.lengthSq() < 1e-8) planeNormal.set(0, 0, 1);
+
+  // Create proper right-handed coordinate system: Y = Z × X
+  const yAxis = new THREE.Vector3().crossVectors(planeNormal, xAxis).normalize();
+  if (yAxis.lengthSq() < 1e-8) {
+    // If xAxis is parallel to planeNormal, choose a different approach
+    const tempX = Math.abs(planeNormal.dot(new THREE.Vector3(1, 0, 0))) < 0.9
+      ? new THREE.Vector3(1, 0, 0)
+      : new THREE.Vector3(0, 1, 0);
+    const xAxis2 = new THREE.Vector3().crossVectors(planeNormal, tempX).normalize();
+    const yAxis2 = new THREE.Vector3().crossVectors(planeNormal, xAxis2).normalize();
+    return { origin, planeNormal, xAxis: xAxis2, yAxis: yAxis2 };
+  }
+
+  // Ensure xAxis is orthogonal to planeNormal (project and normalize)
+  const xAxisCorrected = xAxis.clone().sub(planeNormal.clone().multiplyScalar(xAxis.dot(planeNormal))).normalize();
+
+  return { origin, planeNormal, xAxis: xAxisCorrected, yAxis };
+}
+
+function filletPolyline(points, radius, basis, segmentNames = [], sheetSide = "left", thickness = 0) {
+  if (!Array.isArray(points) || points.length < 2) {
+    return {
+      points: Array.isArray(points) ? points.map((pt) => pt.clone()) : [],
+      segmentNames: [],
+      points2D: null,
+      tangents2D: null,
+      arcs: [],
+    };
+  }
+
+  const { origin, xAxis, yAxis, planeNormal } = basis;
+  const to2D = (vec) => {
+    const rel = vec.clone().sub(origin);
+    return {
+      u: rel.dot(xAxis),
+      v: rel.dot(yAxis),
+      w: rel.dot(planeNormal),
+    };
+  };
+  const to3D = (coord) => {
+    return origin.clone()
+      .add(xAxis.clone().multiplyScalar(coord.u))
+      .add(yAxis.clone().multiplyScalar(coord.v))
+      .add(planeNormal.clone().multiplyScalar(coord.w || 0));
+  };
+
+  if (!radius || radius <= 1e-8 || points.length < 3) {
+    const coordsSimple = points.map((pt) => to2D(pt));
+    return {
+      points: points.map((pt) => pt.clone()),
+      segmentNames: normalizeSegmentNameCount(segmentNames, points.length - 1),
+      points2D: coordsSimple,
+      tangents2D: null,
+      arcs: [],
+    };
+  }
+
+  const coords = points.map((pt) => to2D(pt));
+  const baseNames = normalizeSegmentNameCount(segmentNames, coords.length - 1);
+  const segCount = coords.length - 1;
+  const segmentStart = new Array(segCount);
+  const segmentEnd = new Array(segCount);
+  const arcCenters = new Array(coords.length).fill(null);
+  const arcSweepDirs = new Array(coords.length).fill(0);
+  const arcInfo = [];
+  for (let i = 0; i < segCount; i++) {
+    segmentStart[i] = { ...coords[i] };
+    segmentEnd[i] = { ...coords[i + 1] };
+  }
+
+  const arcSamples = new Array(coords.length).fill(null);
+  const arcNames = new Array(coords.length).fill(null);
+
+  const len = (a, b) => Math.hypot(b.u - a.u, b.v - a.v);
+  const norm = (a, b) => {
+    const d = len(a, b) || 1;
+    return { x: (b.u - a.u) / d, y: (b.v - a.v) / d };
+  };
+
+  for (let i = 1; i < coords.length - 1; i++) {
+    const prev = coords[i - 1];
+    const curr = coords[i];
+    const next = coords[i + 1];
+    const dirPrev = norm(prev, curr);
+    const dirNext = norm(curr, next);
+    const turn = dirPrev.x * dirNext.y - dirPrev.y * dirNext.x;
+    const dot = (-dirPrev.x) * dirNext.x + (-dirPrev.y) * dirNext.y;
+    const angle = Math.acos(Math.max(-1, Math.min(1, dot)));
+    if (!Number.isFinite(angle) || angle < (5 * Math.PI / 180)) {
+      continue;
+    }
+    let offset = radius / Math.tan(angle / 2);
+    const lenPrev = len(prev, curr);
+    const lenNext = len(curr, next);
+    offset = Math.min(offset, lenPrev * 0.9, lenNext * 0.9);
+    if (!Number.isFinite(offset) || offset <= 0) {
+      continue;
+    }
+    const insideSign = Math.sign(turn) || 1;
+    // Determine which side is "inside" the bend (where the sheet material is)
+    // For sheet metal: the bend creates two arcs
+    // - Inner arc (smaller radius) = bendRadius
+    // - Outer arc (larger radius) = bendRadius + thickness
+    
+    // The "inside" of the bend is determined by the turn direction
+    const normalPrev = insideSign > 0
+      ? { x: -dirPrev.y, y: dirPrev.x }
+      : { x: dirPrev.y, y: -dirPrev.x };
+    const normalNext = insideSign > 0
+      ? { x: -dirNext.y, y: dirNext.x }
+      : { x: dirNext.y, y: -dirNext.x };
+    
+    // Calculate the bisector direction (average of the two normals)
+    const bisectorX = normalPrev.x + normalNext.x;
+    const bisectorY = normalPrev.y + normalNext.y;
+    const bisectorLen = Math.hypot(bisectorX, bisectorY);
+    
+    if (bisectorLen < 1e-10) continue; // Skip if normals cancel out (180° turn)
+    
+    const bisectorNormX = bisectorX / bisectorLen;
+    const bisectorNormY = bisectorY / bisectorLen;
+    
+    // For sheet metal bends, we need to consider which side the sheet is on
+    // sheetSide "left" means sheet material is on the left looking along the path
+    // sheetSide "right" means sheet material is on the right
+    
+    // Determine if the bend is on the same side as the sheet
+    const bendOnSheetSide = (sheetSide === "left" && insideSign > 0) || (sheetSide === "right" && insideSign < 0);
+    
+    // If bend is on sheet side: path follows outer radius (bendRadius + thickness)
+    // If bend is away from sheet: path follows inner radius (bendRadius)
+    const pathRadius = bendOnSheetSide ? radius + thickness : radius;
+    
+    // The distance from vertex to center along bisector: radius / sin(angle/2)
+    const halfAngleSin = Math.sin(angle / 2);
+    const centerDist = halfAngleSin > 1e-10 ? pathRadius / halfAngleSin : pathRadius;
+    
+    const center = {
+      u: curr.u + bisectorNormX * centerDist,
+      v: curr.v + bisectorNormY * centerDist,
+      w: curr.w,
+    };
+
+    // Calculate new tangent points: project center onto each line to find where
+    // a circle of pathRadius from center touches the incoming/outgoing segments
+    const centerRelToCurr = { u: center.u - curr.u, v: center.v - curr.v };
+    
+    // For incoming segment: project center displacement onto line direction
+    const projPrev = centerRelToCurr.u * dirPrev.x + centerRelToCurr.v * dirPrev.y;
+    const perpDistPrevSq = centerRelToCurr.u * centerRelToCurr.u + centerRelToCurr.v * centerRelToCurr.v - projPrev * projPrev;
+    const tangentDistPrev = -projPrev + Math.sqrt(Math.max(0, pathRadius * pathRadius - perpDistPrevSq));
+    
+    // For outgoing segment
+    const projNext = centerRelToCurr.u * dirNext.x + centerRelToCurr.v * dirNext.y;
+    const perpDistNextSq = centerRelToCurr.u * centerRelToCurr.u + centerRelToCurr.v * centerRelToCurr.v - projNext * projNext;
+    const tangentDistNext = projNext + Math.sqrt(Math.max(0, pathRadius * pathRadius - perpDistNextSq));
+    
+    // Clamp to segment lengths
+    const clampedOffsetPrev = Math.min(tangentDistPrev, lenPrev * 0.9);
+    const clampedOffsetNext = Math.min(tangentDistNext, lenNext * 0.9);
+    
+    const arcStart = {
+      u: curr.u - dirPrev.x * clampedOffsetPrev,
+      v: curr.v - dirPrev.y * clampedOffsetPrev,
+      w: curr.w,
+    };
+    
+    const arcEnd = {
+      u: curr.u + dirNext.x * clampedOffsetNext,
+      v: curr.v + dirNext.y * clampedOffsetNext,
+      w: curr.w,
+    };
+
+    // Calculate the actual radius from center to the tangent points
+    const actualRadiusStart = Math.hypot(arcStart.u - center.u, arcStart.v - center.v);
+    const actualRadiusEnd = Math.hypot(arcEnd.u - center.u, arcEnd.v - center.v);
+    const actualArcRadius = (actualRadiusStart + actualRadiusEnd) * 0.5;
+    
+    const startAng = Math.atan2(arcStart.v - center.v, arcStart.u - center.u);
+    const endAng = Math.atan2(arcEnd.v - center.v, arcEnd.u - center.u);
+    const sweepDir = insideSign > 0 ? 1 : -1;
+    let delta = endAng - startAng;
+    if (sweepDir > 0 && delta <= 0) delta += Math.PI * 2;
+    if (sweepDir < 0 && delta >= 0) delta -= Math.PI * 2;
+    const steps = Math.max(1, Math.ceil(Math.abs(delta) / (Math.PI / 18)));
+
+    segmentEnd[i - 1] = arcStart;
+    segmentStart[i] = arcEnd;
+    const arcPts = [arcStart];
+    for (let step = 1; step < steps; step++) {
+      const ang = startAng + sweepDir * (Math.abs(delta) * (step / steps));
+      arcPts.push({
+        u: center.u + Math.cos(ang) * actualArcRadius,
+        v: center.v + Math.sin(ang) * actualArcRadius,
+        w: curr.w,
+      });
+    }
+    arcPts.push(arcEnd);
+    arcSamples[i] = arcPts;
+    arcNames[i] = buildFilletEdgeName(baseNames[i - 1], baseNames[i]);
+    arcInfo.push({
+      name: arcNames[i] || buildFilletEdgeName(baseNames[i - 1], baseNames[i]),
+      center,
+      radius,
+    });
+    arcCenters[i] = center;
+    arcSweepDirs[i] = sweepDir;
+  }
+
+  const segmentDirections = new Array(segCount);
+  const dirBetween = (a, b) => {
+    const dx = (b?.u ?? 0) - (a?.u ?? 0);
+    const dy = (b?.v ?? 0) - (a?.v ?? 0);
+    const l = Math.hypot(dx, dy);
+    if (l < 1e-12) return null;
+    return { x: dx / l, y: dy / l };
+  };
+  for (let i = 0; i < segCount; i++) {
+    segmentDirections[i] = dirBetween(segmentStart[i], segmentEnd[i]);
+  }
+  let fallbackDir = null;
+  for (const dir of segmentDirections) {
+    if (dir) {
+      fallbackDir = dir;
+      break;
+    }
+  }
+  if (!fallbackDir) fallbackDir = { x: 1, y: 0 };
+  const safeDir = (dir) => {
+    if (dir && Number.isFinite(dir.x) && Number.isFinite(dir.y) && Math.hypot(dir.x, dir.y) > 1e-12) {
+      return dir;
+    }
+    return fallbackDir;
+  };
+
+  const outCoords = [];
+  const outNames = [];
+  const outTangents = [];
+  const coordsEqual = (a, b) => !a || !b
+    ? false
+    : (Math.abs(a.u - b.u) < 1e-9 && Math.abs(a.v - b.v) < 1e-9 && Math.abs((a.w || 0) - (b.w || 0)) < 1e-9);
+  const normalizeTan = (tan) => {
+    if (!tan || !Number.isFinite(tan.x) || !Number.isFinite(tan.y)) return null;
+    const l = Math.hypot(tan.x, tan.y);
+    if (l < 1e-12) return null;
+    return { x: tan.x / l, y: tan.y / l };
+  };
+  const pushCoord = (coord, segName, tangent = null) => {
+    if (!coord) return false;
+    const copy = { u: coord.u, v: coord.v, w: coord.w };
+    const tanNorm = normalizeTan(tangent);
+    if (!outCoords.length) {
+      outCoords.push(copy);
+      outTangents.push(tanNorm);
+      return true;
+    }
+    const last = outCoords[outCoords.length - 1];
+    if (coordsEqual(last, copy)) {
+      if (!outTangents[outTangents.length - 1] && tanNorm) {
+        outTangents[outTangents.length - 1] = tanNorm;
+      }
+      return false;
+    }
+    outCoords.push(copy);
+    outTangents.push(tanNorm);
+    if (segName) {
+      outNames[outCoords.length - 2] = segName;
+    }
+    return true;
+  };
+
+  const arcTangent = (center, pt, sweepDir) => {
+    if (!center || !pt) return null;
+    const dx = pt.u - center.u;
+    const dy = pt.v - center.v;
+    const l = Math.hypot(dx, dy);
+    if (l < 1e-12) return null;
+    return sweepDir > 0
+      ? { x: -dy / l, y: dx / l }
+      : { x: dy / l, y: -dx / l };
+  };
+
+  for (let seg = 0; seg < segCount; seg++) {
+    const segTangent = safeDir(segmentDirections[seg]);
+    pushCoord(segmentStart[seg], null, segTangent);
+    const segName = baseNames[seg] || `SEG_${seg}`;
+    pushCoord(segmentEnd[seg], segName, segTangent);
+    const arc = arcSamples[seg + 1];
+    if (arc && arc.length >= 2) {
+      const arcName = arcNames[seg + 1] || buildFilletEdgeName(baseNames[seg], baseNames[seg + 1]);
+      const center = arcCenters[seg + 1];
+      const sweepDir = arcSweepDirs[seg + 1] || 1;
+      for (let j = 1; j < arc.length; j++) {
+        const pt = arc[j];
+        const tan = arcTangent(center, pt, sweepDir) || segTangent;
+        pushCoord(pt, arcName, tan);
+      }
+    }
+  }
+
+  const outPoints = outCoords.map((coord) => to3D(coord));
+  return {
+    points: outPoints,
+    segmentNames: normalizeSegmentNameCount(outNames, outPoints.length - 1),
+    points2D: outCoords.map((coord) => ({ ...coord })),
+    tangents2D: outTangents.map((tan) => (tan ? { x: tan.x, y: tan.y } : null)),
+    arcs: arcInfo,
+  };
+}
+
+function buildContourFlangeStripFaces({
+  featureID,
+  pathPoints,
+  pathSegmentNames,
+  planeBasis,
+  thickness,
+  sheetSide,
+  path2DOverride = null,
+  pathTangents2D = null,
+}) {
+  if (!Array.isArray(pathPoints) || pathPoints.length < 2) {
+    throw new Error("Contour flange strip requires at least two path points.");
+  }
+  if (!(planeBasis?.origin && planeBasis?.xAxis && planeBasis?.yAxis && planeBasis?.planeNormal)) {
+    throw new Error("Contour flange could not resolve a sketch plane basis.");
+  }
+
+  const converters = createPlaneBasisConverters(planeBasis);
+  let path2D = Array.isArray(path2DOverride) && path2DOverride.length === pathPoints.length
+    ? path2DOverride.map((coord) => ({ u: coord.u, v: coord.v, w: coord.w }))
+    : pathPoints.map((pt) => converters.to2D(pt));
+  const tangentHints = Array.isArray(pathTangents2D) && pathTangents2D.length === path2D.length
+    ? pathTangents2D.map((tan) => {
+      if (!tan) return null;
+      const x = Number(tan.x ?? tan.u ?? tan[0]);
+      const y = Number(tan.y ?? tan.v ?? tan[1]);
+      if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
+      const len = Math.hypot(x, y);
+      if (len < 1e-12) return null;
+      return { x: x / len, y: y / len };
+    })
+    : null;
+  const pathNames = normalizeSegmentNameCount(pathSegmentNames, path2D.length - 1);
+  let offset2D = offsetPolyline2D(path2D, thickness, sheetSide, tangentHints);
+  if (!offset2D || offset2D.length !== path2D.length) {
+    throw new Error("Contour flange failed to compute the offset path.");
+  }
+  const areaTolerance = Math.max(thickness * thickness * 1e-6, 1e-9);
+  const pathGroups = groupSegmentsByName(pathNames);
+  if (!pathGroups.length && path2D.length >= 2) {
+    pathGroups.push({ name: "SEG_0", startIndex: 0, endIndex: path2D.length - 2 });
+  }
+  const faces = [];
+  let segmentCounter = 0;
+  for (const group of pathGroups) {
+    const face = buildSegmentFace({
+      featureID,
+      converters,
+      path2D,
+      offset2D,
+      startIndex: group.startIndex,
+      endIndex: group.endIndex,
+      segmentName: group.name,
+      areaTolerance,
+      segmentIndex: segmentCounter++,
+    });
+    if (face) faces.push(face);
+  }
+
+  if (!faces.length) {
+    throw new Error("Contour flange failed to create planar strip regions from the selected path.");
+  }
+
+  return faces;
+}
+
+function groupSegmentsByName(names) {
+  const result = [];
+  if (!Array.isArray(names) || !names.length) return result;
+  let current = names[0];
+  let startIndex = 0;
+  for (let i = 1; i <= names.length; i++) {
+    const next = names[i];
+    if (next !== current) {
+      result.push({ name: current, startIndex, endIndex: i - 1 });
+      startIndex = i;
+      current = next;
+    }
+  }
+  return result;
+}
+
+function buildSegmentFace({
+  featureID,
+  converters,
+  path2D,
+  offset2D,
+  startIndex,
+  endIndex,
+  segmentName,
+  areaTolerance,
+  segmentIndex,
+}) {
+  const pathSlice = [];
+  const offsetSlice = [];
+  for (let i = startIndex; i <= endIndex + 1 && i < path2D.length; i++) {
+    pathSlice.push({ ...path2D[i] });
+  }
+  for (let i = startIndex; i <= endIndex + 1 && i < offset2D.length; i++) {
+    offsetSlice.push({ ...offset2D[i] });
+  }
+  if (pathSlice.length < 2 || offsetSlice.length < 2) return null;
+
+  const polygon = buildSegmentPolygon(pathSlice, offsetSlice);
+  const loopCoords = dedupePolygonCoords(polygon);
+  if (loopCoords.length < 3) return null;
+
+  let area = polygonArea2D(loopCoords);
+  if (!Number.isFinite(area) || Math.abs(area) < areaTolerance) return null;
+  if (area < 0) loopCoords.reverse();
+
+  const triangles = triangulatePolygon(loopCoords);
+  if (!triangles.length) return null;
+
+  const worldPts = loopCoords.map((coord) => converters.to3D(coord));
+  const positionArray = new Float32Array(worldPts.length * 3);
+  for (let i = 0; i < worldPts.length; i++) {
+    positionArray[i * 3 + 0] = worldPts[i].x;
+    positionArray[i * 3 + 1] = worldPts[i].y;
+    positionArray[i * 3 + 2] = worldPts[i].z;
+  }
+  const indexArray = new Uint32Array(triangles.length * 3);
+  for (let i = 0; i < triangles.length; i++) {
+    const tri = triangles[i];
+    indexArray[i * 3 + 0] = tri[0];
+    indexArray[i * 3 + 1] = tri[1];
+    indexArray[i * 3 + 2] = tri[2];
+  }
+
+  const geometry = new THREE.BufferGeometry();
+  geometry.setAttribute("position", new THREE.BufferAttribute(positionArray, 3));
+  geometry.setIndex(new THREE.BufferAttribute(indexArray, 1));
+
+  const baseName = segmentName || `SEG_${segmentIndex}`;
+  const face = new BREP.Face(geometry);
+  face.name = featureID ? `${featureID}:${baseName}` : `SM.CF_${baseName}`;
+
+  const loopWorld = worldPts.map((pt) => [pt.x, pt.y, pt.z]);
+  if (loopWorld.length >= 2) {
+    const first = loopWorld[0];
+    const last = loopWorld[loopWorld.length - 1];
+    if (first[0] === last[0] && first[1] === last[1] && first[2] === last[2]) {
+      loopWorld.pop();
+    }
+  }
+  face.userData = face.userData || {};
+  face.userData.boundaryLoopsWorld = [{ pts: loopWorld, isHole: false }];
+
+  const pathEdgePts = pathSlice.map((coord) => converters.to3D(coord));
+  const offsetEdgePts = offsetSlice.map((coord) => converters.to3D(coord));
+  const pathEdge = createPseudoEdge(baseName, pathEdgePts);
+  const offsetEdge = createPseudoEdge(`${baseName}_OFFSET`, offsetEdgePts);
+  const startClosure = createPseudoEdge(`${baseName}_START_CAP`, [pathEdgePts[0], offsetEdgePts[0]]);
+  const endClosure = createPseudoEdge(
+    `${baseName}_END_CAP`,
+    [pathEdgePts[pathEdgePts.length - 1], offsetEdgePts[offsetEdgePts.length - 1]],
+  );
+  const edges = [pathEdge, offsetEdge, startClosure, endClosure].filter(Boolean);
+  face.edges = edges;
+
+  const baseEdges = pathEdge ? [pathEdge.name] : [];
+  const offsetEdges = offsetEdge ? [offsetEdge.name] : [];
+  const closureEdges = [startClosure?.name, endClosure?.name].filter(Boolean);
+  face.userData.sheetMetalEdgeGroups = {
+    baseEdges,
+    offsetEdges,
+    closureEdges,
+  };
+  return face;
+}
+
+function buildSegmentPolygon(pathSlice, offsetSlice) {
+  const polygon = [];
+  for (const coord of pathSlice) {
+    polygon.push({ ...coord });
+  }
+  for (let i = offsetSlice.length - 1; i >= 0; i--) {
+    polygon.push({ ...offsetSlice[i] });
+  }
+  return polygon;
+}
+
+function dedupePolygonCoords(coords) {
+  const out = [];
+  const push = (coord) => {
+    if (!coord) return;
+    if (!out.length || !coordsAlmostEqual(out[out.length - 1], coord)) {
+      out.push({ u: coord.u, v: coord.v, w: coord.w });
+    }
+  };
+  for (const coord of coords) push(coord);
+  if (out.length >= 2 && coordsAlmostEqual(out[0], out[out.length - 1])) {
+    out.pop();
+  }
+  return out;
+}
+
+function coordsAlmostEqual(a, b, eps = 1e-9) {
+  if (!a || !b) return false;
+  return (
+    Math.abs(a.u - b.u) < eps
+    && Math.abs(a.v - b.v) < eps
+    && Math.abs((a.w || 0) - (b.w || 0)) < eps
+  );
+}
+
+function triangulatePolygon(points) {
+  if (!Array.isArray(points) || points.length < 3) return [];
+  const contour = points.map((coord) => new THREE.Vector2(coord.u, coord.v));
+  let tris = THREE.ShapeUtils.triangulateShape(contour, []);
+  if (!Array.isArray(tris) || !tris.length) {
+    tris = [];
+    for (let i = 1; i < points.length - 1; i++) {
+      tris.push([0, i, i + 1]);
+    }
+  }
+  return tris;
+}
+
+let pseudoEdgeCounter = 0;
+function createPseudoEdge(name, points) {
+  if (!Array.isArray(points) || points.length < 2) return null;
+  const sanitized = points.map((pt) => [pt.x, pt.y, pt.z]);
+  return {
+    type: "EDGE",
+    name: name || `SMCF_EDGE_${pseudoEdgeCounter++}`,
+    userData: { polylineLocal: sanitized },
+    matrixWorld: new THREE.Matrix4(),
+    closedLoop: false,
+    updateWorldMatrix: () => { },
+  };
+}
+
+function createPlaneBasisConverters(basis) {
+  const origin = basis.origin instanceof THREE.Vector3
+    ? basis.origin.clone()
+    : Array.isArray(basis.origin)
+      ? new THREE.Vector3().fromArray(basis.origin)
+      : new THREE.Vector3(0, 0, 0);
+  const xAxis = basis.xAxis instanceof THREE.Vector3
+    ? basis.xAxis.clone()
+    : Array.isArray(basis.xAxis)
+      ? new THREE.Vector3().fromArray(basis.xAxis)
+      : new THREE.Vector3(1, 0, 0);
+  const yAxis = basis.yAxis instanceof THREE.Vector3
+    ? basis.yAxis.clone()
+    : Array.isArray(basis.yAxis)
+      ? new THREE.Vector3().fromArray(basis.yAxis)
+      : new THREE.Vector3(0, 1, 0);
+  const planeNormal = basis.planeNormal instanceof THREE.Vector3
+    ? basis.planeNormal.clone()
+    : Array.isArray(basis.planeNormal)
+      ? new THREE.Vector3().fromArray(basis.planeNormal)
+      : new THREE.Vector3(0, 0, 1);
+  return {
+    origin,
+    planeNormal,
+    to2D(vec) {
+      const rel = vec.clone().sub(origin);
+      return {
+        u: rel.dot(xAxis),
+        v: rel.dot(yAxis),
+        w: rel.dot(planeNormal),
+      };
+    },
+    to3D(coord) {
+      return origin.clone()
+        .add(xAxis.clone().multiplyScalar(coord.u))
+        .add(yAxis.clone().multiplyScalar(coord.v))
+        .add(planeNormal.clone().multiplyScalar(coord.w || 0));
+    },
+  };
+}
+
+function offsetPolyline2D(path2D, thickness, sheetSide, tangentHints = null) {
+  if (!Array.isArray(path2D) || path2D.length < 2) return [];
+  const EPS = 1e-10;
+  const normalizedTangents = Array.isArray(tangentHints) && tangentHints.length === path2D.length
+    ? tangentHints.map((tan) => {
+      if (!tan) return null;
+      const x = Number(tan.x ?? tan.u ?? tan[0]);
+      const y = Number(tan.y ?? tan.v ?? tan[1]);
+      const len = Math.hypot(x, y);
+      if (!Number.isFinite(x) || !Number.isFinite(y) || len < EPS) return null;
+      return { x: x / len, y: y / len };
+    })
+    : null;
+  const dirs = [];
+  for (let i = 0; i < path2D.length - 1; i++) {
+    const dx = path2D[i + 1].u - path2D[i].u;
+    const dy = path2D[i + 1].v - path2D[i].v;
+    const len = Math.hypot(dx, dy);
+    dirs.push(len > EPS ? { x: dx / len, y: dy / len } : null);
+  }
+
+  let fallback = null;
+  for (const dir of dirs) {
+    if (dir) {
+      fallback = dir;
+      break;
+    }
+  }
+  if (!fallback && normalizedTangents) {
+    for (const tan of normalizedTangents) {
+      if (tan) {
+        fallback = tan;
+        break;
+      }
+    }
+  }
+  if (!fallback) fallback = { x: 1, y: 0 };
+
+  const sideSign = sheetSide === "right" ? -1 : 1;
+  const safeDir = (dir) => (dir && Number.isFinite(dir.x) && Number.isFinite(dir.y)
+    ? dir
+    : fallback);
+  const rotateDir = (dir) => {
+    const base = safeDir(dir);
+    return { x: -base.y * sideSign, y: base.x * sideSign };
+  };
+  const offsetPoint = (pt, perp) => ({
+    u: pt.u + perp.x * thickness,
+    v: pt.v + perp.y * thickness,
+    w: pt.w,
+  });
+  const offsets = new Array(path2D.length);
+  const tangentOffset = (index) => {
+    if (!normalizedTangents) return null;
+    const tan = normalizedTangents[index];
+    if (!tan) return null;
+    return offsetPoint(path2D[index], rotateDir(tan));
+  };
+  const getPrevDir = (vertexIndex) => {
+    for (let seg = vertexIndex - 1; seg >= 0; seg--) {
+      if (dirs[seg]) return dirs[seg];
+    }
+    return normalizedTangents?.[vertexIndex] || fallback;
+  };
+  const getNextDir = (vertexIndex) => {
+    for (let seg = vertexIndex; seg < dirs.length; seg++) {
+      if (dirs[seg]) return dirs[seg];
+    }
+    return normalizedTangents?.[vertexIndex] || fallback;
+  };
+
+  offsets[0] = tangentOffset(0) || offsetPoint(path2D[0], rotateDir(getNextDir(0)));
+  for (let i = 1; i < path2D.length - 1; i++) {
+    const directOffset = tangentOffset(i);
+    if (directOffset) {
+      offsets[i] = directOffset;
+      continue;
+    }
+    const prevDir = safeDir(getPrevDir(i));
+    const nextDir = safeDir(getNextDir(i));
+    const perpPrev = rotateDir(prevDir);
+    const perpNext = rotateDir(nextDir);
+    const a = offsetPoint(path2D[i], perpPrev);
+    const b = offsetPoint(path2D[i], perpNext);
+    const hit = intersectLines2D(a, prevDir, b, nextDir);
+    if (hit) {
+      offsets[i] = { u: hit.u, v: hit.v, w: path2D[i].w };
+    } else {
+      offsets[i] = {
+        u: 0.5 * (a.u + b.u),
+        v: 0.5 * (a.v + b.v),
+        w: path2D[i].w,
+      };
+    }
+  }
+  offsets[path2D.length - 1] = tangentOffset(path2D.length - 1)
+    || offsetPoint(path2D[path2D.length - 1], rotateDir(getPrevDir(path2D.length - 1)));
+  return offsets;
+}
+
+function intersectLines2D(pointA, dirA, pointB, dirB) {
+  const dAx = dirA?.x ?? 0;
+  const dAy = dirA?.y ?? 0;
+  const dBx = dirB?.x ?? 0;
+  const dBy = dirB?.y ?? 0;
+  const denom = dAx * dBy - dAy * dBx;
+  if (!Number.isFinite(denom) || Math.abs(denom) < 1e-12) {
+    return null;
+  }
+  const diffX = pointB.u - pointA.u;
+  const diffY = pointB.v - pointA.v;
+  const t = (diffX * dBy - diffY * dBx) / denom;
+  return {
+    u: pointA.u + dAx * t,
+    v: pointA.v + dAy * t,
+    w: pointA.w,
+  };
+}
+
+function polygonArea2D(points) {
+  if (!Array.isArray(points) || points.length < 3) return 0;
+  let area = 0;
+  for (let i = 0; i < points.length; i++) {
+    const a = points[i];
+    const b = points[(i + 1) % points.length];
+    area += (a.u * b.v) - (a.v * b.u);
+  }
+  return area / 2;
+}
+
+function resolveSheetSideOption(inputParams) {
+  const legacyValue = inputParams?.sheetSide;
+  const reverseRaw = inputParams?.reverseSheetSide;
+  let sheetSide = "left";
+  if (typeof reverseRaw === "boolean") {
+    sheetSide = reverseRaw ? "right" : "left";
+  } else if (legacyValue != null) {
+    sheetSide = (String(legacyValue).toLowerCase() === "right") ? "right" : "left";
+  }
+  const reverseSheetSide = sheetSide === "right";
+  if (inputParams && typeof reverseRaw !== "boolean") {
+    inputParams.reverseSheetSide = reverseSheetSide;
+  }
+  return { sheetSide, reverseSheetSide };
+}
+
+function normalizeSegmentNameCount(names, expectedLength) {
+  const count = Math.max(0, Number(expectedLength) || 0);
+  const result = new Array(count);
+  for (let i = 0; i < count; i++) {
+    const raw = Array.isArray(names) ? names[i] : null;
+    if (typeof raw === "string" && raw.trim().length) {
+      result[i] = raw.trim();
+    } else {
+      result[i] = `SEG_${i}`;
+    }
+  }
+  return result;
+}
+
+function buildDefaultSegmentNames(count) {
+  const total = Math.max(0, Number(count) || 0);
+  return Array.from({ length: total }, (_, i) => `SEG_${i}`);
+}
+
+function buildFilletEdgeName(nameA, nameB) {
+  const left = (typeof nameA === "string" && nameA.trim().length) ? nameA.trim() : null;
+  const right = (typeof nameB === "string" && nameB.trim().length) ? nameB.trim() : null;
+  if (left && right && left !== right) return `${left}__${right}`;
+  if (left && right) return `${left}_ARC`;
+  if (left) return `${left}__SMCF`;
+  if (right) return `SMCF__${right}`;
+  return "SMCF_FILLET";
+}
+
+function deriveEdgeBaseName(edge, fallbackIndex) {
+  const fallback = `EDGE_${fallbackIndex}`;
+  if (!edge) return fallback;
+  const direct = typeof edge.name === "string" && edge.name.trim().length ? edge.name.trim() : null;
+  if (direct) return direct;
+  const skId = edge.userData?.sketchGeometryId ?? edge.userData?.sketchGeomId ?? edge.userData?.id;
+  if (skId != null) return `SKETCH_EDGE_${skId}`;
+  const uid = edge.uuid ? String(edge.uuid).slice(0, 8) : null;
+  if (uid) return `EDGE_${uid}`;
+  return fallback;
+}
+
+function tagContourFlangeFaceTypes(sweep) {
+  if (!sweep || typeof sweep.getFaceNames !== "function") return;
+  const names = sweep.getFaceNames();
+  const thicknessFaces = names.filter((name) =>
+    name.endsWith("_START")
+    || name.endsWith("_END")
+    || name.includes("_CAP_SW"),
+  );
+  const bFaces = names.filter((name) => name.includes("_OFFSET_SW"));
+  const aFaces = names.filter((name) =>
+    name.endsWith("_SW")
+    && !name.includes("_OFFSET_SW")
+    && !name.includes("_CAP_SW"),
+  );
+  setSheetMetalFaceTypeMetadata(sweep, aFaces, SHEET_METAL_FACE_TYPES.A);
+  setSheetMetalFaceTypeMetadata(sweep, bFaces, SHEET_METAL_FACE_TYPES.B);
+  setSheetMetalFaceTypeMetadata(sweep, thicknessFaces, SHEET_METAL_FACE_TYPES.THICKNESS);
+}
+
+function addCylMetadataToSideFaces(
+  sweep,
+  arcs,
+  converters,
+  extrudeVector,
+  axisDir,
+  thickness = 0,
+  bendRadius = null,
+  sheetSide = "left",
+) {
+  if (!sweep || !Array.isArray(sweep.faces)) return;
+  const arcList = Array.isArray(arcs) ? arcs.filter((a) => a && a.center && Number.isFinite(a.radius)) : [];
+  if (!arcList.length) return;
+
+  const height = extrudeVector.length();
+  const featureTag = sweep.params?.name ? `${sweep.params.name}:` : "";
+  const v = new THREE.Vector3();
+  const eps = 1e-9;
+  const relStdTol = 0.02;
+  const absStdTol = Math.max(1e-5, Math.abs(thickness || 0) * 0.02, Math.abs(bendRadius || 0) * 0.02);
+
+  const arc3D = arcList.map((arc) => {
+    const startCenter = converters.to3D(arc.center);
+    const endCenter = startCenter.clone().add(extrudeVector);
+    return {
+      name: arc.name || "BEND",
+      radius: arc.radius,
+      axisStart: startCenter,
+      axisEnd: endCenter,
+    };
+  });
+
+  const arc3DByName = new Map();
+  for (const arc of arc3D) {
+    const name = typeof arc.name === "string" ? arc.name.trim() : "";
+    if (!name) continue;
+    let list = arc3DByName.get(name);
+    if (!list) { list = []; arc3DByName.set(name, list); }
+    list.push(arc);
+  }
+
+  const isFacePlanar = (face) => {
+    const geom = face?.geometry;
+    const pos = geom?.getAttribute?.("position");
+    if (!pos || pos.count < 3) return null;
+    const idx = geom.getIndex?.() || null;
+    const triCount = idx ? (idx.count / 3) | 0 : (pos.count / 3) | 0;
+    if (!triCount) return null;
+
+    const a = new THREE.Vector3();
+    const b = new THREE.Vector3();
+    const c = new THREE.Vector3();
+    const m = face.matrixWorld || null;
+    const getPos = (out, i) => {
+      out.set(pos.getX(i), pos.getY(i), pos.getZ(i));
+      if (m) out.applyMatrix4(m);
+      return out;
+    };
+
+    let nx = 0;
+    let ny = 0;
+    let nz = 0;
+    let areaSum = 0;
+    for (let t = 0; t < triCount; t++) {
+      const base = t * 3;
+      const i0 = idx ? idx.getX(base) >>> 0 : base;
+      const i1 = idx ? idx.getX(base + 1) >>> 0 : base + 1;
+      const i2 = idx ? idx.getX(base + 2) >>> 0 : base + 2;
+      getPos(a, i0);
+      getPos(b, i1);
+      getPos(c, i2);
+      const abx = b.x - a.x;
+      const aby = b.y - a.y;
+      const abz = b.z - a.z;
+      const acx = c.x - a.x;
+      const acy = c.y - a.y;
+      const acz = c.z - a.z;
+      const tx = aby * acz - abz * acy;
+      const ty = abz * acx - abx * acz;
+      const tz = abx * acy - aby * acx;
+      const area = Math.hypot(tx, ty, tz);
+      if (area <= 1e-12) continue;
+      nx += tx;
+      ny += ty;
+      nz += tz;
+      areaSum += area;
+    }
+
+    const len = Math.hypot(nx, ny, nz);
+    if (!(len > 1e-12) || !(areaSum > 1e-12)) return null;
+    const ax = nx / len;
+    const ay = ny / len;
+    const az = nz / len;
+    let maxAngle = 0;
+    for (let t = 0; t < triCount; t++) {
+      const base = t * 3;
+      const i0 = idx ? idx.getX(base) >>> 0 : base;
+      const i1 = idx ? idx.getX(base + 1) >>> 0 : base + 1;
+      const i2 = idx ? idx.getX(base + 2) >>> 0 : base + 2;
+      getPos(a, i0);
+      getPos(b, i1);
+      getPos(c, i2);
+      const abx = b.x - a.x;
+      const aby = b.y - a.y;
+      const abz = b.z - a.z;
+      const acx = c.x - a.x;
+      const acy = c.y - a.y;
+      const acz = c.z - a.z;
+      const tx = aby * acz - abz * acy;
+      const ty = abz * acx - abx * acz;
+      const tz = abx * acy - aby * acx;
+      const nLen = Math.hypot(tx, ty, tz);
+      if (nLen <= 1e-12) continue;
+      const dot = Math.abs((tx / nLen) * ax + (ty / nLen) * ay + (tz / nLen) * az);
+      const clamped = Math.max(-1, Math.min(1, dot));
+      const angle = Math.acos(clamped);
+      if (angle > maxAngle) maxAngle = angle;
+    }
+
+    const planarRatio = len / areaSum;
+    return planarRatio >= 0.9995 && maxAngle <= (Math.PI / 180);
+  };
+
+  const findArcCandidates = (sourceName) => {
+    if (!sourceName) return arc3D;
+    const trimmed = String(sourceName).trim();
+    if (!trimmed) return arc3D;
+    const direct = arc3DByName.get(trimmed);
+    if (direct && direct.length) return direct;
+    const tail = trimmed.includes(":") ? trimmed.split(":").slice(-1)[0] : trimmed;
+    if (tail !== trimmed) {
+      const directTail = arc3DByName.get(tail);
+      if (directTail && directTail.length) return directTail;
+    }
+    return [];
+  };
+
+  // Centerlines per arc
+  for (const arc of arc3D) {
+    const clName = `${featureTag}${arc.name}_AXIS`;
+    try { sweep.addCenterline(arc.axisStart, arc.axisEnd, clName, { polylineWorld: true }); } catch { /* optional */ }
+  }
+
+  // Attach metadata by geometric fit to each side face
+  for (const face of sweep.faces) {
+    try {
+      const meta = face.getMetadata?.() || {};
+      const faceType = meta?.faceType;
+      if (faceType && faceType !== "SIDEWALL") continue;
+      if (isFacePlanar(face)) continue;
+      const pos = face.geometry?.getAttribute?.("position");
+      if (!pos || pos.itemSize !== 3 || pos.count < 3) continue;
+      const verts = [];
+      for (let i = 0; i < pos.count; i++) {
+        v.set(pos.getX(i), pos.getY(i), pos.getZ(i)).applyMatrix4(face.matrixWorld);
+        verts.push(v.clone());
+      }
+      const sourceEdgeName = meta?.sourceEdgeName || face?.name || null;
+      let candidates = findArcCandidates(sourceEdgeName);
+      if (!candidates.length) candidates = arc3D;
+      let best = null;
+      for (const arc of candidates) {
+        const axisVec = arc.axisEnd.clone().sub(arc.axisStart);
+        const axisLen = axisVec.length();
+        if (axisLen < 1e-9) continue;
+        const axisN = axisVec.clone().normalize();
+        const origin = arc.axisStart;
+        let sumDist = 0;
+        let sumSqDist = 0;
+        let minT = Infinity;
+        let maxT = -Infinity;
+        for (const p of verts) {
+          const t = p.clone().sub(origin).dot(axisN);
+          if (t < minT) minT = t;
+          if (t > maxT) maxT = t;
+          const proj = origin.clone().add(axisN.clone().multiplyScalar(t));
+          const d = p.distanceTo(proj);
+          sumDist += d;
+          sumSqDist += d * d;
+        }
+        const meanRadius = sumDist / verts.length;
+        if (!(meanRadius > eps)) continue;
+        const variance = Math.max(0, sumSqDist / verts.length - meanRadius * meanRadius);
+        const std = Math.sqrt(variance);
+        const relStd = std / meanRadius;
+        if (std > absStdTol && relStd > relStdTol) continue;
+        if (!best || relStd < best.relStd) {
+          best = {
+            arc,
+            relStd,
+            radius: meanRadius,
+            axisN,
+            center: origin.clone().add(axisN.clone().multiplyScalar((minT + maxT) * 0.5)),
+            height: maxT - minT,
+          };
+        }
+      }
+      if (best) {
+        const arc = best.arc;
+        const axisN = best.axisN || arc.axisEnd.clone().sub(arc.axisStart).normalize();
+        const snappedR = best.radius;
+        const adjustedCenter = best.center.clone();
+        sweep.setFaceMetadata(face.name, {
+          type: "cylindrical",
+          radius: snappedR, // enforce stable bend radius independent of sheet side
+          height: best.height || height,
+          axis: [axisN.x, axisN.y, axisN.z],
+          center: [adjustedCenter.x, adjustedCenter.y, adjustedCenter.z],
+          pmiRadiusOverride: snappedR,
+        });
+      }
+    } catch { /* ignore */ }
+  }
+}