brepjs 9.3.9 → 9.4.0

package/dist/2d/blueprints/intersectionSegments.d.ts

@@ -1,5 +1,11 @@
+import { Point2D } from '../lib/index.js';
 import { default as Blueprint } from './Blueprint.js';
 import { IntersectionSegment } from './booleanHelpers.js';
+/**
+ * Check whether a segment's start/end points match one of the common segment
+ * point pairs.
+ */
+export declare function isCommonSegmentMatch(commonSegmentsPoints: Point2D[][], segmentStart: Point2D, segmentEnd: Point2D): boolean;
 /**
  * Given two closed blueprints, find their intersection points, split each
  * blueprint's curves at those points, and pair up the resulting segments.

package/dist/2d/blueprints/intersectionSegments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intersectionSegments.d.ts","sourceRoot":"","sources":["../../../src/2d/blueprints/intersectionSegments.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAY5C,OAAO,KAAK,EAAW,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAgKxE;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,SAAS,GAChB,mBAAmB,EAAE,GAAG,IAAI,CAwE9B"}
+{"version":3,"file":"intersectionSegments.d.ts","sourceRoot":"","sources":["../../../src/2d/blueprints/intersectionSegments.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAW,MAAM,iBAAiB,CAAC;AAGxD,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAY5C,OAAO,KAAK,EAAW,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AA0IxE;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,oBAAoB,EAAE,OAAO,EAAE,EAAE,EACjC,YAAY,EAAE,OAAO,EACrB,UAAU,EAAE,OAAO,GAClB,OAAO,CAQT;AAMD;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,SAAS,GAChB,mBAAmB,EAAE,GAAG,IAAI,CAwE9B"}

package/dist/2d/lib/offset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"offset.d.ts","sourceRoot":"","sources":["../../../src/2d/lib/offset.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAmBhD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,YAAY,GACvB,OAAO,OAAO,EACd,QAAQ,MAAM,KACb,OAAO,GAAG;IAAE,SAAS,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAuEtE,CAAC"}
+{"version":3,"file":"offset.d.ts","sourceRoot":"","sources":["../../../src/2d/lib/offset.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAmBhD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,YAAY,GACvB,OAAO,OAAO,EACd,QAAQ,MAAM,KACb,OAAO,GAAG;IAAE,SAAS,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CA4EtE,CAAC"}

package/dist/2d.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const Blueprint = require("./Blueprint-C_ny87tf.cjs");
-const boolean2D = require("./boolean2D-C_WtQSZM.cjs");
+const Blueprint = require("./Blueprint-CKGR_t7l.cjs");
+const boolean2D = require("./boolean2D-DXpQlTbC.cjs");
 function reverseCurve(curve) {
   const cloned = curve.clone();
   cloned.reverse();

package/dist/2d.js

@@ -1,6 +1,6 @@
-import { B as Blueprint } from "./Blueprint-vLo9HuPx.js";
-import { d, C } from "./Blueprint-vLo9HuPx.js";
-import { e, C as C2, f, l, g, n, k, q, o, p, r } from "./boolean2D-G9wVVewF.js";
+import { B as Blueprint } from "./Blueprint-Bx9F-b3M.js";
+import { d, C } from "./Blueprint-Bx9F-b3M.js";
+import { e, C as C2, f, l, g, n, k, q, o, p, r } from "./boolean2D-iR7ADbYD.js";
 function reverseCurve(curve) {
   const cloned = curve.clone();
   cloned.reverse();

package/dist/{Blueprint-vLo9HuPx.js → Blueprint-Bx9F-b3M.js}

@@ -1,12 +1,12 @@
-import { r as resolvePlane } from "./vectors-CpZfWX0T.js";
+import { r as resolvePlane } from "./vectors-B8RRTytu.js";
 import { a as toVec3 } from "./types-CWDdqcrq.js";
-import { q as getKernel, y as getKernel2D, z as registerForCleanup, A as unregisterFromCleanup, s as createEdge, r as createWire } from "./shapeTypes-d-jYnZuW.js";
-import { u as uvBounds, f as faceGeomType, e as faceCenter, h as uvCoordinates, c as cast } from "./faceFns-DKAs23b7.js";
-import { g as getOrientation } from "./curveFns-B7b2uHRl.js";
-import { o as ok, e as err, b as computationError, u as unwrap, x as validationError } from "./errors-C_XjfNt5.js";
-import { d as distance2d, s as samePoint, b as scalarMultiply2d, c as add2d, n as normalize2d, e as subtract2d, g as getSingleFace } from "./helpers-BidbwB1g.js";
+import { q as getKernel, y as getKernel2D, z as registerForCleanup, A as unregisterFromCleanup, s as createEdge, r as createWire } from "./shapeTypes-Dh_qy0wO.js";
+import { u as uvBounds, f as faceGeomType, e as faceCenter, h as uvCoordinates, c as cast } from "./faceFns-BkJ2_drH.js";
+import { g as getOrientation } from "./curveFns-DimdPJLf.js";
+import { o as ok, e as err, b as computationError, u as unwrap, x as validationError } from "./errors-lBwyc8YG.js";
+import { d as distance2d, s as samePoint, b as scalarMultiply2d, c as add2d, n as normalize2d, e as subtract2d, g as getSingleFace } from "./helpers-nNbxhw97.js";
 import { R as RAD2DEG, D as DEG2RAD } from "./vecOps-ZDdZWbwT.js";
-import { m as makeFace } from "./surfaceBuilders-BX-btdhW.js";
+import { m as makeFace } from "./surfaceBuilders-CX69g8_x.js";
 import { bug } from "./result.js";
 function makePlane(plane, origin) {
   if (plane && typeof plane !== "string") {

package/dist/{Blueprint-C_ny87tf.cjs → Blueprint-CKGR_t7l.cjs}

@@ -1,13 +1,13 @@
 "use strict";
-const vectors = require("./vectors-BwRTfFd1.cjs");
+const vectors = require("./vectors-DqQXtR8s.cjs");
 const types = require("./types-CA_xrgDq.cjs");
-const shapeTypes = require("./shapeTypes-CBhj5o2y.cjs");
-const faceFns = require("./faceFns-A6VJdsJc.cjs");
-const curveFns = require("./curveFns-BsxQJoWM.cjs");
-const errors = require("./errors-HU7EpHt3.cjs");
-const helpers = require("./helpers-C-dHgprx.cjs");
+const shapeTypes = require("./shapeTypes-DGDFzV7k.cjs");
+const faceFns = require("./faceFns-BxkKVWoi.cjs");
+const curveFns = require("./curveFns-NHndvCbT.cjs");
+const errors = require("./errors-DiTn5EoC.cjs");
+const helpers = require("./helpers-BlW0S8kc.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const surfaceBuilders = require("./surfaceBuilders-DwMD54OR.cjs");
+const surfaceBuilders = require("./surfaceBuilders-BQScH37x.cjs");
 const result = require("./result.cjs");
 function makePlane(plane, origin) {
   if (plane && typeof plane !== "string") {

package/dist/{boolean2D-C_WtQSZM.cjs → boolean2D-DXpQlTbC.cjs}

@@ -44,18 +44,18 @@ var __callDispose = (stack, error, hasError) => {
   };
   return next();
 };
-const vectors = require("./vectors-BwRTfFd1.cjs");
-const errors = require("./errors-HU7EpHt3.cjs");
-const faceFns = require("./faceFns-A6VJdsJc.cjs");
+const vectors = require("./vectors-DqQXtR8s.cjs");
+const errors = require("./errors-DiTn5EoC.cjs");
+const faceFns = require("./faceFns-BxkKVWoi.cjs");
 const types = require("./types-CA_xrgDq.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const loft = require("./loft-B0VRwdIS.cjs");
-const shapeTypes = require("./shapeTypes-CBhj5o2y.cjs");
-const curveFns = require("./curveFns-BsxQJoWM.cjs");
-const surfaceBuilders = require("./surfaceBuilders-DwMD54OR.cjs");
+const loft = require("./loft-CvTRTIDd.cjs");
+const shapeTypes = require("./shapeTypes-DGDFzV7k.cjs");
+const curveFns = require("./curveFns-NHndvCbT.cjs");
+const surfaceBuilders = require("./surfaceBuilders-BQScH37x.cjs");
 const result = require("./result.cjs");
-const helpers = require("./helpers-C-dHgprx.cjs");
-const Blueprint = require("./Blueprint-C_ny87tf.cjs");
+const helpers = require("./helpers-BlW0S8kc.cjs");
+const Blueprint = require("./Blueprint-CKGR_t7l.cjs");
 const intersectCurves = (first, second, precision = 1e-9) => {
   if (first.boundingBox.isOut(second.boundingBox))
     return errors.ok({ intersections: [], commonSegments: [], commonSegmentsPoints: [] });
@@ -1974,7 +1974,7 @@ function splitCurvesAtIntersections(curves, curvePoints) {
 function isCommonSegmentMatch(commonSegmentsPoints, segmentStart, segmentEnd) {
   return commonSegmentsPoints.some(([startPoint, endPoint]) => {
     if (startPoint === void 0 || endPoint === void 0) return false;
-    return samePoint(startPoint, segmentStart) && samePoint(endPoint, segmentEnd) || samePoint(startPoint, segmentEnd) && samePoint(startPoint, segmentStart);
+    return samePoint(startPoint, segmentStart) && samePoint(endPoint, segmentEnd) || samePoint(startPoint, segmentEnd) && samePoint(endPoint, segmentStart);
   });
 }
 function blueprintsIntersectionSegments(first, second) {

package/dist/{boolean2D-G9wVVewF.js → boolean2D-iR7ADbYD.js}

@@ -43,18 +43,18 @@ var __callDispose = (stack, error, hasError) => {
   };
   return next();
 };
-import { a as createPlane } from "./vectors-CpZfWX0T.js";
-import { o as ok, e as err, b as computationError, u as unwrap, g as isOk } from "./errors-C_XjfNt5.js";
-import { d as downcast, u as uvBounds, p as pointOnSurface, n as normalAt } from "./faceFns-DKAs23b7.js";
+import { a as createPlane } from "./vectors-B8RRTytu.js";
+import { o as ok, e as err, b as computationError, u as unwrap, g as isOk } from "./errors-lBwyc8YG.js";
+import { d as downcast, u as uvBounds, p as pointOnSurface, n as normalAt } from "./faceFns-BkJ2_drH.js";
 import { a as toVec3 } from "./types-CWDdqcrq.js";
 import { n as vecScale, j as vecNormalize, b as vecCross, D as DEG2RAD, R as RAD2DEG } from "./vecOps-ZDdZWbwT.js";
-import { r as revolution, c as complexExtrude, t as twistExtrude, b as basicFaceExtrusion, g as genericSweep, l as loft } from "./loft-BI8MUcCF.js";
-import { y as getKernel2D, t as createFace, r as createWire, q as getKernel, s as createEdge, D as DisposalScope } from "./shapeTypes-d-jYnZuW.js";
-import { d as curveStartPoint, c as curveTangentAt, e as curveIsClosed } from "./curveFns-B7b2uHRl.js";
-import { m as makeFace, l as makeNewFaceWithinFace, b as assembleWire, z as zip } from "./surfaceBuilders-BX-btdhW.js";
+import { r as revolution, c as complexExtrude, t as twistExtrude, b as basicFaceExtrusion, g as genericSweep, l as loft } from "./loft-C8yS_NS6.js";
+import { y as getKernel2D, t as createFace, r as createWire, q as getKernel, s as createEdge, D as DisposalScope } from "./shapeTypes-Dh_qy0wO.js";
+import { d as curveStartPoint, c as curveTangentAt, e as curveIsClosed } from "./curveFns-DimdPJLf.js";
+import { m as makeFace, l as makeNewFaceWithinFace, b as assembleWire, z as zip } from "./surfaceBuilders-CX69g8_x.js";
 import { bug } from "./result.js";
-import { s as samePoint$1, n as normalize2d, e as subtract2d, c as add2d, i as crossProduct2d, b as scalarMultiply2d, f as polarToCartesian, r as rotate2d, j as cartesianToPolar, d as distance2d, p as polarAngle2d, k as PRECISION_INTERSECTION } from "./helpers-BidbwB1g.js";
-import { C as Curve2D, a as make2dSegmentCurve, j as approximateAsBSpline, b as make2dArcFromCenter, k as isPoint2D, g as make2dCircle, l as make2dThreePointArc, d as BoundingBox2d, v as viewbox, n as asSVG, B as Blueprint, o as make2dEllipseArc, p as make2dTangentArc, q as make2dBezierCurve, r as removeDuplicatePoints } from "./Blueprint-vLo9HuPx.js";
+import { s as samePoint$1, n as normalize2d, e as subtract2d, c as add2d, i as crossProduct2d, b as scalarMultiply2d, f as polarToCartesian, r as rotate2d, j as cartesianToPolar, d as distance2d, p as polarAngle2d, k as PRECISION_INTERSECTION } from "./helpers-nNbxhw97.js";
+import { C as Curve2D, a as make2dSegmentCurve, j as approximateAsBSpline, b as make2dArcFromCenter, k as isPoint2D, g as make2dCircle, l as make2dThreePointArc, d as BoundingBox2d, v as viewbox, n as asSVG, B as Blueprint, o as make2dEllipseArc, p as make2dTangentArc, q as make2dBezierCurve, r as removeDuplicatePoints } from "./Blueprint-Bx9F-b3M.js";
 const intersectCurves = (first, second, precision = 1e-9) => {
   if (first.boundingBox.isOut(second.boundingBox))
     return ok({ intersections: [], commonSegments: [], commonSegmentsPoints: [] });
@@ -1973,7 +1973,7 @@ function splitCurvesAtIntersections(curves, curvePoints) {
 function isCommonSegmentMatch(commonSegmentsPoints, segmentStart, segmentEnd) {
   return commonSegmentsPoints.some(([startPoint, endPoint]) => {
     if (startPoint === void 0 || endPoint === void 0) return false;
-    return samePoint(startPoint, segmentStart) && samePoint(endPoint, segmentEnd) || samePoint(startPoint, segmentEnd) && samePoint(startPoint, segmentStart);
+    return samePoint(startPoint, segmentStart) && samePoint(endPoint, segmentEnd) || samePoint(startPoint, segmentEnd) && samePoint(endPoint, segmentStart);
   });
 }
 function blueprintsIntersectionSegments(first, second) {

package/dist/{booleanFns-gwskRu9F.js → booleanFns-7rIed0u7.js}

@@ -1,9 +1,9 @@
-import { q as getKernel, c as castShape, j as isShape3D } from "./shapeTypes-d-jYnZuW.js";
-import { o as ok, d as isErr, e as err, x as validationError, B as BrepErrorCode, p as typeCastError, k as kernelError } from "./errors-C_XjfNt5.js";
-import { r as resolvePlane } from "./vectors-CpZfWX0T.js";
+import { q as getKernel, c as castShape, j as isShape3D } from "./shapeTypes-Dh_qy0wO.js";
+import { o as ok, d as isErr, e as err, x as validationError, B as BrepErrorCode, p as typeCastError, k as kernelError } from "./errors-lBwyc8YG.js";
+import { r as resolvePlane } from "./vectors-B8RRTytu.js";
 import { H as HASH_CODE_MAX, n as vecScale, v as vecAdd } from "./vecOps-ZDdZWbwT.js";
-import { a as getFaces, p as propagateOriginsFromEvolution, b as propagateOriginsByHash, g as getFaceOrigins, c as getWires, d as getEdges, e as getVertices } from "./shapeFns-D9CKkCnS.js";
-import { m as makeFace } from "./surfaceBuilders-BX-btdhW.js";
+import { a as getFaces, p as propagateOriginsFromEvolution, b as propagateOriginsByHash, g as getFaceOrigins, c as getWires, d as getEdges, e as getVertices } from "./shapeFns-BO9NK6Oo.js";
+import { m as makeFace } from "./surfaceBuilders-CX69g8_x.js";
 const shapeTagStore = /* @__PURE__ */ new WeakMap();
 const tagMetadataStore = /* @__PURE__ */ new WeakMap();
 function hasFaceTags(shape) {

package/dist/{booleanFns-G0j8iAZV.cjs → booleanFns-Bv06tE2O.cjs}

@@ -1,10 +1,10 @@
 "use strict";
-const shapeTypes = require("./shapeTypes-CBhj5o2y.cjs");
-const errors = require("./errors-HU7EpHt3.cjs");
-const vectors = require("./vectors-BwRTfFd1.cjs");
+const shapeTypes = require("./shapeTypes-DGDFzV7k.cjs");
+const errors = require("./errors-DiTn5EoC.cjs");
+const vectors = require("./vectors-DqQXtR8s.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const shapeFns = require("./shapeFns-O9Ont1Dy.cjs");
-const surfaceBuilders = require("./surfaceBuilders-DwMD54OR.cjs");
+const shapeFns = require("./shapeFns-DdBZDjVs.cjs");
+const surfaceBuilders = require("./surfaceBuilders-BQScH37x.cjs");
 const shapeTagStore = /* @__PURE__ */ new WeakMap();
 const tagMetadataStore = /* @__PURE__ */ new WeakMap();
 function hasFaceTags(shape) {

package/dist/brepjs.cjs

@@ -45,30 +45,30 @@ var __callDispose = (stack, error, hasError) => {
   return next();
 };
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const shapeTypes = require("./shapeTypes-CBhj5o2y.cjs");
-const errors = require("./errors-HU7EpHt3.cjs");
+const shapeTypes = require("./shapeTypes-DGDFzV7k.cjs");
+const errors = require("./errors-DiTn5EoC.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const Blueprint = require("./Blueprint-C_ny87tf.cjs");
-const loft$2 = require("./loft-B0VRwdIS.cjs");
-const operations = require("./operations-B1FSxszL.cjs");
-const boolean2D = require("./boolean2D-C_WtQSZM.cjs");
+const Blueprint = require("./Blueprint-CKGR_t7l.cjs");
+const loft$2 = require("./loft-CvTRTIDd.cjs");
+const operations = require("./operations-JLacBa4V.cjs");
+const boolean2D = require("./boolean2D-DXpQlTbC.cjs");
 const _2d = require("./2d.cjs");
-const helpers = require("./helpers-C-dHgprx.cjs");
+const helpers = require("./helpers-BlW0S8kc.cjs");
 const io = require("./io.cjs");
-const drawFns = require("./drawFns-BIoGsiXr.cjs");
+const drawFns = require("./drawFns-BBaIUkX4.cjs");
 const types = require("./types-CA_xrgDq.cjs");
-const vectors = require("./vectors-BwRTfFd1.cjs");
-const shapeFns = require("./shapeFns-O9Ont1Dy.cjs");
-const booleanFns = require("./booleanFns-G0j8iAZV.cjs");
-const topology = require("./topology-ChR-we6s.cjs");
-const curveFns = require("./curveFns-BsxQJoWM.cjs");
-const faceFns = require("./faceFns-A6VJdsJc.cjs");
-const meshFns = require("./meshFns-ClCp7nft.cjs");
-const measurement = require("./measurement-D5XQSvln.cjs");
-const surfaceBuilders = require("./surfaceBuilders-DwMD54OR.cjs");
+const vectors = require("./vectors-DqQXtR8s.cjs");
+const shapeFns = require("./shapeFns-DdBZDjVs.cjs");
+const booleanFns = require("./booleanFns-Bv06tE2O.cjs");
+const topology = require("./topology-In3-XjPz.cjs");
+const curveFns = require("./curveFns-NHndvCbT.cjs");
+const faceFns = require("./faceFns-BxkKVWoi.cjs");
+const meshFns = require("./meshFns-Bl6gXIPd.cjs");
+const measurement = require("./measurement-mWRWDA69.cjs");
+const surfaceBuilders = require("./surfaceBuilders-BQScH37x.cjs");
 const query = require("./query.cjs");
 const result = require("./result.cjs");
-const cornerFinder = require("./cornerFinder-56x6NzUP.cjs");
+const cornerFinder = require("./cornerFinder-Ci8VuZvA.cjs");
 const worker = require("./worker.cjs");
 function supportsProjection(kernel) {
   return "projectShape" in kernel;
@@ -659,7 +659,30 @@ function multiSectionSweep(sections, spine, options) {
       )
     );
   }
-  const { solid: solid2 = true, ruled = false, tolerance: _tolerance = 1e-6 } = options ?? {};
+  const { solid: solid2 = true, ruled = false, tolerance = 1e-6 } = options ?? {};
+  const explicitLocations = sections.map((s) => s.location);
+  for (let i = 0; i < explicitLocations.length; i++) {
+    const loc = explicitLocations[i];
+    if (loc !== void 0 && (loc < 0 || loc > 1)) {
+      return errors.err(
+        errors.validationError(
+          errors.BrepErrorCode.MULTI_SWEEP_FAILED,
+          `Section ${i} location ${loc} is out of range [0, 1]`
+        )
+      );
+    }
+  }
+  const definedLocs = explicitLocations.filter((l) => l !== void 0);
+  for (let i = 1; i < definedLocs.length; i++) {
+    if ((definedLocs[i] ?? 0) <= (definedLocs[i - 1] ?? 0)) {
+      return errors.err(
+        errors.validationError(
+          errors.BrepErrorCode.MULTI_SWEEP_FAILED,
+          "Section locations must be strictly increasing"
+        )
+      );
+    }
+  }
   try {
     const kernel = shapeTypes.getKernel();
     const [uFirst, uLast] = kernel.curveParameters(spine.wrapped);
@@ -678,7 +701,7 @@ function multiSectionSweep(sections, spine, options) {
       const positioned = kernel.positionOnCurve(section2.wire.wrapped, spine.wrapped, param);
       positionedWires.push(kernel.downcast(positioned, "wire"));
     }
-    const loftResult = kernel.loftAdvanced(positionedWires, { solid: solid2, ruled });
+    const loftResult = kernel.loftAdvanced(positionedWires, { solid: solid2, ruled, tolerance });
     const result2 = shapeTypes.castShape(loftResult);
     if (!shapeTypes.isShape3D(result2)) {
       return errors.err(
@@ -1082,6 +1105,66 @@ function fanTriangulate(count) {
   }
   return tris;
 }
+function cross2d(ax, ay, bx, by, cx, cy) {
+  return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
+}
+function pointInTriangle(px, py, ax, ay, bx, by, cx, cy) {
+  const d1 = cross2d(ax, ay, bx, by, px, py);
+  const d2 = cross2d(bx, by, cx, cy, px, py);
+  const d3 = cross2d(cx, cy, ax, ay, px, py);
+  const hasNeg = d1 < 0 || d2 < 0 || d3 < 0;
+  const hasPos = d1 > 0 || d2 > 0 || d3 > 0;
+  return !(hasNeg && hasPos);
+}
+function earClipTriangulate(poly) {
+  const n = poly.length;
+  if (n < 3) return [];
+  if (n === 3) return [[0, 1, 2]];
+  let area2 = 0;
+  for (let i = 0; i < n; i++) {
+    const a = poly[i];
+    const b = poly[(i + 1) % n];
+    if (a && b) area2 += a.x * b.y - b.x * a.y;
+  }
+  const tris = [];
+  const idx = Array.from({ length: n }, (_, i) => i);
+  if (area2 < 0) idx.reverse();
+  const isEar = (prev, curr, next) => {
+    const a = poly[prev];
+    const b = poly[curr];
+    const c = poly[next];
+    if (!a || !b || !c) return false;
+    if (cross2d(a.x, a.y, b.x, b.y, c.x, c.y) <= 0) return false;
+    for (const vi of idx) {
+      if (vi === prev || vi === curr || vi === next) continue;
+      const p = poly[vi];
+      if (!p) continue;
+      if (pointInTriangle(p.x, p.y, a.x, a.y, b.x, b.y, c.x, c.y)) return false;
+    }
+    return true;
+  };
+  while (idx.length > 3) {
+    let clipped = false;
+    for (let i = 0; i < idx.length; i++) {
+      const prev = idx[(i - 1 + idx.length) % idx.length];
+      const curr = idx[i];
+      const next = idx[(i + 1) % idx.length];
+      if (prev === void 0 || curr === void 0 || next === void 0) continue;
+      if (isEar(prev, curr, next)) {
+        tris.push([prev, curr, next]);
+        idx.splice(i, 1);
+        clipped = true;
+        break;
+      }
+    }
+    if (!clipped) break;
+  }
+  if (idx.length === 3) {
+    const [a, b, c] = idx;
+    if (a !== void 0 && b !== void 0 && c !== void 0) tris.push([a, b, c]);
+  }
+  return tris;
+}
 function roof(w, options) {
   const angle = (options?.angle ?? 45) * (Math.PI / 180);
   const tanAngle = Math.tan(angle);
@@ -1134,19 +1217,17 @@ function roof(w, options) {
         }
       }
     }
-    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 = kernel.buildTriFace(va, vc, vb);
-        if (triFace !== null) {
-          triFaces.push(triFace);
-        }
+    for (const [ai, bi, ci] of earClipTriangulate(polygon2)) {
+      const pa = polygon2[ai];
+      const pb = polygon2[bi];
+      const pc = polygon2[ci];
+      if (!pa || !pb || !pc) continue;
+      const va = [pa.x, pa.y, 0];
+      const vb = [pb.x, pb.y, 0];
+      const vc = [pc.x, pc.y, 0];
+      const triFace = kernel.buildTriFace(va, vc, vb);
+      if (triFace !== null) {
+        triFaces.push(triFace);
       }
     }
     if (triFaces.length === 0) {
@@ -1170,6 +1251,12 @@ function roof(w, options) {
     return errors.err(errors.kernelError(errors.BrepErrorCode.ROOF_FAILED, `Roof generation failed: ${msg}`, e));
   }
 }
+const UNSUPPORTED_DOF = {
+  coincident: 3,
+  concentric: 4,
+  distance: 1,
+  angle: 1
+};
 function solveConstraints(nodes, constraints) {
   const transforms = /* @__PURE__ */ new Map();
   for (const node of nodes) {
@@ -1178,6 +1265,7 @@ function solveConstraints(nodes, constraints) {
       rotation: [1, 0, 0, 0]
     });
   }
+  const unsupported = [];
   for (const c of constraints) {
     if (c.type === "coincident" && c.entityA && c.entityB) {
       const a = c.entityA;
@@ -1189,9 +1277,10 @@ function solveConstraints(nodes, constraints) {
         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] });
+      } else {
+        unsupported.push(`coincident(${a.entity.type}-${b.entity.type})`);
       }
-    }
-    if (c.type === "distance" && c.entityA && c.entityB && c.value !== void 0) {
+    } else 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") {
@@ -1202,10 +1291,18 @@ function solveConstraints(nodes, constraints) {
         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] });
