brepjs 8.4.0 → 8.7.4

package/dist/brepjs.cjs

@@ -1,30 +1,29 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const occtBoundary = require("./occtBoundary-CocN2VKx.cjs");
-const errors = require("./errors-D13q2HCk.cjs");
-const shapeTypes = require("./shapeTypes-BxVxLdiD.cjs");
+const occtBoundary = require("./occtBoundary-DH2VO-rq.cjs");
+const errors = require("./errors-eRQu29oc.cjs");
+const shapeTypes = require("./shapeTypes-CMjrTv36.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const Blueprint = require("./Blueprint-zgFe_5Qj.cjs");
-const curveFns = require("./curveFns-VMxgfkqw.cjs");
-const loft$2 = require("./loft-B-UCPW9P.cjs");
-const operations = require("./operations-BQeW_DSM.cjs");
-const boolean2D = require("./boolean2D-CfEbRMPF.cjs");
+const Blueprint = require("./Blueprint-BcbOBF-9.cjs");
+const curveFns = require("./curveFns-BXCbASW-.cjs");
+const loft$2 = require("./loft-BcyyvWCj.cjs");
+const operations = require("./operations-CdELWxgv.cjs");
+const boolean2D = require("./boolean2D-CqacqjME.cjs");
 const _2d = require("./2d.cjs");
-const helpers = require("./helpers-C0q_FVxq.cjs");
+const helpers = require("./helpers-CC21GeAr.cjs");
 const io = require("./io.cjs");
-const drawFns = require("./drawFns-CKaHgGSK.cjs");
-const vectors = require("./vectors-DVmHF4zt.cjs");
-const shapeFns = require("./shapeFns-B0zSdO9c.cjs");
-const topology = require("./topology-CycEc6Oe.cjs");
-const faceFns = require("./faceFns-es3GENII.cjs");
-const meshFns = require("./meshFns-DDC_2U81.cjs");
-const booleanFns = require("./booleanFns-5dDG0jpA.cjs");
-const measurement = require("./measurement-CYmT-C77.cjs");
-const curveBuilders = require("./curveBuilders-BkEJ-RVn.cjs");
-const cast = require("./cast-CPNOTNFm.cjs");
+const drawFns = require("./drawFns-CAmFEqd1.cjs");
+const vectors = require("./vectors-DwFeX0Ja.cjs");
+const shapeFns = require("./shapeFns-3RYtsUVY.cjs");
+const booleanFns = require("./booleanFns-NtKxkiXn.cjs");
+const topology = require("./topology-D-nGjCzV.cjs");
+const faceFns = require("./faceFns-DcndPHWm.cjs");
+const meshFns = require("./meshFns-DawUwI3W.cjs");
+const measurement = require("./measurement-DU3ry-0Q.cjs");
+const surfaceBuilders = require("./surfaceBuilders-Xx9DRRxs.cjs");
 const query = require("./query.cjs");
 const result = require("./result.cjs");
-const cornerFinder = require("./cornerFinder-BQ-_VJx0.cjs");
+const cornerFinder = require("./cornerFinder-Bqy8Lw2p.cjs");
 const worker = require("./worker.cjs");
 const errorFactories = {
   OCCT_OPERATION: (code, message, cause) => ({ kind: "OCCT_OPERATION", code, message, cause }),
@@ -82,7 +81,7 @@ function buildWireFinder(filters) {
       isOpen: () => withFilter((wire2) => !curveFns.curveIsClosed(wire2)),
       ofEdgeCount: (count) => withFilter((wire2) => {
         let edgeCount = 0;
-        for (const _raw of cast.iterTopo(wire2.wrapped, "edge")) {
+        for (const _raw of faceFns.iterTopo(wire2.wrapped, "edge")) {
           edgeCount++;
         }
         return edgeCount === count;
@@ -145,6 +144,261 @@ function buildVertexFinder(filters) {
 function vertexFinder() {
   return buildVertexFinder([]);
 }
+function surfaceFromGrid(heights, options = {}) {
+  if (heights.length < 2) {
+    return errors.err(
+      errors.validationError(
+        errors.BrepErrorCode.SURFACE_GRID_TOO_SMALL,
+        `surfaceFromGrid: need at least 2 rows, got ${heights.length}`
+      )
+    );
+  }
+  const rows = heights.length;
+  const cols = heights[0]?.length ?? 0;
+  if (cols < 2) {
+    return errors.err(
+      errors.validationError(
+        errors.BrepErrorCode.SURFACE_GRID_TOO_SMALL,
+        `surfaceFromGrid: need at least 2 columns, got ${cols}`
+      )
+    );
+  }
+  for (let r = 0; r < rows; r++) {
+    const row = heights[r];
+    if (!row || row.length !== cols) {
+      return errors.err(
+        errors.validationError(
+          errors.BrepErrorCode.SURFACE_GRID_JAGGED,
+          `surfaceFromGrid: row ${r} has ${row?.length ?? 0} columns, expected ${cols}`
+        )
+      );
+    }
+  }
+  const { width = cols - 1, depth = rows - 1, scaleZ = 1 } = options;
+  const dx = width / (cols - 1);
+  const dy = depth / (rows - 1);
+  try {
+    return buildBSplineSurface(heights, rows, cols, dx, dy, scaleZ);
+  } catch {
+  }
+  try {
+    return buildTriangulatedSurface(heights, rows, cols, dx, dy, scaleZ);
+  } catch (e) {
+    const raw = e instanceof Error ? e.message : String(e);
+    return errors.err(errors.occtError(errors.BrepErrorCode.SURFACE_FAILED, `surfaceFromGrid failed: ${raw}`, e));
+  }
+}
+function buildBSplineSurface(heights, rows, cols, dx, dy, scaleZ) {
+  const oc = occtBoundary.getKernel().oc;
+  const OC = oc;
+  const pntArray = new OC.TColgp_Array2OfPnt_2(1, rows, 1, cols);
+  try {
+    for (let r = 0; r < rows; r++) {
+      for (let c = 0; c < cols; c++) {
+        const row = heights[r];
+        const z = (row ? row[c] ?? 0 : 0) * scaleZ;
+        const pnt = new oc.gp_Pnt_3(c * dx, r * dy, z);
+        pntArray.SetValue(r + 1, c + 1, pnt);
+        pnt.delete();
+      }
+    }
+    const fitter = new OC.GeomAPI_PointsToBSplineSurface_2(pntArray, 3, 8, 0, 1e-3);
+    const surface = fitter.Surface();
+    const faceMaker = new OC.BRepBuilderAPI_MakeFace_8(surface, 1e-6);
+    let result2;
+    if (faceMaker.IsDone()) {
+      const shape2 = shapeTypes.castShape(faceMaker.Face());
+      if (shapeTypes.isFace(shape2)) {
+        result2 = errors.ok(shape2);
+      } else {
+        shape2[Symbol.dispose]();
+        result2 = errors.err(
+          errors.occtError(errors.BrepErrorCode.SURFACE_FAILED, "B-spline surface did not produce a face")
+        );
+      }
+    } else {
+      result2 = errors.err(
+        errors.occtError(
+          errors.BrepErrorCode.SURFACE_FAILED,
+          "BRepBuilderAPI_MakeFace failed for B-spline surface"
+        )
+      );
+    }
+    faceMaker.delete();
+    fitter.delete();
+    return result2;
+  } finally {
+    pntArray.delete();
+  }
+}
+function buildTriangulatedSurface(heights, rows, cols, dx, dy, scaleZ) {
+  const oc = occtBoundary.getKernel().oc;
+  function pt(r, c) {
+    const row = heights[r];
+    const z = (row ? row[c] ?? 0 : 0) * scaleZ;
+    return { x: c * dx, y: r * dy, z };
+  }
+  function buildTriFace2(a, b, c) {
+    const gpA = new oc.gp_Pnt_3(a.x, a.y, a.z);
+    const gpB = new oc.gp_Pnt_3(b.x, b.y, b.z);
+    const gpC = new oc.gp_Pnt_3(c.x, c.y, c.z);
+    const e1 = new oc.BRepBuilderAPI_MakeEdge_3(gpA, gpB);
+    const e2 = new oc.BRepBuilderAPI_MakeEdge_3(gpB, gpC);
+    const e3 = new oc.BRepBuilderAPI_MakeEdge_3(gpC, gpA);
+    const wireBuilder = new oc.BRepBuilderAPI_MakeWire_1();
+    wireBuilder.Add_1(e1.Edge());
+    wireBuilder.Add_1(e2.Edge());
+    wireBuilder.Add_1(e3.Edge());
+    let face2 = null;
+    if (wireBuilder.IsDone()) {
+      const makeFace = new oc.BRepBuilderAPI_MakeFace_15(wireBuilder.Wire(), false);
+      if (makeFace.IsDone()) {
+        face2 = makeFace.Face();
+      }
+      makeFace.delete();
+    }
+    wireBuilder.delete();
+    e1.delete();
+    e2.delete();
+    e3.delete();
+    gpA.delete();
+    gpB.delete();
+    gpC.delete();
+    return face2;
+  }
+  const sewing = new oc.BRepBuilderAPI_Sewing(1e-6, true, true, true, false);
+  let faceCount = 0;
+  try {
+    for (let r = 0; r < rows - 1; r++) {
+      for (let c = 0; c < cols - 1; c++) {
+        const p00 = pt(r, c);
+        const p10 = pt(r + 1, c);
+        const p11 = pt(r + 1, c + 1);
+        const p01 = pt(r, c + 1);
+        const f1 = buildTriFace2(p00, p10, p11);
+        if (f1 !== null) {
+          sewing.Add(f1);
+          faceCount++;
+        }
+        const f2 = buildTriFace2(p00, p11, p01);
+        if (f2 !== null) {
+          sewing.Add(f2);
+          faceCount++;
+        }
+      }
+    }
+    if (faceCount === 0) {
+      sewing.delete();
+      return errors.err(
+        errors.occtError(errors.BrepErrorCode.SURFACE_FAILED, "surfaceFromGrid: no valid triangular faces built")
+      );
+    }
+    const sewProgress = new oc.Message_ProgressRange_1();
+    sewing.Perform(sewProgress);
+    sewProgress.delete();
+    const sewn = sewing.SewedShape();
+    const shape2 = shapeTypes.castShape(sewn);
+    if (shapeTypes.isFace(shape2)) {
+      return errors.ok(shape2);
+    }
+    if (shapeTypes.isShell(shape2)) {
+      return errors.ok(shape2);
+    }
+    shape2[Symbol.dispose]();
+    return errors.err(
+      errors.occtError(errors.BrepErrorCode.SURFACE_FAILED, "surfaceFromGrid: unexpected shape type from sewing")
+    );
+  } finally {
+    sewing.delete();
+  }
+}
+async function surfaceFromImage(blob, options = {}) {
+  const channel = options.channel ?? "luminance";
+  const downsample = Math.max(1, Math.round(options.downsample ?? 1));
+  if (typeof createImageBitmap !== "function") {
+    return errors.err(
+      errors.ioError(
+        errors.BrepErrorCode.SURFACE_FAILED,
+        "surfaceFromImage requires createImageBitmap (not available in this environment)"
+      )
+    );
+  }
+  let bitmap;
+  try {
+    bitmap = await createImageBitmap(blob);
+  } catch (e) {
+    return errors.err(
+      errors.ioError(
+        errors.BrepErrorCode.SURFACE_FAILED,
+        `surfaceFromImage: failed to decode image — ${e instanceof Error ? e.message : String(e)}`
+      )
+    );
+  }
+  const w = bitmap.width;
+  const h = bitmap.height;
+  if (w < 2 || h < 2) {
+    bitmap.close();
+    return errors.err(
+      errors.validationError(
+        errors.BrepErrorCode.SURFACE_GRID_TOO_SMALL,
+        `surfaceFromImage: image too small (${w}x${h}), need at least 2x2`
+      )
+    );
+  }
+  if (typeof OffscreenCanvas !== "function") {
+    bitmap.close();
+    return errors.err(
+      errors.ioError(
+        errors.BrepErrorCode.SURFACE_FAILED,
+        "surfaceFromImage requires OffscreenCanvas (not available in this environment)"
+      )
+    );
+  }
+  const canvas = new OffscreenCanvas(w, h);
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    bitmap.close();
+    return errors.err(
+      errors.ioError(errors.BrepErrorCode.SURFACE_FAILED, "surfaceFromImage: could not get 2D canvas context")
+    );
+  }
+  ctx.drawImage(bitmap, 0, 0);
+  bitmap.close();
+  const imageData = ctx.getImageData(0, 0, w, h);
+  const data = imageData.data;
+  const rows = [];
+  for (let y = 0; y < h; y += downsample) {
+    const row = [];
+    for (let x = 0; x < w; x += downsample) {
+      const idx = (y * w + x) * 4;
+      const r = data[idx] ?? 0;
+      const g = data[idx + 1] ?? 0;
+      const b = data[idx + 2] ?? 0;
+      let value;
+      switch (channel) {
+        case "r":
+          value = r / 255;
+          break;
+        case "g":
+          value = g / 255;
+          break;
+        case "b":
+          value = b / 255;
+          break;
+        default:
+          value = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+          break;
+      }
+      row.push(value);
+    }
+    rows.push(row);
+  }
+  const gridOpts = {};
+  if (options.width !== void 0) gridOpts.width = options.width;
+  if (options.depth !== void 0) gridOpts.depth = options.depth;
+  if (options.scaleZ !== void 0) gridOpts.scaleZ = options.scaleZ;
+  return surfaceFromGrid(rows, gridOpts);
+}
 function validateNotNull$1(shape2, label) {
   if (shape2.wrapped.IsNull()) {
     return errors.err(errors.validationError(errors.BrepErrorCode.NULL_SHAPE_INPUT, `${label} is a null shape`));
@@ -172,13 +426,13 @@ function hull(shapes, options = {}) {
     const kernel = occtBoundary.getKernel();
     const ocShapes = shapes.map((s) => s.wrapped);
     const resultOc = kernel.hull(ocShapes, tolerance);
-    const cast2 = shapeTypes.castShape(resultOc);
-    if (!shapeTypes.isSolid(cast2)) {
+    const cast = shapeTypes.castShape(resultOc);
+    if (!shapeTypes.isSolid(cast)) {
       return errors.err(
         errors.occtError(errors.BrepErrorCode.HULL_NOT_3D, "Hull result is not a solid; input may be degenerate")
       );
     }
-    return errors.ok(cast2);
+    return errors.ok(cast);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
     if (raw.includes("coplanar") || raw.includes("fewer than") || raw.includes("degenerate")) {
@@ -309,6 +563,809 @@ function minkowski(shape2, tool, options = {}) {
   }
   return minkowskiGeneral(shape2, tool, tolerance);
 }
+function polyhedron(points, faces, options = {}) {
+  const { tolerance = 1e-6 } = options;
+  if (points.length < 4) {
+    return errors.err(
+      errors.validationError(
+        errors.BrepErrorCode.POLYHEDRON_INSUFFICIENT_POINTS,
+        `polyhedron: need at least 4 points, got ${points.length}`
+      )
+    );
+  }
+  if (faces.length < 4) {
+    return errors.err(
+      errors.validationError(
+        errors.BrepErrorCode.POLYHEDRON_INSUFFICIENT_FACES,
+        `polyhedron: need at least 4 faces, got ${faces.length}`
+      )
+    );
+  }
+  const triangles = [];
+  for (const [fi, face2] of faces.entries()) {
+    for (const idx of face2) {
+      if (idx < 0 || idx >= points.length) {
+        return errors.err(
+          errors.validationError(
+            errors.BrepErrorCode.POLYHEDRON_INVALID_INDEX,
+            `polyhedron: face ${fi} has out-of-range index ${idx} (${points.length} points)`
+          )
+        );
+      }
+    }
+    if (face2.length < 3) continue;
+    const v0 = face2[0];
+    for (let i = 1; i < face2.length - 1; i++) {
+      triangles.push([v0, face2[i], face2[i + 1]]);
+    }
+  }
+  try {
+    const kernel = occtBoundary.getKernel();
+    const ptObjs = points.map(([x, y, z]) => ({ x, y, z }));
+    const resultOc = kernel.buildSolidFromFaces(ptObjs, triangles, tolerance);
+    const cast = shapeTypes.castShape(resultOc);
+    if (!shapeTypes.isSolid(cast)) {
+      cast[Symbol.dispose]();
+      return errors.err(errors.occtError(errors.BrepErrorCode.POLYHEDRON_FAILED, "Polyhedron did not produce a solid"));
+    }
+    return errors.ok(cast);
+  } catch (e) {
+    const raw = e instanceof Error ? e.message : String(e);
+    return errors.err(errors.occtError(errors.BrepErrorCode.POLYHEDRON_FAILED, `Polyhedron failed: ${raw}`, e));
+  }
+}
+function multiSectionSweep(sections, spine, options) {
+  if (sections.length < 2) {
+    return errors.err(
+      errors.validationError(
+        errors.BrepErrorCode.MULTI_SWEEP_INSUFFICIENT_SECTIONS,
+        `Multi-section sweep requires at least 2 sections, got ${sections.length}`
+      )
+    );
+  }
+  const { solid: solid2 = true, ruled = false, tolerance = 1e-6 } = options ?? {};
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const r = shapeTypes.gcWithScope();
+    const adaptor = r(new oc.BRepAdaptor_CompCurve_2(spine.wrapped, false));
+    const uFirst = Number(adaptor.FirstParameter());
+    const uLast = Number(adaptor.LastParameter());
+    const uRange = uLast - uFirst;
+    const params = sections.map((s, i) => {
+      if (s.location !== void 0) {
+        return uFirst + s.location * uRange;
+      }
+      return uFirst + i / (sections.length - 1) * uRange;
+    });
+    const builder = r(new oc.BRepOffsetAPI_ThruSections(solid2, ruled, tolerance));
+    for (let i = 0; i < sections.length; i++) {
+      const param = params[i];
+      const section2 = sections[i];
+      if (param === void 0 || section2 === void 0) continue;
+      const pnt = r(new oc.gp_Pnt_1());
+      const tangent = r(new oc.gp_Vec_1());
+      adaptor.D1(param, pnt, tangent);
+      const tangentDir = r(new oc.gp_Dir_2(tangent));
+      const toAx3 = r(new oc.gp_Ax3_4(pnt, tangentDir));
+      const trsf = r(new oc.gp_Trsf_1());
+      trsf.SetTransformation_2(toAx3);
+      trsf.Invert();
+      const transformer = r(new oc.BRepBuilderAPI_Transform_2(section2.wire.wrapped, trsf, true));
+      const transformedShape = transformer.Shape();
+      const transformedWire = oc.TopoDS.Wire_1(transformedShape);
+      builder.AddWire(transformedWire);
+    }
+    const progress = r(new oc.Message_ProgressRange_1());
+    builder.Build(progress);
+    if (!builder.IsDone()) {
+      return errors.err(errors.occtError(errors.BrepErrorCode.MULTI_SWEEP_FAILED, "Multi-section sweep build failed"));
+    }
+    const result2 = shapeTypes.castShape(builder.Shape());
+    if (!shapeTypes.isShape3D(result2)) {
+      return errors.err(
+        errors.typeCastError("MULTI_SWEEP_NOT_3D", "Multi-section sweep did not produce a 3D shape")
+      );
+    }
+    return errors.ok(result2);
+  } catch (e) {
+    const raw = e instanceof Error ? e.message : String(e);
+    return errors.err(
+      errors.occtError(errors.BrepErrorCode.MULTI_SWEEP_FAILED, `Multi-section sweep failed: ${raw}`, e)
+    );
+  }
+}
+function guidedSweep(profile, spine, guides, options = {}) {
+  const { transition = "transformed", solid: solid2 = true, tolerance } = options;
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const r = shapeTypes.gcWithScope();
+    const builder = r(new oc.BRepOffsetAPI_MakePipeShell(spine.wrapped));
+    const modeMap = {
+      transformed: oc.BRepBuilderAPI_TransitionMode.BRepBuilderAPI_Transformed,
+      round: oc.BRepBuilderAPI_TransitionMode.BRepBuilderAPI_RoundCorner,
+      right: oc.BRepBuilderAPI_TransitionMode.BRepBuilderAPI_RightCorner
+    };
+    builder.SetTransitionMode(modeMap[transition]);
+    if (tolerance !== void 0) {
+      builder.SetTolerance(tolerance, tolerance, 1e-7);
+    }
+    if (guides.length > 0) {
+      const firstGuide = guides[0];
+      builder.SetMode_5(firstGuide.wrapped, false, oc.BRepFill_TypeOfContact.BRepFill_NoContact);
+    }
+    builder.Add_1(profile.wrapped, false, false);
+    const progress = r(new oc.Message_ProgressRange_1());
+    builder.Build(progress);
+    if (!builder.IsDone()) {
+      return errors.err(errors.occtError(errors.BrepErrorCode.GUIDED_SWEEP_FAILED, "Guided sweep build failed"));
+    }
+    if (solid2) {
+      builder.MakeSolid();
+    }
+    const result2 = shapeTypes.castShape(builder.Shape());
+    if (!shapeTypes.isShape3D(result2)) {
+      return errors.err(errors.typeCastError("GUIDED_SWEEP_NOT_3D", "Guided sweep did not produce a 3D shape"));
+    }
+    return errors.ok(result2);
+  } catch (e) {
+    const raw = e instanceof Error ? e.message : String(e);
+    return errors.err(errors.occtError(errors.BrepErrorCode.GUIDED_SWEEP_FAILED, `Guided sweep failed: ${raw}`, e));
+  }
+}
+const EPS = 1e-10;
+function cross2(ax, ay, bx, by) {
+  return ax * by - ay * bx;
+}
+function dot2(ax, ay, bx, by) {
+  return ax * bx + ay * by;
+}
+function len2(x, y) {
+  return Math.sqrt(x * x + y * y);
+}
+function polyAt(poly, i) {
+  const p = poly[(i % poly.length + poly.length) % poly.length];
+  if (!p) throw new Error(`Invalid polygon index ${i} for length ${poly.length}`);
+  return p;
+}
+function ensureCCW(poly) {
+  let area = 0;
+  for (let i = 0; i < poly.length; i++) {
+    const cur = polyAt(poly, i);
+    const nxt = polyAt(poly, i + 1);
+    area += cur.x * nxt.y - nxt.x * cur.y;
+  }
+  if (area < 0) return [...poly].reverse();
+  return poly;
+}
+function bisector(poly, i) {
+  const prev = polyAt(poly, i - 1);
+  const cur = polyAt(poly, i);
+  const next = polyAt(poly, i + 1);
+  const e1x = cur.x - prev.x;
+  const e1y = cur.y - prev.y;
+  const e1l = len2(e1x, e1y);
+  const e2x = next.x - cur.x;
+  const e2y = next.y - cur.y;
+  const e2l = len2(e2x, e2y);
+  if (e1l < EPS || e2l < EPS) return { dx: 0, dy: 0 };
+  const n1x = -e1y / e1l;
+  const n1y = e1x / e1l;
+  const n2x = -e2y / e2l;
+  const n2y = e2x / e2l;
+  let bx = n1x + n2x;
+  let by = n1y + n2y;
+  const bl = len2(bx, by);
+  if (bl < EPS) {
+    return { dx: n1x, dy: n1y };
+  }
+  bx /= bl;
+  by /= bl;
+  const cosHalf = dot2(bx, by, n1x, n1y);
+  const speed = Math.abs(cosHalf) > EPS ? 1 / cosHalf : 1;
+  return { dx: bx * speed, dy: by * speed };
+}
+function isLavNodeReflex(node) {
+  const prev = node.prev;
+  const next = node.next;
+  return cross2(node.x - prev.x, node.y - prev.y, next.x - node.x, next.y - node.y) < -EPS;
+}
+function createLav(poly) {
+  const nodes = poly.map((p, i) => {
+    const b = bisector(poly, i);
+    return {
+      x: p.x,
+      y: p.y,
+      bx: b.dx,
+      by: b.dy,
+      origIdx: i,
+      prev: null,
+      next: null,
+      active: true
+    };
+  });
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const prevNode = nodes[(i - 1 + nodes.length) % nodes.length];
+    const nextNode = nodes[(i + 1) % nodes.length];
+    if (node && prevNode && nextNode) {
+      node.prev = prevNode;
+      node.next = nextNode;
+    }
+  }
+  return nodes;
+}
+function lavSize(start) {
+  let count = 1;
+  let cur = start.next;
+  while (cur !== start) {
+    count++;
+    cur = cur.next;
+    if (count > 1e4) break;
+  }
+  return count;
+}
+function bisectorIntersectTime(a, b) {
+  const ddx = a.bx - b.bx;
+  const ddy = a.by - b.by;
+  const dxp = b.x - a.x;
+  const dyp = b.y - a.y;
+  if (Math.abs(ddx) < EPS && Math.abs(ddy) < EPS) return null;
+  let t;
+  if (Math.abs(ddx) > Math.abs(ddy)) {
+    t = dxp / ddx;
+  } else {
+    t = dyp / ddy;
+  }
+  if (t < EPS) return null;
+  const otherDd = Math.abs(ddx) > Math.abs(ddy) ? ddy : ddx;
+  const otherDp = Math.abs(ddx) > Math.abs(ddy) ? dyp : dxp;
+  if (Math.abs(otherDd) > EPS) {
+    const t2 = otherDp / otherDd;
+    if (Math.abs(t - t2) > 1e-4 * Math.max(1, Math.abs(t))) return null;
+  }
+  return t;
+}
+function raySplitTime(node, eA, eB) {
+  const edx = eB.x - eA.x;
+  const edy = eB.y - eA.y;
+  const el = len2(edx, edy);
+  if (el < EPS) return null;
+  const enx = -edy / el;
+  const eny = edx / el;
+  const d0 = (node.x - eA.x) * enx + (node.y - eA.y) * eny;
+  const relBx = node.bx - (eA.bx + eB.bx) / 2;
+  const relBy = node.by - (eA.by + eB.by) / 2;
+  const dRate = relBx * enx + relBy * eny;
+  if (Math.abs(dRate) < EPS) return null;
+  const t = -d0 / dRate;
+  if (t < EPS) return null;
+  const px = node.x + t * node.bx;
+  const py = node.y + t * node.by;
+  const ax = eA.x + t * eA.bx;
+  const ay = eA.y + t * eA.by;
+  const bxx = eB.x + t * eB.bx;
+  const byy = eB.y + t * eB.by;
+  const segDx = bxx - ax;
+  const segDy = byy - ay;
+  const segL = len2(segDx, segDy);
+  if (segL < EPS) return t;
+  const s = dot2(px - ax, py - ay, segDx, segDy) / (segL * segL);
+  if (s < -0.01 || s > 1.01) return null;
+  return t;
+}
+function computeEvents(lavNodes) {
+  const events = [];
+  for (const node of lavNodes) {
+    if (!node.active) continue;
+    const t = bisectorIntersectTime(node, node.next);
+    if (t !== null && t > EPS) {
+      const x = node.x + t * node.bx;
+      const y = node.y + t * node.by;
+      events.push({ time: t, x, y, nodeA: node, nodeB: node.next, type: "edge" });
+    }
+    if (isLavNodeReflex(node)) {
+      let cur = node.next.next;
+      let count = 0;
+      while (cur !== node.prev && cur !== node && count < 1e3) {
+        const st = raySplitTime(node, cur, cur.next);
+        if (st !== null && st > EPS) {
+          const x = node.x + st * node.bx;
+          const y = node.y + st * node.by;
+          events.push({ time: st, x, y, nodeA: node, nodeB: cur, type: "split" });
+        }
+        cur = cur.next;
+        count++;
+      }
+    }
+  }
+  events.sort((a, b) => a.time - b.time);
+  return events;
+}
+function computeStraightSkeleton(polygon2) {
+  if (polygon2.length < 3) {
+    return { nodes: [], faces: [] };
+  }
+  const poly = ensureCCW(polygon2);
+  const n = poly.length;
+  const skeletonNodes = [];
+  const vertexToSkelNodes = Array.from({ length: n }, () => []);
+  const lavNodes = createLav(poly);
+  let iterations = 0;
+  const maxIter = n * n * 2;
+  while (iterations < maxIter) {
+    iterations++;
+    const activeStart = lavNodes.find((nd) => nd.active);
+    if (!activeStart) break;
+    const sz = lavSize(activeStart);
+    if (sz <= 3) {
+      if (sz === 3) {
+        const a = activeStart;
+        const b = a.next;
+        const c = b.next;
+        const t = bisectorIntersectTime(a, b);
+        const time = t !== null && t > EPS ? t : 0;
+        const mx = (a.x + b.x + c.x) / 3 + time * (a.bx + b.bx + c.bx) / 3;
+        const my = (a.y + b.y + c.y) / 3 + time * (a.by + b.by + c.by) / 3;
+        const nodeIdx = skeletonNodes.length;
+        skeletonNodes.push({ x: mx, y: my, height: time });
+        const aNodes = vertexToSkelNodes[a.origIdx];
+        const bNodes = vertexToSkelNodes[b.origIdx];
+        const cNodes = vertexToSkelNodes[c.origIdx];
+        if (aNodes) aNodes.push(nodeIdx);
+        if (bNodes) bNodes.push(nodeIdx);
+        if (cNodes) cNodes.push(nodeIdx);
+        a.active = false;
+        b.active = false;
+        c.active = false;
+      } else {
+        let cur = activeStart;
+        for (let i = 0; i < sz; i++) {
+          cur.active = false;
+          cur = cur.next;
+        }
+      }
+      continue;
+    }
+    const activeNodes = lavNodes.filter((nd) => nd.active);
+    const events = computeEvents(activeNodes);
+    if (events.length === 0) {
+      for (const nd of activeNodes) {
+        nd.active = false;
+      }
+      break;
+    }
+    const ev = events[0];
+    if (!ev) break;
+    if (ev.type === "edge") {
+      const a = ev.nodeA;
+      const b = ev.nodeB;
+      if (!a.active || !b.active) continue;
+      const nodeIdx = skeletonNodes.length;
+      skeletonNodes.push({ x: ev.x, y: ev.y, height: ev.time });
+      const aNodes = vertexToSkelNodes[a.origIdx];
+      const bNodes = vertexToSkelNodes[b.origIdx];
+      if (aNodes) aNodes.push(nodeIdx);
+      if (bNodes) bNodes.push(nodeIdx);
+      a.x = ev.x;
+      a.y = ev.y;
+      a.next = b.next;
+      b.next.prev = a;
+      b.active = false;
+      const lavPoly = [];
+      let cur = a;
+      do {
+        lavPoly.push({ x: cur.x, y: cur.y });
+        cur = cur.next;
+      } while (cur !== a);
+      const bDir = bisector(lavPoly, 0);
+      a.bx = bDir.dx;
+      a.by = bDir.dy;
+    } else {
+      const a = ev.nodeA;
+      const b = ev.nodeB;
+      if (!a.active || !b.active) continue;
+      const nodeIdx = skeletonNodes.length;
+      skeletonNodes.push({ x: ev.x, y: ev.y, height: ev.time });
+      const aNodes = vertexToSkelNodes[a.origIdx];
+      if (aNodes) aNodes.push(nodeIdx);
+      const bNodes = vertexToSkelNodes[b.origIdx];
+      if (bNodes) bNodes.push(nodeIdx);
+      const aCopy = {
+        x: ev.x,
+        y: ev.y,
+        bx: 0,
+        by: 0,
+        origIdx: a.origIdx,
+        prev: null,
+        next: null,
+        active: true
+      };
+      lavNodes.push(aCopy);
+      a.x = ev.x;
+      a.y = ev.y;
+      const aNext = a.next;
+      const bNext = b.next;
+      a.next = bNext;
+      bNext.prev = a;
+      aCopy.next = aNext;
+      aNext.prev = aCopy;
+      aCopy.prev = b;
+      b.next = aCopy;
+      const buildLavPoly = (start) => {
+        const poly2 = [];
+        let c = start;
+        do {
+          poly2.push({ x: c.x, y: c.y });
+          c = c.next;
+        } while (c !== start);
+        return poly2;
+      };
+      const lav1Poly = buildLavPoly(a);
+      const bDir1 = bisector(lav1Poly, 0);
+      a.bx = bDir1.dx;
+      a.by = bDir1.dy;
+      const lav2Poly = buildLavPoly(aCopy);
+      const bDir2 = bisector(lav2Poly, 0);
+      aCopy.bx = bDir2.dx;
+      aCopy.by = bDir2.dy;
+    }
+  }
+  const faces = [];
+  for (let i = 0; i < n; i++) {
+    const j = (i + 1) % n;
+    const pi = polyAt(poly, i);
+    const pj = polyAt(poly, j);
+    const faceVerts = [pi, pj];
+    const faceHeights = [0, 0];
+    const jNodes = vertexToSkelNodes[j];
+    const iNodes = vertexToSkelNodes[i];
+    if (jNodes) {
+      for (const ni of jNodes) {
+        const sn = skeletonNodes[ni];
+        if (sn) {
+          faceVerts.push({ x: sn.x, y: sn.y });
+          faceHeights.push(sn.height);
+        }
+      }
+    }
+    if (iNodes) {
+      for (let k = iNodes.length - 1; k >= 0; k--) {
+        const idx = iNodes[k];
+        if (idx === void 0) continue;
+        const sn = skeletonNodes[idx];
+        if (!sn) continue;
+        const lastVert = faceVerts[faceVerts.length - 1];
+        if (!lastVert) continue;
+        const dist = len2(sn.x - lastVert.x, sn.y - lastVert.y);
+        if (dist > EPS) {
+          faceVerts.push({ x: sn.x, y: sn.y });
+          faceHeights.push(sn.height);
+        }
+      }
+    }
+    if (faceVerts.length >= 3) {
+      faces.push({ vertices: faceVerts, heights: faceHeights });
+    }
+  }
+  const uniqueNodes = [];
+  for (const sn of skeletonNodes) {
+    const exists = uniqueNodes.some(
+      (un) => Math.abs(un.x - sn.x) < 0.01 && Math.abs(un.y - sn.y) < 0.01
+    );
+    if (!exists) {
+      uniqueNodes.push(sn);
+    }
+  }
+  return { nodes: uniqueNodes, faces };
+}
+function extractPolygon(w) {
+  const edges = shapeFns.getEdges(w);
+  const pts = edges.map((e) => {
+    const pt = curveFns.curveStartPoint(e);
+    return { x: pt[0], y: pt[1] };
+  });
+  const first = pts[0];
+  const last = pts[pts.length - 1];
+  if (pts.length > 1 && first && last && Math.abs(first.x - last.x) < 1e-10 && Math.abs(first.y - last.y) < 1e-10) {
+    pts.pop();
+  }
+  return pts;
+}
+function fanTriangulate(count) {
+  const tris = [];
+  for (let i = 1; i < count - 1; i++) {
+    tris.push([0, i, i + 1]);
+  }
+  return tris;
+}
+function buildTriFace$2(oc, a, b, c) {
+  const gpA = new oc.gp_Pnt_3(a[0], a[1], a[2]);
+  const gpB = new oc.gp_Pnt_3(b[0], b[1], b[2]);
+  const gpC = new oc.gp_Pnt_3(c[0], c[1], c[2]);
+  const e1 = new oc.BRepBuilderAPI_MakeEdge_3(gpA, gpB);
+  const e2 = new oc.BRepBuilderAPI_MakeEdge_3(gpB, gpC);
+  const e3 = new oc.BRepBuilderAPI_MakeEdge_3(gpC, gpA);
+  const wireBuilder = new oc.BRepBuilderAPI_MakeWire_1();
+  wireBuilder.Add_1(e1.Edge());
+  wireBuilder.Add_1(e2.Edge());
+  wireBuilder.Add_1(e3.Edge());
+  let face2 = null;
+  if (wireBuilder.IsDone()) {
+    const makeFace = new oc.BRepBuilderAPI_MakeFace_15(wireBuilder.Wire(), false);
+    if (makeFace.IsDone()) {
+      face2 = makeFace.Face();
+    }
+    makeFace.delete();
+  }
+  wireBuilder.delete();
+  e1.delete();
+  e2.delete();
+  e3.delete();
+  gpA.delete();
+  gpB.delete();
+  gpC.delete();
+  return face2;
+}
+function roof(w, options) {
+  const angle = (options?.angle ?? 45) * (Math.PI / 180);
+  const tanAngle = Math.tan(angle);
+  try {
+    const polygon2 = extractPolygon(w);
+    if (polygon2.length < 3) {
+      return errors.err(
+        errors.occtError(errors.BrepErrorCode.ROOF_FAILED, "Wire must have at least 3 edges for roof generation")
+      );
+    }
+    const skeleton = computeStraightSkeleton(polygon2);
+    if (skeleton.faces.length === 0) {
+      return errors.err(
+        errors.occtError(errors.BrepErrorCode.ROOF_FAILED, "Straight skeleton computation produced no faces")
+      );
+    }
+    const oc = occtBoundary.getKernel().oc;
+    const sewing = new oc.BRepBuilderAPI_Sewing(1e-6, true, true, true, false);
+    let faceCount = 0;
+    try {
+      for (const skFace of skeleton.faces) {
+        const verts3d = skFace.vertices.map(
+          (v, i) => [
+            v.x,
+            v.y,
+            (skFace.heights[i] ?? 0) * tanAngle
+          ]
+        );
+        const tris = fanTriangulate(verts3d.length);
+        for (const [ai, bi, ci] of tris) {
+          const va = verts3d[ai];
+          const vb = verts3d[bi];
+          const vc = verts3d[ci];
+          if (!va || !vb || !vc) continue;
+          const abx = vb[0] - va[0];
+          const aby = vb[1] - va[1];
+          const abz = vb[2] - va[2];
+          const acx = vc[0] - va[0];
+          const acy = vc[1] - va[1];
+          const acz = vc[2] - va[2];
+          const nx = aby * acz - abz * acy;
+          const ny = abz * acx - abx * acz;
+          const nz = abx * acy - aby * acx;
+          const areaSq = nx * nx + ny * ny + nz * nz;
+          if (areaSq < 1e-20) continue;
+          const triFace = buildTriFace$2(oc, va, vb, vc);
+          if (triFace !== null) {
+            sewing.Add(triFace);
+            faceCount++;
+          }
+        }
+      }
+      const p0 = polygon2[0];
+      if (p0) {
+        for (let i = 1; i < polygon2.length - 1; i++) {
+          const pi = polygon2[i];
+          const pi1 = polygon2[i + 1];
+          if (!pi || !pi1) continue;
+          const va = [p0.x, p0.y, 0];
+          const vb = [pi.x, pi.y, 0];
+          const vc = [pi1.x, pi1.y, 0];
+          const triFace = buildTriFace$2(oc, va, vc, vb);
+          if (triFace !== null) {
+            sewing.Add(triFace);
+            faceCount++;
+          }
+        }
+      }
+      if (faceCount === 0) {
+        return errors.err(
+          errors.occtError(errors.BrepErrorCode.ROOF_FAILED, "No valid triangular faces could be built")
+        );
+      }
+      const progress = new oc.Message_ProgressRange_1();
+      sewing.Perform(progress);
+      progress.delete();
+      const sewn = sewing.SewedShape();
+      const fixer = new oc.ShapeFix_Solid_1();
+      try {
+        const shell2 = oc.TopoDS.Shell_1(sewn);
+        const solid2 = fixer.SolidFromShell(shell2);
+        const shapeFixer = new oc.ShapeFix_Shape_1(solid2);
+        const shapeFixProgress = new oc.Message_ProgressRange_1();
+        try {
+          shapeFixer.Perform(shapeFixProgress);
+          const fixed = shapeFixer.Shape();
+          return errors.ok(shapeTypes.createSolid(fixed));
+        } finally {
+          shapeFixProgress.delete();
+          shapeFixer.delete();
+        }
+      } catch {
+        return errors.ok(shapeTypes.castShape(sewn));
+      } finally {
+        fixer.delete();
+      }
+    } finally {
+      sewing.delete();
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return errors.err(errors.occtError(errors.BrepErrorCode.ROOF_FAILED, `Roof generation failed: ${msg}`, e));
+  }
+}
+function solveConstraints(nodes, constraints) {
+  const transforms = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    transforms.set(node, {
+      position: [0, 0, 0],
+      rotation: [1, 0, 0, 0]
+    });
+  }
+  for (const c of constraints) {
+    if (c.type === "coincident" && c.entityA && c.entityB) {
+      const a = c.entityA;
+      const b = c.entityB;
+      if (a.entity.type === "plane" && b.entity.type === "plane") {
+        const aNormal = a.entity.normal ?? [0, 0, 1];
+        const aOrigin = a.entity.origin;
+        const bOrigin = b.entity.origin;
+        const dot = aNormal[0] * (aOrigin[0] - bOrigin[0]) + aNormal[1] * (aOrigin[1] - bOrigin[1]) + aNormal[2] * (aOrigin[2] - bOrigin[2]);
+        const pos = [dot * aNormal[0], dot * aNormal[1], dot * aNormal[2]];
+        transforms.set(b.node, { position: pos, rotation: [1, 0, 0, 0] });
+      }
+    }
+    if (c.type === "distance" && c.entityA && c.entityB && c.value !== void 0) {
+      const a = c.entityA;
+      const b = c.entityB;
+      if (a.entity.type === "plane" && b.entity.type === "plane") {
+        const aNormal = a.entity.normal ?? [0, 0, 1];
+        const aOrigin = a.entity.origin;
+        const bOrigin = b.entity.origin;
+        const currentDist = aNormal[0] * (aOrigin[0] - bOrigin[0]) + aNormal[1] * (aOrigin[1] - bOrigin[1]) + aNormal[2] * (aOrigin[2] - bOrigin[2]);
+        const offset2 = currentDist + c.value;
+        const pos = [offset2 * aNormal[0], offset2 * aNormal[1], offset2 * aNormal[2]];
+        transforms.set(b.node, { position: pos, rotation: [1, 0, 0, 0] });
+      }
+    }
+  }
+  return { transforms, dof: 0, converged: true };
+}
+function extractEntity(mate) {
+  if (mate.face) {
+    const origin = faceFns.faceCenter(mate.face);
+    const normal = faceFns.normalAt(mate.face);
+    return { type: "plane", origin, normal };
+  }
+  if (mate.point) {
+    return { type: "point", origin: mate.point };
+  }
+  return null;
+}
+function addMate(assembly, constraint) {
+  const existing = assembly.mates ?? [];
+  return { ...assembly, mates: [...existing, constraint] };
+}
+function solveAssembly(assembly) {
+  const mates = assembly.mates;
+  if (!mates || mates.length === 0) {
+    return errors.err(
+      errors.validationError(errors.BrepErrorCode.ASSEMBLY_MATE_INVALID, "solveAssembly: no mates defined")
+    );
+  }
+  try {
+    const nodes = [];
+    operations.walkAssembly(assembly, (node) => {
+      nodes.push(node.name);
+    });
+    const solverConstraints = [];
+    for (const mate of mates) {
+      if (mate.type === "fixed") {
+        solverConstraints.push({
+          type: "fixed",
+          entityA: { node: mate.entity.node, entity: { type: "point", origin: [0, 0, 0] } }
+        });
+        continue;
+      }
+      if (mate.type === "coincident") {
+        const entA = extractEntity(mate.entityA);
+        const entB = extractEntity(mate.entityB);
+        if (!entA || !entB) {
+          return errors.err(
+            errors.validationError(
+              errors.BrepErrorCode.ASSEMBLY_MATE_INVALID,
+              "solveAssembly: could not extract geometry from mate entities"
+            )
+          );
+        }
+        solverConstraints.push({
+          type: "coincident",
+          entityA: { node: mate.entityA.node, entity: entA },
+          entityB: { node: mate.entityB.node, entity: entB }
+        });
+      }
+      if (mate.type === "distance") {
+        const entA = extractEntity(mate.entityA);
+        const entB = extractEntity(mate.entityB);
+        if (!entA || !entB) {
+          return errors.err(
+            errors.validationError(
+              errors.BrepErrorCode.ASSEMBLY_MATE_INVALID,
+              "solveAssembly: could not extract geometry from mate entities"
+            )
+          );
+        }
+        solverConstraints.push({
+          type: "distance",
+          entityA: { node: mate.entityA.node, entity: entA },
+          entityB: { node: mate.entityB.node, entity: entB },
+          value: mate.distance
+        });
+      }
+      if (mate.type === "angle") {
+        const entA = extractEntity(mate.entityA);
+        const entB = extractEntity(mate.entityB);
+        if (!entA || !entB) {
+          return errors.err(
+            errors.validationError(
+              errors.BrepErrorCode.ASSEMBLY_MATE_INVALID,
+              "solveAssembly: could not extract geometry from mate entities"
+            )
+          );
+        }
+        solverConstraints.push({
+          type: "angle",
+          entityA: { node: mate.entityA.node, entity: entA },
+          entityB: { node: mate.entityB.node, entity: entB },
+          value: mate.angle
+        });
+      }
+      if (mate.type === "concentric") {
+        const entA = extractEntity(mate.axisA);
+        const entB = extractEntity(mate.axisB);
+        if (!entA || !entB) {
+          return errors.err(
+            errors.validationError(
+              errors.BrepErrorCode.ASSEMBLY_MATE_INVALID,
+              "solveAssembly: could not extract geometry from mate entities"
+            )
+          );
+        }
+        solverConstraints.push({
+          type: "concentric",
+          entityA: { node: mate.axisA.node, entity: entA },
+          entityB: { node: mate.axisB.node, entity: entB }
+        });
+      }
+    }
+    const result2 = solveConstraints(nodes, solverConstraints);
+    if (!result2.converged) ;
+    return errors.ok({
+      transforms: result2.transforms,
+      dof: result2.dof,
+      converged: result2.converged
+    });
+  } catch (e) {
+    const raw = e instanceof Error ? e.message : String(e);
+    return errors.err(errors.occtError(errors.BrepErrorCode.ASSEMBLY_SOLVE_FAILED, `Assembly solve failed: ${raw}`, e));
+  }
+}
 function checkInterference(shape1, shape2, tolerance = 1e-6) {
   if (shape1.wrapped.IsNull()) {
     return errors.err(
@@ -346,6 +1403,458 @@ function checkAllInterferences(shapes, tolerance = 1e-6) {
   });
   return pairs;
 }
+function parseEntities(text) {
+  const lines = text.split(/\r?\n/);
+  const entities = [];
+  let inEntities = false;
+  let current;
+  for (let i = 0; i < lines.length - 1; i += 2) {
+    const codeLine = lines[i];
+    const valueLine = lines[i + 1];
+    if (codeLine === void 0 || valueLine === void 0) continue;
+    const code = parseInt(codeLine.trim(), 10);
+    const value = valueLine.trim();
+    if (isNaN(code)) continue;
+    if (code === 2 && value === "ENTITIES") {
+      inEntities = true;
+      continue;
+    }
+    if (!inEntities) continue;
+    if (code === 0) {
+      if (value === "ENDSEC" || value === "EOF") {
+        if (current) entities.push(current);
+        break;
+      }
+      if (current) entities.push(current);
+      current = { type: value, layer: "0", data: /* @__PURE__ */ new Map() };
+      continue;
+    }
+    if (current) {
+      if (code === 8) {
+        current.layer = value;
+      } else {
+        current.data.set(code, value);
+      }
+    }
+  }
+  return entities;
+}
+function getNum(data, code, fallback = 0) {
+  const v = data.get(code);
+  if (v === void 0) return fallback;
+  const n = parseFloat(v);
+  return isNaN(n) ? fallback : n;
+}
+function entityToEdge(entity, oc) {
+  const { type, data } = entity;
+  if (type === "LINE") {
+    const p1 = new oc.gp_Pnt_3(getNum(data, 10), getNum(data, 20), getNum(data, 30));
+    const p2 = new oc.gp_Pnt_3(getNum(data, 11), getNum(data, 21), getNum(data, 31));
+    try {
+      const builder = new oc.BRepBuilderAPI_MakeEdge_3(p1, p2);
+      const edge = builder.Edge();
+      builder.delete();
+      return edge;
+    } finally {
+      p1.delete();
+      p2.delete();
+    }
+  }
+  if (type === "CIRCLE") {
+    const cx = getNum(data, 10);
+    const cy = getNum(data, 20);
+    const cz = getNum(data, 30);
+    const radius = getNum(data, 40);
+    const center = new oc.gp_Pnt_3(cx, cy, cz);
+    const dir = new oc.gp_Dir_4(0, 0, 1);
+    const ax2 = new oc.gp_Ax2_3(center, dir);
+    const circ = new oc.gp_Circ_2(ax2, radius);
+    try {
+      const builder = new oc.BRepBuilderAPI_MakeEdge_8(circ);
+      const edge = builder.Edge();
+      builder.delete();
+      return edge;
+    } finally {
+      center.delete();
+      dir.delete();
+      ax2.delete();
+      circ.delete();
+    }
+  }
+  if (type === "ARC") {
+    const cx = getNum(data, 10);
+    const cy = getNum(data, 20);
+    const cz = getNum(data, 30);
+    const radius = getNum(data, 40);
+    const startAngleDeg = getNum(data, 50);
+    const endAngleDeg = getNum(data, 51);
+    const startAngle = startAngleDeg * Math.PI / 180;
+    const endAngle = endAngleDeg * Math.PI / 180;
+    const center = new oc.gp_Pnt_3(cx, cy, cz);
+    const dir = new oc.gp_Dir_4(0, 0, 1);
+    const ax2 = new oc.gp_Ax2_3(center, dir);
+    const circ = new oc.gp_Circ_2(ax2, radius);
+    try {
+      const builder = new oc.BRepBuilderAPI_MakeEdge_9(circ, startAngle, endAngle);
+      const edge = builder.Edge();
+      builder.delete();
+      return edge;
+    } finally {
+      center.delete();
+      dir.delete();
+      ax2.delete();
+      circ.delete();
+    }
+  }
+  return void 0;
+}
+async function importDXF(blob, options) {
+  const oc = occtBoundary.getKernel().oc;
+  let text;
+  try {
+    text = await blob.text();
+  } catch (cause) {
+    return errors.err(errors.ioError(errors.BrepErrorCode.DXF_IMPORT_FAILED, "Failed to read DXF blob", cause));
+  }
+  const allEntities = parseEntities(text);
+  const entities = options?.layer !== void 0 ? allEntities.filter((e) => e.layer === options.layer) : allEntities;
+  if (entities.length === 0) {
+    return errors.ok([]);
+  }
+  const edges = [];
+  try {
+    for (const entity of entities) {
+      const edge = entityToEdge(entity, oc);
+      if (edge !== void 0) {
+        edges.push(edge);
+      }
+    }
+    if (edges.length === 0) {
+      return errors.ok([]);
+    }
+    const wireBuilder = new oc.BRepBuilderAPI_MakeWire_1();
+    try {
+      for (const edge of edges) {
+        wireBuilder.Add_1(edge);
+      }
+      if (wireBuilder.IsDone()) {
+        const wire2 = wireBuilder.Wire();
+        return errors.ok([shapeTypes.createWire(wire2)]);
+      }
+      return errors.err(
+        errors.ioError(errors.BrepErrorCode.DXF_IMPORT_FAILED, "Failed to assemble DXF edges into a wire")
+      );
+    } finally {
+      wireBuilder.delete();
+    }
+  } catch (cause) {
+    return errors.err(
+      errors.ioError(errors.BrepErrorCode.DXF_IMPORT_FAILED, "Failed to convert DXF entities to geometry", cause)
+    );
+  } finally {
+    for (const edge of edges) {
+      edge.delete();
+    }
+  }
+}
+async function importOBJ(blob) {
+  const text = await blob.text();
+  const lines = text.split("\n");
+  const vertices = [];
+  const faces = [];
+  for (const raw of lines) {
+    const line2 = raw.trim();
+    if (line2.startsWith("v ")) {
+      const parts = line2.split(/\s+/);
+      const x = parseFloat(parts[1] ?? "");
+      const y = parseFloat(parts[2] ?? "");
+      const z = parseFloat(parts[3] ?? "");
+      if (isNaN(x) || isNaN(y) || isNaN(z)) continue;
+      vertices.push([x, y, z]);
+    } else if (line2.startsWith("f ")) {
+      const parts = line2.split(/\s+/).slice(1);
+      const indices = [];
+      for (const p of parts) {
+        const idx = parseInt(p.split("/")[0] ?? "", 10);
+        if (!isNaN(idx)) indices.push(idx);
+      }
+      if (indices.length >= 3) faces.push(indices);
+    }
+  }
+  if (vertices.length === 0 || faces.length === 0) {
+    return errors.err(errors.ioError(errors.BrepErrorCode.OBJ_IMPORT_FAILED, "OBJ file contains no valid geometry"));
+  }
+  try {
+    return buildSolidFromMesh$1(vertices, faces);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return errors.err(errors.ioError(errors.BrepErrorCode.OBJ_IMPORT_FAILED, `OBJ import failed: ${msg}`, e));
+  }
+}
+function buildSolidFromMesh$1(vertices, faces) {
+  const oc = occtBoundary.getKernel().oc;
+  const sewing = new oc.BRepBuilderAPI_Sewing(1e-6, true, true, true, false);
+  let faceCount = 0;
+  try {
+    for (const face2 of faces) {
+      for (let i = 1; i < face2.length - 1; i++) {
+        const rawA = face2[0] ?? 0;
+        const rawB = face2[i] ?? 0;
+        const rawC = face2[i + 1] ?? 0;
+        const ai = rawA > 0 ? rawA - 1 : vertices.length + rawA;
+        const bi = rawB > 0 ? rawB - 1 : vertices.length + rawB;
+        const ci = rawC > 0 ? rawC - 1 : vertices.length + rawC;
+        const va = vertices[ai];
+        const vb = vertices[bi];
+        const vc = vertices[ci];
+        if (!va || !vb || !vc) continue;
+        const triFace = buildTriFace$1(oc, va, vb, vc);
+        if (triFace !== null) {
+          sewing.Add(triFace);
+          faceCount++;
+        }
+      }
+    }
+    if (faceCount === 0) {
+      return errors.err(
+        errors.ioError(errors.BrepErrorCode.OBJ_IMPORT_FAILED, "No valid triangular faces could be built")
+      );
+    }
+    const progress = new oc.Message_ProgressRange_1();
+    sewing.Perform(progress);
+    progress.delete();
+    const sewn = sewing.SewedShape();
+    const fixer = new oc.ShapeFix_Solid_1();
+    try {
+      const shell2 = oc.TopoDS.Shell_1(sewn);
+      const solid2 = fixer.SolidFromShell(shell2);
+      return errors.ok(shapeTypes.castShape(solid2));
+    } catch {
+      return errors.ok(shapeTypes.castShape(sewn));
+    } finally {
+      fixer.delete();
+    }
+  } finally {
+    sewing.delete();
+  }
+}
+function buildTriFace$1(oc, a, b, c) {
+  const gpA = new oc.gp_Pnt_3(a[0], a[1], a[2]);
+  const gpB = new oc.gp_Pnt_3(b[0], b[1], b[2]);
+  const gpC = new oc.gp_Pnt_3(c[0], c[1], c[2]);
+  const e1 = new oc.BRepBuilderAPI_MakeEdge_3(gpA, gpB);
+  const e2 = new oc.BRepBuilderAPI_MakeEdge_3(gpB, gpC);
+  const e3 = new oc.BRepBuilderAPI_MakeEdge_3(gpC, gpA);
+  const wireBuilder = new oc.BRepBuilderAPI_MakeWire_1();
+  wireBuilder.Add_1(e1.Edge());
+  wireBuilder.Add_1(e2.Edge());
+  wireBuilder.Add_1(e3.Edge());
+  let face2 = null;
+  if (wireBuilder.IsDone()) {
+    const makeFace = new oc.BRepBuilderAPI_MakeFace_15(wireBuilder.Wire(), false);
+    if (makeFace.IsDone()) {
+      face2 = makeFace.Face();
+    }
+    makeFace.delete();
+  }
+  wireBuilder.delete();
+  e1.delete();
+  e2.delete();
+  e3.delete();
+  gpA.delete();
+  gpB.delete();
+  gpC.delete();
+  return face2;
+}
+function extractFromZip(data, target) {
+  let eocdOffset = -1;
+  for (let i = data.length - 22; i >= 0; i--) {
+    if (data[i] === 80 && data[i + 1] === 75 && data[i + 2] === 5 && data[i + 3] === 6) {
+      eocdOffset = i;
+      break;
+    }
+  }
+  if (eocdOffset < 0) return null;
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const cdOffset = view.getUint32(eocdOffset + 16, true);
+  const cdSize = view.getUint32(eocdOffset + 12, true);
+  const cdEnd = cdOffset + cdSize;
+  let pos = cdOffset;
+  const decoder = new TextDecoder();
+  while (pos < cdEnd) {
+    const sig = view.getUint32(pos, true);
+    if (sig !== 33639248) break;
+    const nameLen = view.getUint16(pos + 28, true);
+    const extraLen = view.getUint16(pos + 30, true);
+    const commentLen = view.getUint16(pos + 32, true);
+    const localOffset = view.getUint32(pos + 42, true);
+    const name = decoder.decode(data.subarray(pos + 46, pos + 46 + nameLen));
+    if (name === target) {
+      const compressionMethod = view.getUint16(localOffset + 8, true);
+      if (compressionMethod !== 0) {
+        return null;
+      }
+      const localNameLen = view.getUint16(localOffset + 26, true);
+      const localExtraLen = view.getUint16(localOffset + 28, true);
+      const compressedSize = view.getUint32(localOffset + 18, true);
+      const dataStart = localOffset + 30 + localNameLen + localExtraLen;
+      return data.subarray(dataStart, dataStart + compressedSize);
+    }
+    pos += 46 + nameLen + extraLen + commentLen;
+  }
+  return null;
+}
+function isAttrChar(code) {
+  return code >= 97 && code <= 122 || // a-z
+  code >= 65 && code <= 90 || // A-Z
+  code >= 48 && code <= 57 || // 0-9
+  code === 95;
+}
+function parseTagAttrs(tag) {
+  const attrs = {};
+  let pos = 0;
+  while (pos < tag.length) {
+    const eq = tag.indexOf('="', pos);
+    if (eq < 0) break;
+    let nameStart = eq;
+    while (nameStart > 0 && isAttrChar(tag.charCodeAt(nameStart - 1))) nameStart--;
+    if (nameStart === eq) {
+      pos = eq + 2;
+      continue;
+    }
+    const name = tag.slice(nameStart, eq);
+    const valStart = eq + 2;
+    const closeQuote = tag.indexOf('"', valStart);
+    if (closeQuote < 0) break;
+    attrs[name] = tag.slice(valStart, closeQuote);
+    pos = closeQuote + 1;
+  }
+  return attrs;
+}
+function findTags(xml, tagName) {
+  const tags = [];
+  const needle = `<${tagName} `;
+  let pos = 0;
+  while (pos < xml.length) {
+    const start = xml.indexOf(needle, pos);
+    if (start < 0) break;
+    const end = xml.indexOf(">", start);
+    if (end < 0) break;
+    tags.push(xml.slice(start, end + 1));
+    pos = end + 1;
+  }
+  return tags;
+}
+function parseModelXml(xml) {
+  const vertices = [];
+  const triangles = [];
+  for (const tag of findTags(xml, "vertex")) {
+    const a = parseTagAttrs(tag);
+    if (a["x"] !== void 0 && a["y"] !== void 0 && a["z"] !== void 0) {
+      vertices.push([parseFloat(a["x"]), parseFloat(a["y"]), parseFloat(a["z"])]);
+    }
+  }
+  for (const tag of findTags(xml, "triangle")) {
+    const a = parseTagAttrs(tag);
+    if (a["v1"] !== void 0 && a["v2"] !== void 0 && a["v3"] !== void 0) {
+      triangles.push([parseInt(a["v1"], 10), parseInt(a["v2"], 10), parseInt(a["v3"], 10)]);
+    }
+  }
+  return { vertices, triangles };
+}
+function buildTriFace(oc, a, b, c) {
+  const gpA = new oc.gp_Pnt_3(a[0], a[1], a[2]);
+  const gpB = new oc.gp_Pnt_3(b[0], b[1], b[2]);
+  const gpC = new oc.gp_Pnt_3(c[0], c[1], c[2]);
+  const e1 = new oc.BRepBuilderAPI_MakeEdge_3(gpA, gpB);
+  const e2 = new oc.BRepBuilderAPI_MakeEdge_3(gpB, gpC);
+  const e3 = new oc.BRepBuilderAPI_MakeEdge_3(gpC, gpA);
+  const wireBuilder = new oc.BRepBuilderAPI_MakeWire_1();
+  wireBuilder.Add_1(e1.Edge());
+  wireBuilder.Add_1(e2.Edge());
+  wireBuilder.Add_1(e3.Edge());
+  let face2 = null;
+  if (wireBuilder.IsDone()) {
+    const makeFace = new oc.BRepBuilderAPI_MakeFace_15(wireBuilder.Wire(), false);
+    if (makeFace.IsDone()) {
+      face2 = makeFace.Face();
+    }
+    makeFace.delete();
+  }
+  wireBuilder.delete();
+  e1.delete();
+  e2.delete();
+  e3.delete();
+  gpA.delete();
+  gpB.delete();
+  gpC.delete();
+  return face2;
+}
+function buildSolidFromMesh(mesh2) {
+  const oc = occtBoundary.getKernel().oc;
+  const sewing = new oc.BRepBuilderAPI_Sewing(1e-6, true, true, true, false);
+  let faceCount = 0;
+  try {
+    for (const [v1, v2, v3] of mesh2.triangles) {
+      const va = mesh2.vertices[v1];
+      const vb = mesh2.vertices[v2];
+      const vc = mesh2.vertices[v3];
+      if (!va || !vb || !vc) continue;
+      const triFace = buildTriFace(oc, va, vb, vc);
+      if (triFace !== null) {
+        sewing.Add(triFace);
+        faceCount++;
+      }
+    }
+    if (faceCount === 0) {
+      return errors.err(
+        errors.ioError(errors.BrepErrorCode.THREEMF_IMPORT_FAILED, "No valid triangular faces could be built")
+      );
+    }
+    const progress = new oc.Message_ProgressRange_1();
+    sewing.Perform(progress);
+    progress.delete();
+    const sewn = sewing.SewedShape();
+    const fixer = new oc.ShapeFix_Solid_1();
+    try {
+      const shell2 = oc.TopoDS.Shell_1(sewn);
+      const solid2 = fixer.SolidFromShell(shell2);
+      return errors.ok(shapeTypes.castShape(solid2));
+    } catch {
+      return errors.ok(shapeTypes.castShape(sewn));
+    } finally {
+      fixer.delete();
+    }
+  } finally {
+    sewing.delete();
+  }
+}
+async function importThreeMF(blob) {
+  try {
+    const arrayBuf = await blob.arrayBuffer();
+    const data = new Uint8Array(arrayBuf);
+    const modelData = extractFromZip(data, "3D/3dmodel.model");
+    if (!modelData) {
+      return errors.err(
+        errors.ioError(
+          errors.BrepErrorCode.THREEMF_IMPORT_FAILED,
+          "3MF archive does not contain 3D/3dmodel.model (or uses unsupported compression)"
+        )
+      );
+    }
+    const xml = new TextDecoder().decode(modelData);
+    const parsed = parseModelXml(xml);
+    if (parsed.vertices.length === 0 || parsed.triangles.length === 0) {
+      return errors.err(
+        errors.ioError(errors.BrepErrorCode.THREEMF_IMPORT_FAILED, "3MF model contains no valid geometry")
+      );
+    }
+    return buildSolidFromMesh(parsed);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return errors.err(errors.ioError(errors.BrepErrorCode.THREEMF_IMPORT_FAILED, `3MF import failed: ${msg}`, e));
+  }
+}
 function resolve(s) {
   if ("__wrapped" in s) {
     return s.val;
@@ -412,18 +1921,18 @@ function ellipsoid(rx, ry, rz, options) {
   return solid2;
 }
 function line(from, to) {
-  return curveBuilders.makeLine(from, to);
+  return surfaceBuilders.makeLine(from, to);
 }
 function circle(radius, options) {
   const axisDir = options?.axis ?? [0, 0, 1];
-  return curveBuilders.makeCircle(radius, options?.at ?? [0, 0, 0], axisDir);
+  return surfaceBuilders.makeCircle(radius, options?.at ?? [0, 0, 0], axisDir);
 }
 function ellipse(majorRadius, minorRadius, options) {
   const axisDir = options?.axis ?? [0, 0, 1];
-  return curveBuilders.makeEllipse(majorRadius, minorRadius, options?.at ?? [0, 0, 0], axisDir, options?.xDir);
+  return surfaceBuilders.makeEllipse(majorRadius, minorRadius, options?.at ?? [0, 0, 0], axisDir, options?.xDir);
 }
 function helix(pitch, height, radius, options) {
-  return curveBuilders.makeHelix(
+  return surfaceBuilders.makeHelix(
     pitch,
     height,
     radius,
@@ -433,11 +1942,11 @@ function helix(pitch, height, radius, options) {
   );
 }
 function threePointArc(p1, p2, p3) {
-  return curveBuilders.makeThreePointArc(p1, p2, p3);
+  return surfaceBuilders.makeThreePointArc(p1, p2, p3);
 }
 function ellipseArc(majorRadius, minorRadius, startAngle, endAngle, options) {
   const axisDir = options?.axis ?? [0, 0, 1];
-  return curveBuilders.makeEllipseArc(
+  return surfaceBuilders.makeEllipseArc(
     majorRadius,
     minorRadius,
     startAngle * vecOps.DEG2RAD,
@@ -448,28 +1957,28 @@ function ellipseArc(majorRadius, minorRadius, startAngle, endAngle, options) {
   );
 }
 function bsplineApprox(points, config) {
-  return curveBuilders.makeBSplineApproximation(points, config);
+  return surfaceBuilders.makeBSplineApproximation(points, config);
 }
 function bezier(points) {
-  return curveBuilders.makeBezierCurve(points);
+  return surfaceBuilders.makeBezierCurve(points);
 }
 function tangentArc(startPoint, startTgt, endPoint) {
-  return curveBuilders.makeTangentArc(startPoint, startTgt, endPoint);
+  return surfaceBuilders.makeTangentArc(startPoint, startTgt, endPoint);
 }
 function wire(listOfEdges) {
-  return curveBuilders.assembleWire(listOfEdges);
+  return surfaceBuilders.assembleWire(listOfEdges);
 }
 function face(w, holes) {
-  return Blueprint.makeFace(w, holes);
+  return surfaceBuilders.makeFace(w, holes);
 }
 function filledFace(w) {
-  return Blueprint.makeNonPlanarFace(w);
+  return surfaceBuilders.makeNonPlanarFace(w);
 }
 function subFace(originFace, w) {
-  return Blueprint.makeNewFaceWithinFace(originFace, w);
+  return surfaceBuilders.makeNewFaceWithinFace(originFace, w);
 }
 function polygon(points) {
-  return Blueprint.makePolygon(points);
+  return surfaceBuilders.makePolygon(points);
 }
 function vertex(point) {
   return loft$2.makeVertex(point);
@@ -487,7 +1996,7 @@ function sewShells(facesOrShells, ignoreType) {
   return loft$2.weldShellsAndFaces(facesOrShells, ignoreType);
 }
 function addHoles(f, holes) {
-  return Blueprint.addHolesInFace(f, holes);
+  return surfaceBuilders.addHolesInFace(f, holes);
 }
 function validateNotNull(shape2, label) {
   if (shape2.wrapped.IsNull()) {
@@ -506,9 +2015,11 @@ function thicken$1(shape2, thickness) {
     const progress = r(new oc.Message_ProgressRange_1());
     builder.Build(progress);
     const resultOc = builder.Shape();
-    const cast2 = shapeTypes.castShape(resultOc);
-    shapeFns.propagateOrigins(builder, [shape2], cast2);
-    return errors.ok(cast2);
+    const cast = shapeTypes.castShape(resultOc);
+    shapeFns.propagateOrigins(builder, [shape2], cast);
+    booleanFns.propagateFaceTags(builder, [shape2], cast);
+    booleanFns.propagateColors(builder, [shape2], cast);
+    return errors.ok(cast);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
     return errors.err(errors.occtError("THICKEN_FAILED", `Thicken operation failed: ${raw}`, e));
@@ -567,12 +2078,14 @@ function fillet$1(shape2, edges, radius) {
       }
     }
     const resultOc = builder.Shape();
-    const cast2 = shapeTypes.castShape(resultOc);
-    if (!shapeTypes.isShape3D(cast2)) {
+    const cast = shapeTypes.castShape(resultOc);
+    if (!shapeTypes.isShape3D(cast)) {
       return errors.err(errors.occtError("FILLET_RESULT_NOT_3D", "Fillet result is not a 3D shape"));
     }
-    shapeFns.propagateOrigins(builder, [shape2], cast2);
-    return errors.ok(cast2);
+    shapeFns.propagateOrigins(builder, [shape2], cast);
+    booleanFns.propagateFaceTags(builder, [shape2], cast);
+    booleanFns.propagateColors(builder, [shape2], cast);
+    return errors.ok(cast);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
     return errors.err(
@@ -661,12 +2174,14 @@ function chamfer$1(shape2, edges, distance) {
       }
     }
     const resultOc = builder.Shape();
-    const cast2 = shapeTypes.castShape(resultOc);
-    if (!shapeTypes.isShape3D(cast2)) {
+    const cast = shapeTypes.castShape(resultOc);
+    if (!shapeTypes.isShape3D(cast)) {
       return errors.err(errors.occtError("CHAMFER_RESULT_NOT_3D", "Chamfer result is not a 3D shape"));
     }
-    shapeFns.propagateOrigins(builder, [shape2], cast2);
-    return errors.ok(cast2);
+    shapeFns.propagateOrigins(builder, [shape2], cast);
+    booleanFns.propagateFaceTags(builder, [shape2], cast);
+    booleanFns.propagateColors(builder, [shape2], cast);
+    return errors.ok(cast);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
     return errors.err(
@@ -709,12 +2224,14 @@ function shell$1(shape2, faces, thickness, tolerance = 1e-3) {
       progress
     );
     const resultOc = builder.Shape();
-    const cast2 = shapeTypes.castShape(resultOc);
-    if (!shapeTypes.isShape3D(cast2)) {
+    const cast = shapeTypes.castShape(resultOc);
+    if (!shapeTypes.isShape3D(cast)) {
       return errors.err(errors.occtError("SHELL_RESULT_NOT_3D", "Shell result is not a 3D shape"));
     }
-    shapeFns.propagateOrigins(builder, [shape2], cast2);
-    return errors.ok(cast2);
+    shapeFns.propagateOrigins(builder, [shape2], cast);
+    booleanFns.propagateFaceTags(builder, [shape2], cast);
+    booleanFns.propagateColors(builder, [shape2], cast);
+    return errors.ok(cast);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
     return errors.err(
@@ -749,12 +2266,14 @@ function offset$1(shape2, distance, tolerance = 1e-6) {
       progress
     );
     const resultOc = builder.Shape();
-    const cast2 = shapeTypes.castShape(resultOc);
-    if (!shapeTypes.isShape3D(cast2)) {
+    const cast = shapeTypes.castShape(resultOc);
+    if (!shapeTypes.isShape3D(cast)) {
       return errors.err(errors.occtError("OFFSET_RESULT_NOT_3D", "Offset result is not a 3D shape"));
     }
-    shapeFns.propagateOrigins(builder, [shape2], cast2);
-    return errors.ok(cast2);
+    shapeFns.propagateOrigins(builder, [shape2], cast);
+    booleanFns.propagateFaceTags(builder, [shape2], cast);
+    booleanFns.propagateColors(builder, [shape2], cast);
+    return errors.ok(cast);
   } catch (e) {
     const raw = e instanceof Error ? e.message : String(e);
     return errors.err(errors.occtError("OFFSET_FAILED", `Offset operation failed: ${raw}`, e));
@@ -795,6 +2314,9 @@ function intersect(a, b, options) {
 function section(shape2, plane, options) {
   return booleanFns.section(resolve(shape2), plane, options);
 }
+function sectionToFace(shape2, plane, options) {
+  return booleanFns.sectionToFace(resolve(shape2), plane, options);
+}
 function split(shape2, tools) {
   return booleanFns.split(resolve(shape2), tools);
 }
@@ -904,7 +2426,7 @@ function toBREP(shape2) {
   return shapeFns.toBREP(resolve(shape2));
 }
 function fromBREP(data) {
-  return cast.fromBREP(data);
+  return faceFns.fromBREP(data);
 }
 function isValid(shape2) {
   return topology.isValid(resolve(shape2));
@@ -1029,7 +2551,7 @@ function pocket(shape2, options) {
   const targetFace = resolveTargetFace(s, options.face);
   const normal = faceFns.normalAt(targetFace);
   const w = toWire(profile);
-  const faceResult = Blueprint.makeFace(w);
+  const faceResult = surfaceBuilders.makeFace(w);
   if (errors.isErr(faceResult)) return faceResult;
   const extDir = vecOps.vecScale(vecOps.vecNormalize(normal), -depth);
   const toolResult = operations.extrude(faceResult.value, extDir);
@@ -1045,7 +2567,7 @@ function boss(shape2, options) {
   const targetFace = resolveTargetFace(s, options.face);
   const normal = faceFns.normalAt(targetFace);
   const w = toWire(profile);
-  const faceResult = Blueprint.makeFace(w);
+  const faceResult = surfaceBuilders.makeFace(w);
   if (errors.isErr(faceResult)) return faceResult;
   const extDir = vecOps.vecScale(vecOps.vecNormalize(normal), height);
   const toolResult = operations.extrude(faceResult.value, extDir);
@@ -1471,6 +2993,7 @@ exports.drawingFillet = drawFns.drawingFillet;
 exports.drawingFuse = drawFns.drawingFuse;
 exports.drawingIntersect = drawFns.drawingIntersect;
 exports.drawingToSketchOnPlane = drawFns.drawingToSketchOnPlane;
+exports.fontMetrics = drawFns.fontMetrics;
 exports.getFont = drawFns.getFont;
 exports.isProjectionPlane = drawFns.isProjectionPlane;
 exports.loadFont = drawFns.loadFont;
@@ -1497,6 +3020,7 @@ exports.sketchSweep = drawFns.sketchSweep;
 exports.sketchText = drawFns.sketchText;
 exports.sketchWires = drawFns.sketchWires;
 exports.textBlueprints = drawFns.textBlueprints;
+exports.textMetrics = drawFns.textMetrics;
 exports.translateDrawing = drawFns.translateDrawing;
 exports.createNamedPlane = vectors.createNamedPlane;
 exports.createPlane = vectors.createPlane;
@@ -1517,8 +3041,21 @@ exports.iterEdges = shapeFns.iterEdges;
 exports.iterFaces = shapeFns.iterFaces;
 exports.iterVertices = shapeFns.iterVertices;
 exports.iterWires = shapeFns.iterWires;
+exports.resize = shapeFns.resize;
 exports.setShapeOrigin = shapeFns.setShapeOrigin;
 exports.vertexPosition = shapeFns.vertexPosition;
+exports.applyGlue = booleanFns.applyGlue;
+exports.colorFaces = booleanFns.colorFaces;
+exports.colorShape = booleanFns.colorShape;
+exports.cutAll = booleanFns.cutAll;
+exports.findFacesByTag = booleanFns.findFacesByTag;
+exports.fuseAll = booleanFns.fuseAll;
+exports.getFaceColor = booleanFns.getFaceColor;
+exports.getFaceTags = booleanFns.getFaceTags;
+exports.getShapeColor = booleanFns.getShapeColor;
+exports.getTagMetadata = booleanFns.getTagMetadata;
+exports.setTagMetadata = booleanFns.setTagMetadata;
+exports.tagFaces = booleanFns.tagFaces;
 exports.adjacentFaces = topology.adjacentFaces;
 exports.autoHeal = topology.autoHeal;
 exports.chamferDistAngleShape = topology.chamferDistAngle;
@@ -1533,17 +3070,24 @@ exports.toGroupedBufferGeometryData = topology.toGroupedBufferGeometryData;
 exports.toLineGeometryData = topology.toLineGeometryData;
 exports.verticesOfEdge = topology.verticesOfEdge;
 exports.wiresOfFace = topology.wiresOfFace;
+exports.asTopo = faceFns.asTopo;
+exports.cast = faceFns.cast;
 exports.classifyPointOnFace = faceFns.classifyPointOnFace;
+exports.deserializeShape = faceFns.fromBREP;
+exports.downcast = faceFns.downcast;
 exports.faceCenter = faceFns.faceCenter;
 exports.faceGeomType = faceFns.faceGeomType;
 exports.faceOrientation = faceFns.faceOrientation;
 exports.flipFaceOrientation = faceFns.flipFaceOrientation;
 exports.getSurfaceType = faceFns.getSurfaceType;
 exports.innerWires = faceFns.innerWires;
+exports.isCompSolid = faceFns.isCompSolid;
+exports.iterTopo = faceFns.iterTopo;
 exports.normalAt = faceFns.normalAt;
 exports.outerWire = faceFns.outerWire;
 exports.pointOnSurface = faceFns.pointOnSurface;
 exports.projectPointOnFace = faceFns.projectPointOnFace;
+exports.shapeType = faceFns.shapeType;
 exports.uvBounds = faceFns.uvBounds;
 exports.uvCoordinates = faceFns.uvCoordinates;
 exports.clearMeshCache = meshFns.clearMeshCache;
@@ -1551,9 +3095,6 @@ exports.createMeshCache = meshFns.createMeshCache;
 exports.exportIGES = meshFns.exportIGES;
 exports.exportSTEP = meshFns.exportSTEP;
 exports.exportSTL = meshFns.exportSTL;
-exports.applyGlue = booleanFns.applyGlue;
-exports.cutAll = booleanFns.cutAll;
-exports.fuseAll = booleanFns.fuseAll;
 exports.createDistanceQuery = measurement.createDistanceQuery;
 exports.measureArea = measurement.measureArea;
 exports.measureCurvatureAt = measurement.measureCurvatureAt;
@@ -1564,13 +3105,7 @@ exports.measureLinearProps = measurement.measureLinearProps;
 exports.measureSurfaceProps = measurement.measureSurfaceProps;
 exports.measureVolume = measurement.measureVolume;
 exports.measureVolumeProps = measurement.measureVolumeProps;
-exports.asTopo = cast.asTopo;
-exports.cast = cast.cast;
-exports.deserializeShape = cast.fromBREP;
-exports.downcast = cast.downcast;
-exports.isCompSolid = cast.isCompSolid;
-exports.iterTopo = cast.iterTopo;
-exports.shapeType = cast.shapeType;
+exports.fill = surfaceBuilders.fill;
 exports.edgeFinder = query.edgeFinder;
 exports.BrepBugError = result.BrepBugError;
 exports.bug = result.bug;
@@ -1592,6 +3127,7 @@ exports.registerHandler = worker.registerHandler;
 exports.rejectAll = worker.rejectAll;
 exports.BrepWrapperError = BrepWrapperError;
 exports.addHoles = addHoles;
+exports.addMate = addMate;
 exports.applyMatrix = applyMatrix;
 exports.bezier = bezier;
 exports.boss = boss;
@@ -1603,6 +3139,7 @@ exports.checkInterference = checkInterference;
 exports.circle = circle;
 exports.clone = clone;
 exports.compound = compound;
+exports.computeStraightSkeleton = computeStraightSkeleton;
 exports.cone = cone;
 exports.cut = cut;
 exports.cylinder = cylinder;
@@ -1617,9 +3154,13 @@ exports.filledFace = filledFace;
 exports.fillet = fillet;
 exports.fromBREP = fromBREP;
 exports.fuse = fuse;
+exports.guidedSweep = guidedSweep;
 exports.heal = heal;
 exports.helix = helix;
 exports.hull = hull;
+exports.importDXF = importDXF;
+exports.importOBJ = importOBJ;
+exports.importThreeMF = importThreeMF;
 exports.intersect = intersect;
 exports.isChamferRadius = isChamferRadius;
 exports.isEmpty = isEmpty;
@@ -1635,26 +3176,33 @@ exports.meshEdges = meshEdges;
 exports.minkowski = minkowski;
 exports.mirror = mirror;
 exports.mirrorJoin = mirrorJoin;
+exports.multiSectionSweep = multiSectionSweep;
 exports.offset = offset;
 exports.offsetFace = offsetFace;
 exports.pocket = pocket;
 exports.polygon = polygon;
+exports.polyhedron = polyhedron;
 exports.rectangularPattern = rectangularPattern;
 exports.resolve = resolve;
 exports.resolve3D = resolve3D;
 exports.revolve = revolve;
+exports.roof = roof;
 exports.rotate = rotate;
 exports.scale = scale;
 exports.section = section;
+exports.sectionToFace = sectionToFace;
 exports.sewShells = sewShells;
 exports.shape = shape;
 exports.shell = shell;
 exports.simplify = simplify;
 exports.slice = slice;
 exports.solid = solid;
+exports.solveAssembly = solveAssembly;
 exports.sphere = sphere;
 exports.split = split;
 exports.subFace = subFace;
+exports.surfaceFromGrid = surfaceFromGrid;
+exports.surfaceFromImage = surfaceFromImage;
 exports.tangentArc = tangentArc;
 exports.thicken = thicken;
 exports.threePointArc = threePointArc;