brepjs 8.3.0 → 8.7.4

package/dist/{occtBoundary-BFAaUtA7.cjs → occtBoundary-DH2VO-rq.cjs}

@@ -1042,7 +1042,7 @@ function makeWire(oc, edges) {
   progress.delete();
   return wire;
 }
-function makeFace(oc, wire, planar = true) {
+function makeFace$1(oc, wire, planar = true) {
   if (planar) {
     const builder2 = new oc.BRepBuilderAPI_MakeFace_15(wire, false);
     const face = builder2.Face();
@@ -1441,6 +1441,416 @@ function approximatePoints(oc, points, options = {}) {
   splineBuilder.delete();
   return edge;
 }
+function sub(a, b) {
+  return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
+}
+function cross(a, b) {
+  return {
+    x: a.y * b.z - a.z * b.y,
+    y: a.z * b.x - a.x * b.z,
+    z: a.x * b.y - a.y * b.x
+  };
+}
+function dot(a, b) {
+  return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+function lengthVec(v) {
+  return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+}
+function distSq(a, b) {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  const dz = a.z - b.z;
+  return dx * dx + dy * dy + dz * dz;
+}
+function at(arr, i) {
+  const v = arr[i];
+  if (v === void 0) throw new Error(`Index ${i} out of bounds`);
+  return v;
+}
+function atN(arr, i) {
+  const v = arr[i];
+  if (v === void 0) throw new Error(`Index ${i} out of bounds`);
+  return v;
+}
+function makeFace(points, a, b, c) {
+  const normal = cross(sub(at(points, b), at(points, a)), sub(at(points, c), at(points, a)));
+  const len = lengthVec(normal);
+  const n = len > 1e-14 ? { x: normal.x / len, y: normal.y / len, z: normal.z / len } : normal;
+  return {
+    a,
+    b,
+    c,
+    normal: n,
+    offset: dot(n, at(points, a)),
+    alive: true,
+    outsidePoints: []
+  };
+}
+function signedDist(face, point) {
+  return dot(face.normal, point) - face.offset;
+}
+function deduplicatePoints(points, tolerance) {
+  const tolSq = tolerance * tolerance;
+  const result = [];
+  for (const p of points) {
+    let isDuplicate = false;
+    for (const q of result) {
+      if (distSq(p, q) < tolSq) {
+        isDuplicate = true;
+        break;
+      }
+    }
+    if (!isDuplicate) result.push(p);
+  }
+  return result;
+}
+function findInitialTetrahedron(points) {
+  const n = points.length;
+  if (n < 4) return null;
+  let i0 = 0;
+  let i1 = 1;
+  let maxDist = distSq(at(points, 0), at(points, 1));
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const d = distSq(at(points, i), at(points, j));
+      if (d > maxDist) {
+        maxDist = d;
+        i0 = i;
+        i1 = j;
+      }
+    }
+  }
+  if (maxDist < 1e-20) return null;
+  const lineDir = sub(at(points, i1), at(points, i0));
+  let i2 = -1;
+  let maxLineDist = -1;
+  for (let i = 0; i < n; i++) {
+    if (i === i0 || i === i1) continue;
+    const v = sub(at(points, i), at(points, i0));
+    const c = cross(lineDir, v);
+    const d = dot(c, c);
+    if (d > maxLineDist) {
+      maxLineDist = d;
+      i2 = i;
+    }
+  }
+  if (i2 === -1 || maxLineDist < 1e-20) return null;
+  const planeNormal = cross(
+    sub(at(points, i1), at(points, i0)),
+    sub(at(points, i2), at(points, i0))
+  );
+  const planeLen = lengthVec(planeNormal);
+  if (planeLen < 1e-14) return null;
+  const pn = {
+    x: planeNormal.x / planeLen,
+    y: planeNormal.y / planeLen,
+    z: planeNormal.z / planeLen
+  };
+  const planeOffset = dot(pn, at(points, i0));
+  let i3 = -1;
+  let maxPlaneDist = -1;
+  for (let i = 0; i < n; i++) {
+    if (i === i0 || i === i1 || i === i2) continue;
+    const d = Math.abs(dot(pn, at(points, i)) - planeOffset);
+    if (d > maxPlaneDist) {
+      maxPlaneDist = d;
+      i3 = i;
+    }
+  }
+  if (i3 === -1 || maxPlaneDist < 1e-14) return null;
+  const sd = dot(pn, at(points, i3)) - planeOffset;
+  if (sd > 0) {
+    return [i0, i2, i1, i3];
+  }
+  return [i0, i1, i2, i3];
+}
+function quickHull(inputPoints, tolerance) {
+  const points = deduplicatePoints(inputPoints, tolerance);
+  if (points.length < 4) {
+    throw new Error(
+      points.length === 0 ? "No points provided for convex hull" : "Fewer than 4 non-coincident points; cannot form a 3D convex hull"
+    );
+  }
+  const tet = findInitialTetrahedron(points);
+  if (tet === null) {
+    throw new Error("All points are coplanar; cannot form a 3D convex hull");
+  }
+  const [t0, t1, t2, t3] = tet;
+  const centroid = {
+    x: (at(points, t0).x + at(points, t1).x + at(points, t2).x + at(points, t3).x) / 4,
+    y: (at(points, t0).y + at(points, t1).y + at(points, t2).y + at(points, t3).y) / 4,
+    z: (at(points, t0).z + at(points, t1).z + at(points, t2).z + at(points, t3).z) / 4
+  };
+  function makeOutwardFace(a, b, c) {
+    const face = makeFace(points, a, b, c);
+    const faceCenter = {
+      x: (at(points, a).x + at(points, b).x + at(points, c).x) / 3,
+      y: (at(points, a).y + at(points, b).y + at(points, c).y) / 3,
+      z: (at(points, a).z + at(points, b).z + at(points, c).z) / 3
+    };
+    const toCentroid = sub(centroid, faceCenter);
+    if (dot(face.normal, toCentroid) > 0) {
+      return makeFace(points, a, c, b);
+    }
+    return face;
+  }
+  const faces = [
+    makeOutwardFace(t0, t1, t2),
+    makeOutwardFace(t0, t2, t3),
+    makeOutwardFace(t0, t3, t1),
+    makeOutwardFace(t1, t3, t2)
+  ];
+  const tetSet = /* @__PURE__ */ new Set([t0, t1, t2, t3]);
+  const epsilon = 1e-10;
+  for (let i = 0; i < points.length; i++) {
+    if (tetSet.has(i)) continue;
+    for (const face of faces) {
+      if (signedDist(face, at(points, i)) > epsilon) {
+        face.outsidePoints.push(i);
+        break;
+      }
+    }
+  }
+  for (let iteration = 0; iteration < points.length * 4; iteration++) {
+    let currentFace = null;
+    for (const face of faces) {
+      if (face.alive && face.outsidePoints.length > 0) {
+        currentFace = face;
+        break;
+      }
+    }
+    if (currentFace === null) break;
+    let furthestIdx = atN(currentFace.outsidePoints, 0);
+    let furthestDist = signedDist(currentFace, at(points, furthestIdx));
+    for (let i = 1; i < currentFace.outsidePoints.length; i++) {
+      const idx = atN(currentFace.outsidePoints, i);
+      const d = signedDist(currentFace, at(points, idx));
+      if (d > furthestDist) {
+        furthestDist = d;
+        furthestIdx = idx;
+      }
+    }
+    const visibleFaces = [];
+    for (const face of faces) {
+      if (face.alive && signedDist(face, at(points, furthestIdx)) > epsilon) {
+        visibleFaces.push(face);
+      }
+    }
+    const edgeCount = /* @__PURE__ */ new Map();
+    for (const face of visibleFaces) {
+      const edges = [
+        [face.a, face.b],
+        [face.b, face.c],
+        [face.c, face.a]
+      ];
+      for (const [ea, eb] of edges) {
+        const key = ea < eb ? `${ea}-${eb}` : `${eb}-${ea}`;
+        const entry = edgeCount.get(key);
+        if (entry) {
+          entry.count++;
+        } else {
+          edgeCount.set(key, { a: ea, b: eb, count: 1 });
+        }
+      }
+    }
+    const horizonEdges = [];
+    for (const entry of edgeCount.values()) {
+      if (entry.count === 1) {
+        horizonEdges.push({ a: entry.a, b: entry.b });
+      }
+    }
+    const orphanedPoints = [];
+    for (const face of visibleFaces) {
+      for (const idx of face.outsidePoints) {
+        if (idx !== furthestIdx) {
+          orphanedPoints.push(idx);
+        }
+      }
+      face.alive = false;
+      face.outsidePoints = [];
+    }
+    const newFaces = [];
+    for (const edge of horizonEdges) {
+      const newFaceObj = makeFace(points, edge.a, edge.b, furthestIdx);
+      newFaces.push(newFaceObj);
+      faces.push(newFaceObj);
+    }
+    for (const idx of orphanedPoints) {
+      for (const face of newFaces) {
+        if (signedDist(face, at(points, idx)) > epsilon) {
+          face.outsidePoints.push(idx);
+          break;
+        }
+      }
+    }
+  }
+  const resultFaces = [];
+  for (const face of faces) {
+    if (face.alive) {
+      resultFaces.push([face.a, face.b, face.c]);
+    }
+  }
+  return { faces: resultFaces, points };
+}
+function extractVertices(oc, shapes, tolerance) {
+  const vertices = [];
+  const meshDeflection = Math.max(tolerance, 1);
+  for (const shape of shapes) {
+    const mesh2 = new oc.BRepMesh_IncrementalMesh_2(
+      shape,
+      meshDeflection,
+      false,
+      meshDeflection * 0.5,
+      false
+    );
+    const progress = new oc.Message_ProgressRange_1();
+    mesh2.Perform(progress);
+    progress.delete();
+    mesh2.delete();
+    const explorer = new oc.TopExp_Explorer_2(
+      shape,
+      oc.TopAbs_ShapeEnum.TopAbs_FACE,
+      oc.TopAbs_ShapeEnum.TopAbs_SHAPE
+    );
+    while (explorer.More()) {
+      const face = oc.TopoDS.Face_1(explorer.Current());
+      const location = new oc.TopLoc_Location_1();
+      const tri = oc.BRep_Tool.Triangulation(face, location, 0);
+      if (!tri.IsNull()) {
+        const trsf = location.Transformation();
+        const nbNodes = tri.get().NbNodes();
+        for (let i = 1; i <= nbNodes; i++) {
+          const node = tri.get().Node(i);
+          const transformed = node.Transformed(trsf);
+          vertices.push({
+            x: transformed.X(),
+            y: transformed.Y(),
+            z: transformed.Z()
+          });
+          transformed.delete();
+          node.delete();
+        }
+        trsf.delete();
+      }
+      location.delete();
+      explorer.Next();
+    }
+    explorer.delete();
+  }
+  return vertices;
+}
+function buildTriFace(oc, pa, pb, pc) {
+  const gpA = new oc.gp_Pnt_3(pa.x, pa.y, pa.z);
+  const gpB = new oc.gp_Pnt_3(pb.x, pb.y, pb.z);
+  const gpC = new oc.gp_Pnt_3(pc.x, pc.y, pc.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 face = null;
+  if (wireBuilder.IsDone()) {
+    const makeFaceBuilder = new oc.BRepBuilderAPI_MakeFace_15(wireBuilder.Wire(), false);
+    if (makeFaceBuilder.IsDone()) {
+      face = makeFaceBuilder.Face();
+    }
+    makeFaceBuilder.delete();
+  }
+  wireBuilder.delete();
+  e1.delete();
+  e2.delete();
+  e3.delete();
+  gpA.delete();
+  gpB.delete();
+  gpC.delete();
+  return face;
+}
+function reconstructBrep(oc, hullResult, tolerance) {
+  const { faces: hullFaces, points } = hullResult;
+  const ocFaces = [];
+  for (const [ia, ib, ic] of hullFaces) {
+    const face = buildTriFace(oc, at(points, ia), at(points, ib), at(points, ic));
+    if (face !== null) {
+      ocFaces.push(face);
+    }
+  }
+  if (ocFaces.length < 4) {
+    throw new Error(`hull: only ${ocFaces.length} faces built, need at least 4 for a solid`);
+  }
+  const sewTolerance = Math.max(tolerance, 1e-4);
+  const sewing = new oc.BRepBuilderAPI_Sewing(sewTolerance, true, true, true, false);
+  for (const face of ocFaces) {
+    sewing.Add(face);
+  }
+  const sewProgress = new oc.Message_ProgressRange_1();
+  sewing.Perform(sewProgress);
+  sewProgress.delete();
+  const sewn = sewing.SewedShape();
+  sewing.delete();
+  const shellExplorer = new oc.TopExp_Explorer_2(
+    sewn,
+    oc.TopAbs_ShapeEnum.TopAbs_SHELL,
+    oc.TopAbs_ShapeEnum.TopAbs_SHAPE
+  );
+  if (shellExplorer.More()) {
+    const shell2 = oc.TopoDS.Shell_1(shellExplorer.Current());
+    shellExplorer.delete();
+    const solidMaker = new oc.BRepBuilderAPI_MakeSolid_1();
+    solidMaker.Add(shell2);
+    const solidProgress = new oc.Message_ProgressRange_1();
+    solidMaker.Build(solidProgress);
+    solidProgress.delete();
+    if (solidMaker.IsDone()) {
+      const solid = solidMaker.Solid();
+      solidMaker.delete();
+      shell2.delete();
+      const props = new oc.GProp_GProps_1();
+      oc.BRepGProp.VolumeProperties_1(solid, props, false, false, false);
+      const vol = props.Mass();
+      props.delete();
+      if (vol < 0) {
+        solid.Complement();
+      }
+      return solid;
+    }
+    shell2.delete();
+    solidMaker.delete();
+    return sewn;
+  }
+  shellExplorer.delete();
+  return sewn;
+}
+function hull(oc, shapes, tolerance) {
+  if (shapes.length === 0) {
+    throw new Error("hull: no shapes provided");
+  }
+  const vertices = extractVertices(oc, shapes, tolerance);
+  if (vertices.length < 4) {
+    throw new Error("hull: fewer than 4 vertices extracted from input shapes");
+  }
+  const hullResult = quickHull(vertices, tolerance);
+  if (hullResult.faces.length < 4) {
+    throw new Error("hull: degenerate hull (fewer than 4 faces)");
+  }
+  return reconstructBrep(oc, hullResult, tolerance);
+}
+function buildSolidFromFaces(oc, points, faces, tolerance) {
+  const hullResult = { points, faces };
+  return reconstructBrep(oc, hullResult, tolerance);
+}
+function hullFromPoints(oc, points, tolerance) {
+  if (points.length < 4) {
+    throw new Error("hullFromPoints: fewer than 4 points");
+  }
+  const hullResult = quickHull(points, tolerance);
+  if (hullResult.faces.length < 4) {
+    throw new Error("hullFromPoints: degenerate hull (fewer than 4 faces)");
+  }
+  return reconstructBrep(oc, hullResult, tolerance);
+}
 class OCCTAdapter {
   oc;
   constructor(oc) {
@@ -1465,6 +1875,25 @@ class OCCTAdapter {
   cutAll(shape, tools, options = {}) {
     return cutAll(this.oc, shape, tools, options);
   }
+  // --- Convex hull ---
+  hull(shapes, tolerance) {
+    return hull(this.oc, shapes, tolerance);
+  }
+  hullFromPoints(points, tolerance) {
+    return hullFromPoints(
+      this.oc,
+      points.map((p) => ({ x: p.x, y: p.y, z: p.z })),
+      tolerance
+    );
+  }
+  buildSolidFromFaces(points, faces, tolerance) {
+    return buildSolidFromFaces(
+      this.oc,
+      points.map((p) => ({ x: p.x, y: p.y, z: p.z })),
+      faces,
+      tolerance
+    );
+  }
   // --- Shape construction (delegates to constructorOps.ts) ---
   makeVertex(x, y, z) {
     return makeVertex(this.oc, x, y, z);
@@ -1476,7 +1905,7 @@ class OCCTAdapter {
     return makeWire(this.oc, edges);
   }
   makeFace(wire, planar = true) {
-    return makeFace(this.oc, wire, planar);
+    return makeFace$1(this.oc, wire, planar);
   }
   makeBox(width, height, depth) {
     return makeBox(this.oc, width, height, depth);

package/dist/operations/assemblyFns.d.ts

@@ -10,6 +10,7 @@ export interface AssemblyNode {
     };
     readonly metadata?: Readonly<Record<string, unknown>>;
     readonly children: ReadonlyArray<AssemblyNode>;
+    readonly mates?: readonly unknown[];
 }
 export interface AssemblyNodeOptions {
     shape?: AnyShape;

package/dist/operations/assemblyFns.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assemblyFns.d.ts","sourceRoot":"","sources":["../../src/operations/assemblyFns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAMtD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,IAAI,CAAA;KAAE,CAAC;IACjD,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACtD,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;CAChD;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,IAAI,CAAA;KAAE,CAAC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAMD,kCAAkC;AAClC,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,YAAY,CAShG;AAMD,mDAAmD;AACnD,wBAAgB,QAAQ,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,GAAG,YAAY,CAEhF;AAED,uEAAuE;AACvE,wBAAgB,WAAW,CAAC,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,GAAG,YAAY,CAMjF;AAED,sDAAsD;AACtD,wBAAgB,UAAU,CACxB,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE,OAAO,CAAC,mBAAmB,CAAC,GACpC,YAAY,CAQd;AAMD,yEAAyE;AACzE,wBAAgB,QAAQ,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAOnF;AAED,gEAAgE;AAChE,wBAAgB,YAAY,CAC1B,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,EACpD,KAAK,SAAI,GACR,IAAI,CAKN;AAED,mCAAmC;AACnC,wBAAgB,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAMrD;AAED,oDAAoD;AACpD,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,QAAQ,EAAE,CAM5D"}
+{"version":3,"file":"assemblyFns.d.ts","sourceRoot":"","sources":["../../src/operations/assemblyFns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAMtD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,IAAI,CAAA;KAAE,CAAC;IACjD,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACtD,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;IAC/C,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;CACrC;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,IAAI,CAAA;KAAE,CAAC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAMD,kCAAkC;AAClC,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,YAAY,CAShG;AAMD,mDAAmD;AACnD,wBAAgB,QAAQ,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,GAAG,YAAY,CAEhF;AAED,uEAAuE;AACvE,wBAAgB,WAAW,CAAC,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,GAAG,YAAY,CAMjF;AAED,sDAAsD;AACtD,wBAAgB,UAAU,CACxB,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE,OAAO,CAAC,mBAAmB,CAAC,GACpC,YAAY,CAQd;AAMD,yEAAyE;AACzE,wBAAgB,QAAQ,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAOnF;AAED,gEAAgE;AAChE,wBAAgB,YAAY,CAC1B,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,EACpD,KAAK,SAAI,GACR,IAAI,CAKN;AAED,mCAAmC;AACnC,wBAAgB,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAMrD;AAED,oDAAoD;AACpD,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,QAAQ,EAAE,CAM5D"}

package/dist/operations/guidedSweepFns.d.ts

@@ -0,0 +1,25 @@
+import { Wire, Solid, Shell } from '../core/shapeTypes.js';
+import { Result } from '../core/result.js';
+/** Options for guide curve sweep. */
+export interface GuidedSweepOptions {
+    /** Transition mode at spine vertices. Defaults to 'transformed'. */
+    transition?: 'transformed' | 'round' | 'right';
+    /** Produce a solid (true) or shell (false). Defaults to true. */
+    solid?: boolean;
+    /** Builder tolerance. When set, passed to SetTolerance. */
+    tolerance?: number;
+}
+/**
+ * Sweep a profile wire along a spine, using guide wires to control shape evolution.
+ *
+ * The first guide wire is used as an auxiliary spine via `SetMode_5`, which
+ * controls how the profile orientation evolves along the path.
+ *
+ * @param profile - The cross-section wire to sweep.
+ * @param spine - The path wire to sweep along.
+ * @param guides - Guide wires controlling profile evolution. First guide is used as auxiliary spine.
+ * @param options - Sweep configuration.
+ * @returns Result containing the swept Solid or Shell.
+ */
+export declare function guidedSweep(profile: Wire, spine: Wire, guides: ReadonlyArray<Wire>, options?: GuidedSweepOptions): Result<Solid | Shell>;
+//# sourceMappingURL=guidedSweepFns.d.ts.map

package/dist/operations/guidedSweepFns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guidedSweepFns.d.ts","sourceRoot":"","sources":["../../src/operations/guidedSweepFns.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAGhE,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,mBAAmB,CAAC;AAGzD,qCAAqC;AACrC,MAAM,WAAW,kBAAkB;IACjC,oEAAoE;IACpE,UAAU,CAAC,EAAE,aAAa,GAAG,OAAO,GAAG,OAAO,CAAC;IAC/C,iEAAiE;IACjE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,2DAA2D;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,IAAI,EACb,KAAK,EAAE,IAAI,EACX,MAAM,EAAE,aAAa,CAAC,IAAI,CAAC,EAC3B,OAAO,GAAE,kBAAuB,GAC/B,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC,CAiDvB"}

package/dist/operations/mateFns.d.ts

@@ -0,0 +1,50 @@
+import { Face, Edge } from '../core/shapeTypes.js';
+import { Vec3 } from '../core/types.js';
+import { Result } from '../core/result.js';
+import { AssemblyNode } from './assemblyFns.js';
+export interface MateEntity {
+    node: string;
+    face?: Face;
+    edge?: Edge;
+    point?: Vec3;
+}
+export type MateConstraint = {
+    type: 'coincident';
+    entityA: MateEntity;
+    entityB: MateEntity;
+} | {
+    type: 'concentric';
+    axisA: MateEntity;
+    axisB: MateEntity;
+} | {
+    type: 'distance';
+    entityA: MateEntity;
+    entityB: MateEntity;
+    distance: number;
+} | {
+    type: 'angle';
+    entityA: MateEntity;
+    entityB: MateEntity;
+    angle: number;
+} | {
+    type: 'fixed';
+    entity: MateEntity;
+};
+export interface AssemblySolveResult {
+    transforms: Map<string, {
+        position: Vec3;
+        rotation: [number, number, number, number];
+    }>;
+    dof: number;
+    converged: boolean;
+}
+/**
+ * Add a mate constraint to an assembly.
+ * Returns a new assembly node with the constraint added.
+ */
+export declare function addMate(assembly: AssemblyNode, constraint: MateConstraint): AssemblyNode;
+/**
+ * Solve all mate constraints and compute part transforms.
+ */
+export declare function solveAssembly(assembly: AssemblyNode): Result<AssemblySolveResult>;
+//# sourceMappingURL=mateFns.d.ts.map

package/dist/operations/mateFns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mateFns.d.ts","sourceRoot":"","sources":["../../src/operations/mateFns.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,mBAAmB,CAAC;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAarD,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,KAAK,CAAC,EAAE,IAAI,CAAC;CACd;AAED,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,UAAU,CAAA;CAAE,GAChE;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAE,GAC5D;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAChF;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC1E;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,CAAC;AAE1C,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,QAAQ,EAAE,IAAI,CAAC;QAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAC,CAAC;IACxF,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,OAAO,CAAC;CACpB;AAyBD;;;GAGG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,YAAY,EAAE,UAAU,EAAE,cAAc,GAAG,YAAY,CAGxF;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CAAC,mBAAmB,CAAC,CA0HjF"}

package/dist/operations/multiSweepFns.d.ts

@@ -0,0 +1,32 @@
+import { Wire, Solid, Shell } from '../core/shapeTypes.js';
+import { Result } from '../core/result.js';
+/** Configuration for a single sweep section (profile wire + optional location). */
+export interface SweepSectionConfig {
+    /** The profile wire for this section. */
+    wire: Wire;
+    /** Location along the spine as a parameter in [0.0, 1.0]. Auto-distributed if omitted. */
+    location?: number;
+}
+/** Options for the multi-section sweep operation. */
+export interface MultiSweepOptions {
+    /** Produce a solid (true) or shell (false). Defaults to true. */
+    solid?: boolean;
+    /** Use ruled (straight) interpolation between sections. Defaults to false. */
+    ruled?: boolean;
+    /** Tolerance for the loft builder. Defaults to 1e-6. */
+    tolerance?: number;
+}
+/**
+ * Sweep multiple profile sections along a spine wire.
+ *
+ * Each section wire is positioned at a point along the spine (either at an
+ * explicit `location` parameter or auto-distributed evenly). The profiles
+ * are then lofted using `BRepOffsetAPI_ThruSections`.
+ *
+ * @param sections - At least 2 section configs with profile wires.
+ * @param spine - The path wire to sweep along.
+ * @param options - Sweep configuration.
+ * @returns Result containing the swept Solid or Shell.
+ */
+export declare function multiSectionSweep(sections: ReadonlyArray<SweepSectionConfig>, spine: Wire, options?: MultiSweepOptions): Result<Solid | Shell>;
+//# sourceMappingURL=multiSweepFns.d.ts.map

package/dist/operations/multiSweepFns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiSweepFns.d.ts","sourceRoot":"","sources":["../../src/operations/multiSweepFns.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAGhE,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,mBAAmB,CAAC;AAGzD,mFAAmF;AACnF,MAAM,WAAW,kBAAkB;IACjC,yCAAyC;IACzC,IAAI,EAAE,IAAI,CAAC;IACX,0FAA0F;IAC1F,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,qDAAqD;AACrD,MAAM,WAAW,iBAAiB;IAChC,iEAAiE;IACjE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,8EAA8E;IAC9E,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,wDAAwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,aAAa,CAAC,kBAAkB,CAAC,EAC3C,KAAK,EAAE,IAAI,EACX,OAAO,CAAC,EAAE,iBAAiB,GAC1B,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC,CAkFvB"}

package/dist/operations/roofFns.d.ts

@@ -0,0 +1,16 @@
+import { Wire, Solid } from '../core/shapeTypes.js';
+import { Result } from '../core/result.js';
+export interface RoofOptions {
+    /** Roof slope angle in degrees (default: 45). */
+    readonly angle?: number;
+}
+/**
+ * Create a roof solid from a planar wire using the straight skeleton algorithm.
+ * Each polygon edge produces a sloped face rising toward the skeleton ridge.
+ *
+ * @param w - A planar wire defining the roof footprint
+ * @param options - Optional angle (degrees) for the roof slope
+ * @returns A Result containing the roof Solid, or an error
+ */
+export declare function roof(w: Wire, options?: RoofOptions): Result<Solid>;
+//# sourceMappingURL=roofFns.d.ts.map

package/dist/operations/roofFns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roofFns.d.ts","sourceRoot":"","sources":["../../src/operations/roofFns.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAGzD,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,mBAAmB,CAAC;AAWzD,MAAM,WAAW,WAAW;IAC1B,iDAAiD;IACjD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAmFD;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,MAAM,CAAC,KAAK,CAAC,CA4HlE"}

package/dist/operations/straightSkeleton.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Pure TypeScript straight skeleton algorithm for simple polygons.
+ * No OCCT dependency — operates on 2D point arrays.
+ */
+export interface SkPoint2D {
+    readonly x: number;
+    readonly y: number;
+}
+export interface SkeletonNode {
+    readonly x: number;
+    readonly y: number;
+    readonly height: number;
+}
+export interface SkeletonFace {
+    readonly vertices: SkPoint2D[];
+    readonly heights: number[];
+}
+export interface StraightSkeleton {
+    readonly nodes: SkeletonNode[];
+    readonly faces: SkeletonFace[];
+}
+/**
+ * Compute the straight skeleton of a simple polygon.
+ * The polygon vertices must define a simple (non-self-intersecting) polygon.
+ * They will be reordered to CCW if necessary.
+ */
+export declare function computeStraightSkeleton(polygon: SkPoint2D[]): StraightSkeleton;
+//# sourceMappingURL=straightSkeleton.d.ts.map

package/dist/operations/straightSkeleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"straightSkeleton.d.ts","sourceRoot":"","sources":["../../src/operations/straightSkeleton.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,QAAQ,EAAE,SAAS,EAAE,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,YAAY,EAAE,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,YAAY,EAAE,CAAC;CAChC;AA+PD;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,SAAS,EAAE,GAAG,gBAAgB,CAiO9E"}

package/dist/{operations-CYGNxn5D.cjs → operations-CdELWxgv.cjs}

@@ -1,11 +1,11 @@
 "use strict";
-const occtBoundary = require("./occtBoundary-BFAaUtA7.cjs");
+const occtBoundary = require("./occtBoundary-DH2VO-rq.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const shapeTypes = require("./shapeTypes-UqVCIO_T.cjs");
-const cast = require("./cast-C107o5ow.cjs");
-const errors = require("./errors-DK1VAdP4.cjs");
-const loft = require("./loft-PMRx9iMG.cjs");
-const booleanFns = require("./booleanFns-Cd414V3l.cjs");
+const shapeTypes = require("./shapeTypes-CMjrTv36.cjs");
+const faceFns = require("./faceFns-DcndPHWm.cjs");
+const errors = require("./errors-eRQu29oc.cjs");
+const loft = require("./loft-BcyyvWCj.cjs");
+const booleanFns = require("./booleanFns-NtKxkiXn.cjs");
 function uuidv() {
   return (String([1e7]) + String(-1e3) + String(-4e3) + String(-8e3) + String(-1e11)).replace(
     /[018]/g,
@@ -117,7 +117,7 @@ function extrude(face, extrusionVec) {
     const vec = r(occtBoundary.toOcVec(extrusionVec));
     const builder = r(new oc.BRepPrimAPI_MakePrism_1(face.wrapped, vec, false, true));
     const shape = builder.Shape();
-    const downcastResult = cast.downcast(shape);
+    const downcastResult = faceFns.downcast(shape);
     if (errors.isErr(downcastResult)) {
       return downcastResult;
     }