+      } else {
+        unsupported.push(`distance(${a.entity.type}-${b.entity.type})`);
       }
+    } else if (c.type === "concentric" || c.type === "angle") {
+      unsupported.push(c.type);
     }
   }
-  return { transforms, dof: 0, converged: true };
+  const dof = unsupported.reduce((sum, type) => {
+    const baseDof = UNSUPPORTED_DOF[type] ?? UNSUPPORTED_DOF[type.split("(")[0] ?? ""] ?? 0;
+    return sum + baseDof;
+  }, 0);
+  return { transforms, dof, converged: unsupported.length === 0, unsupported };
 }
 function extractEntity(mate) {
   if (mate.face) {
@@ -1218,6 +1315,22 @@ function extractEntity(mate) {
   }
   return null;
 }
+function extractPair(a, b) {
+  const entA = extractEntity(a);
+  const entB = extractEntity(b);
+  if (!entA || !entB) {
+    return errors.err(
+      errors.validationError(
+        errors.BrepErrorCode.ASSEMBLY_MATE_INVALID,
+        "solveAssembly: could not extract geometry from mate entities"
+      )
+    );
+  }
+  return errors.ok({
+    entityA: { node: a.node, entity: entA },
+    entityB: { node: b.node, entity: entB }
+  });
+}
 function addMate(assembly, constraint) {
   const existing = assembly.mates ?? [];
   return { ...assembly, mates: [...existing, constraint] };
@@ -1244,78 +1357,28 @@ function solveAssembly(assembly) {
         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 pair = extractPair(mate.entityA, mate.entityB);
+        if (!pair.ok) return pair;
+        solverConstraints.push({ type: "coincident", ...pair.value });
+      } else if (mate.type === "distance") {
+        const pair = extractPair(mate.entityA, mate.entityB);
+        if (!pair.ok) return pair;
+        solverConstraints.push({ type: "distance", ...pair.value, value: mate.distance });
+      } else if (mate.type === "angle") {
+        const pair = extractPair(mate.entityA, mate.entityB);
+        if (!pair.ok) return pair;
+        solverConstraints.push({ type: "angle", ...pair.value, value: mate.angle });
+      } else {
+        const pair = extractPair(mate.axisA, mate.axisB);
+        if (!pair.ok) return pair;
+        solverConstraints.push({ type: "concentric", ...pair.value });
       }
     }
     const result2 = solveConstraints(nodes, solverConstraints);
-    if (!result2.converged) ;
+    if (!result2.converged) {
+      const detail = result2.unsupported.length > 0 ? `Unsupported constraint types: ${result2.unsupported.join(", ")} (${result2.dof} DOF unresolved)` : "Assembly constraint solver did not converge";
+      return errors.err(errors.kernelError(errors.BrepErrorCode.ASSEMBLY_NOT_CONVERGED, detail));
+    }
     return errors.ok({
       transforms: result2.transforms,
       dof: result2.dof,
@@ -2284,7 +2347,7 @@ function isValid(shape2) {
 function isEmpty(shape2) {
   return shapeFns.isEmpty(resolve(shape2));
 }
-function loft$1(wires, { ruled = true, startPoint, endPoint, tolerance: _tolerance = 1e-6 } = {}, returnShell = false) {
+function loft$1(wires, { ruled = true, startPoint, endPoint, tolerance = 1e-6 } = {}, returnShell = false) {
   if (wires.length === 0 && !startPoint && !endPoint) {
     return errors.err(errors.validationError("LOFT_EMPTY", "Loft requires at least one wire or start/end point"));
   }
@@ -2297,6 +2360,7 @@ function loft$1(wires, { ruled = true, startPoint, endPoint, tolerance: _toleran
       {
         solid: !returnShell,
         ruled,
+        tolerance,
         ...startVertex ? { startVertex } : {},
         ...endVertex ? { endVertex } : {}
       }
@@ -2664,11 +2728,13 @@ exports.withScopeResult = shapeTypes.withScopeResult;
 exports.withScopeResultAsync = shapeTypes.withScopeResultAsync;
 exports.BrepErrorCode = errors.BrepErrorCode;
 exports.OK = errors.OK;
+exports.all = errors.all;
 exports.andThen = errors.andThen;
 exports.collect = errors.collect;
 exports.computationError = errors.computationError;
 exports.err = errors.err;
 exports.flatMap = errors.flatMap;
+exports.fromNullable = errors.fromNullable;
 exports.ioError = errors.ioError;
 exports.isErr = errors.isErr;
 exports.isOk = errors.isOk;
@@ -2678,9 +2744,13 @@ exports.mapErr = errors.mapErr;
 exports.match = errors.match;
 exports.moduleInitError = errors.moduleInitError;
 exports.ok = errors.ok;
+exports.or = errors.or;
+exports.orElse = errors.orElse;
 exports.pipeline = errors.pipeline;
 exports.queryError = errors.queryError;
 exports.sketcherStateError = errors.sketcherStateError;
+exports.tap = errors.tap;
+exports.tapErr = errors.tapErr;
 exports.tryCatch = errors.tryCatch;
 exports.tryCatchAsync = errors.tryCatchAsync;
 exports.typeCastError = errors.typeCastError;
@@ -2689,6 +2759,7 @@ exports.unwrapErr = errors.unwrapErr;
 exports.unwrapOr = errors.unwrapOr;
 exports.unwrapOrElse = errors.unwrapOrElse;
 exports.validationError = errors.validationError;
+exports.zipResults = errors.zip;
 exports.DEG2RAD = vecOps.DEG2RAD;
 exports.HASH_CODE_MAX = vecOps.HASH_CODE_MAX;
 exports.RAD2DEG = vecOps.RAD2DEG;
@@ -2725,6 +2796,7 @@ exports.createAssembly = operations.createAssembly;
 exports.createAssemblyNode = operations.createAssemblyNode;
 exports.createHistory = operations.createHistory;
 exports.createRegistry = operations.createRegistry;
+exports.deserializeHistory = operations.deserializeHistory;
 exports.exportAssemblySTEP = operations.exportAssemblySTEP;
 exports.findNode = operations.findNode;
 exports.findStep = operations.findStep;
@@ -2736,6 +2808,7 @@ exports.registerShape = operations.registerShape;
 exports.removeChild = operations.removeChild;
 exports.replayFrom = operations.replayFrom;
 exports.replayHistory = operations.replayHistory;
+exports.serializeHistory = operations.serializeHistory;
 exports.stepCount = operations.stepCount;
 exports.stepsFrom = operations.stepsFrom;
 exports.supportExtrude = operations.supportExtrude;