brepjs 20.12.4 → 20.12.6

package/dist/{healingFns-CYLIcIWv.cjs → healingFns-DWljGTNR.cjs}

@@ -1,10 +1,10 @@
-const require_shapeTypes = require("./shapeTypes-DJT3SnGK.cjs");
-const require_occtWasmAdapter = require("./occtWasmAdapter-CRd9RFEu.cjs");
+const require_shapeTypes = require("./shapeTypes-Dc7j-MYg.cjs");
+const require_occtWasmAdapter = require("./occtWasmAdapter-DVxLkjlJ.cjs");
 const require_errors = require("./errors-O_blYTWT.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-xh11vEQw.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-5Frx8Y-0.cjs");
 const require_constants = require("./constants-oee0S_x6.cjs");
-const require_faceFns = require("./faceFns-BjmlYcc9.cjs");
-const require_solidBuilders = require("./solidBuilders-BWbqhbyv.cjs");
+const require_faceFns = require("./faceFns-B7MiDYj1.cjs");
+const require_solidBuilders = require("./solidBuilders-iS5DDwg8.cjs");
 const require_arrayAccess = require("./arrayAccess-DpJYARwv.cjs");
 // src/topology/threeHelpers.ts
 /**

package/dist/{helpers-BQ6XMFcm.js → helpers-D2hANLRu.js}

@@ -1,12 +1,12 @@
-import { q as getKernel, y as isFace } from "./shapeTypes-DAz6aAnJ.js";
+import { q as getKernel, y as isFace } from "./shapeTypes-DwvQUp9M.js";
 import { E as ok, g as err, o as queryError, x as isOk } from "./errors-BTccWbtE.js";
-import { c as getFaces, f as getVertices, p as getWires, s as getEdges } from "./topologyQueryFns-BfYdGOJc.js";
+import { c as getFaces, f as getVertices, p as getWires, s as getEdges } from "./topologyQueryFns-LXV1nTaS.js";
 import { t as DEG2RAD } from "./constants-iraOnb2p.js";
 import { a as vecDot, d as vecNormalize } from "./vecOps-S-m9H_fe.js";
-import { l as normalAt, s as getSurfaceType } from "./faceFns-7eHqNM0P.js";
-import { a as isSameShape, n as getHashCode } from "./shapeFns-BCgegapL.js";
-import { f as getCurveType, i as curveIsClosed, o as curveLength } from "./curveFns-B4308HNM.js";
-import { n as measureArea } from "./measureFns-1IfNe629.js";
+import { l as normalAt, s as getSurfaceType } from "./faceFns-iVPbTxki.js";
+import { a as isSameShape, n as getHashCode } from "./shapeFns-CgqKICF_.js";
+import { f as getCurveType, i as curveIsClosed, o as curveLength } from "./curveFns-BP3srCfK.js";
+import { n as measureArea } from "./measureFns-mxBdPiWa.js";
 // src/utils/vec2d.ts
 /** Precision for curve intersection and parameter operations. */
 var PRECISION_INTERSECTION = 1e-9;
@@ -216,11 +216,15 @@ function resolveDir(dir) {
 * with a vertex constructed at the reference point.
 */
 function distanceFromPointFilter(distance, point, tolerance) {
-	const kernel = getKernel();
-	const vtx = kernel.makeVertex(point[0], point[1], point[2]);
 	return (element) => {
-		const d = kernel.distance(vtx, element.wrapped).value;
-		return Math.abs(d - distance) < tolerance;
+		const kernel = getKernel();
+		const vtx = kernel.makeVertex(point[0], point[1], point[2]);
+		try {
+			const d = kernel.distance(vtx, element.wrapped).value;
+			return Math.abs(d - distance) < tolerance;
+		} finally {
+			kernel.dispose(vtx);
+		}
 	};
 }
 // src/query/shapeFinders.ts

package/dist/{helpers-De0Z_6iV.cjs → helpers-DKEVm6Hu.cjs}

@@ -1,12 +1,12 @@
-const require_shapeTypes = require("./shapeTypes-DJT3SnGK.cjs");
+const require_shapeTypes = require("./shapeTypes-Dc7j-MYg.cjs");
 const require_errors = require("./errors-O_blYTWT.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-xh11vEQw.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-5Frx8Y-0.cjs");
 const require_constants = require("./constants-oee0S_x6.cjs");
 const require_vecOps = require("./vecOps-CrGEPPQM.cjs");
-const require_faceFns = require("./faceFns-BjmlYcc9.cjs");
-const require_shapeFns = require("./shapeFns-BbXqiNqY.cjs");
-const require_curveFns = require("./curveFns-8lUhNquZ.cjs");
-const require_measureFns = require("./measureFns-Ce01LVwq.cjs");
+const require_faceFns = require("./faceFns-B7MiDYj1.cjs");
+const require_shapeFns = require("./shapeFns-C0w8vvfb.cjs");
+const require_curveFns = require("./curveFns-CyIvQNYT.cjs");
+const require_measureFns = require("./measureFns-CZHNWkiA.cjs");
 // src/utils/vec2d.ts
 /** Precision for curve intersection and parameter operations. */
 var PRECISION_INTERSECTION = 1e-9;
@@ -216,11 +216,15 @@ function resolveDir(dir) {
 * with a vertex constructed at the reference point.
 */
 function distanceFromPointFilter(distance, point, tolerance) {
-	const kernel = require_shapeTypes.getKernel();
-	const vtx = kernel.makeVertex(point[0], point[1], point[2]);
 	return (element) => {
-		const d = kernel.distance(vtx, element.wrapped).value;
-		return Math.abs(d - distance) < tolerance;
+		const kernel = require_shapeTypes.getKernel();
+		const vtx = kernel.makeVertex(point[0], point[1], point[2]);
+		try {
+			const d = kernel.distance(vtx, element.wrapped).value;
+			return Math.abs(d - distance) < tolerance;
+		} finally {
+			kernel.dispose(vtx);
+		}
 	};
 }
 // src/query/shapeFinders.ts

package/dist/{importFns-BCL4-H8e.js → importFns-DUzIkns7.js}

@@ -1,8 +1,8 @@
-import { n as castResultShape, q as getKernel } from "./shapeTypes-DAz6aAnJ.js";
+import { n as castResultShape, q as getKernel } from "./shapeTypes-DwvQUp9M.js";
 import { i as wasmIndex, r as vec3At$1 } from "./bug-ClMTAJhe.js";
 import { E as ok, g as err, r as ioError, t as BrepErrorCode } from "./errors-BTccWbtE.js";
 import { n as getAtOrThrow } from "./arrayAccess-BpgouNir.js";
-import { c as make2dBezierCurve, h as make2dThreePointArc, p as make2dSegmentCurve, t as Blueprint } from "./blueprint-DFpjcrlm.js";
+import { c as make2dBezierCurve, h as make2dThreePointArc, p as make2dSegmentCurve, t as Blueprint } from "./blueprint-BhIk9Pvm.js";
 // src/io/objExportFns.ts
 /** Read a vec3 from a typed array at the given vertex index. */
 function vec3At(arr, i) {

package/dist/{importFns-3IMBHQrQ.cjs → importFns-KEPAgbjj.cjs}

@@ -1,8 +1,8 @@
-const require_shapeTypes = require("./shapeTypes-DJT3SnGK.cjs");
+const require_shapeTypes = require("./shapeTypes-Dc7j-MYg.cjs");
 const require_bug = require("./bug-CBcpIPuf.cjs");
 const require_errors = require("./errors-O_blYTWT.cjs");
 const require_arrayAccess = require("./arrayAccess-DpJYARwv.cjs");
-const require_blueprint = require("./blueprint-D0VEeTzJ.cjs");
+const require_blueprint = require("./blueprint-D83DDDPb.cjs");
 // src/io/objExportFns.ts
 /** Read a vec3 from a typed array at the given vertex index. */
 function vec3At(arr, i) {

package/dist/index.d.ts

@@ -6,7 +6,7 @@ export { currentQuality } from './kernel/quality.js';
 export type { QualityLevel } from './kernel/quality.js';
 export { EXACT_BREP_CAPABILITIES, DEFAULT_CAPABILITIES } from './kernel/capabilities.js';
 export type { KernelCapabilities, TessellationModel } from './kernel/capabilities.js';
-export type { KernelAdapter, BrepkitHandle, OcctWasmHandle, OcctWasmModule, OcctKernelWasm, SurfaceType, ShapeOrientation, ShapeType, KernelBooleanOps, KernelBuilderOps, KernelCore, KernelCurveOps, KernelEvolutionOps, KernelIOOps, KernelMeasureOps, KernelMeshOps, KernelModifierOps, KernelPrimitiveOps, KernelRepairOps, KernelSurfaceOps, KernelSweepOps, KernelTopologyOps, KernelTransformOps, } from './kernel/index.js';
+export type { KernelAdapter, BrepkitHandle, OcctWasmHandle, OcctWasmModule, OcctKernelWasm, SurfaceType as KernelSurfaceType, ShapeOrientation, ShapeType, KernelBooleanOps, KernelBuilderOps, KernelCore, KernelCurveOps, KernelEvolutionOps, KernelIOOps, KernelMeasureOps, KernelMeshOps, KernelModifierOps, KernelPrimitiveOps, KernelRepairOps, KernelSurfaceOps, KernelSweepOps, KernelTopologyOps, KernelTransformOps, } from './kernel/index.js';
 export { supportsProjection, supportsConstraintSketch } from './kernel/index.js';
 export type { ProjectionCapability, ConstraintSketchCapability } from './kernel/index.js';
 export { getPerformanceStats, resetPerformanceStats } from './kernel/index.js';
@@ -93,7 +93,7 @@ export { facesOfEdge, edgesOfFace, wiresOfFace, verticesOfEdge, verticesOfFace,
 export { getCurveType, curveStartPoint, curveEndPoint, curvePointAt, curveTangentAt, curveAxis, curveLength, curveIsClosed, curveIsPeriodic, curvePeriod, getOrientation, flipOrientation, offsetWire2D, interpolateCurve, approximateCurve, type InterpolateCurveOptions, type ApproximateCurveOptions, } from './topology/curveFns.js';
 export { getNurbsCurveData, getNurbsSurfaceData } from './topology/nurbsFns.js';
 export type { NurbsCurveData, NurbsSurfaceData } from './kernel/types.js';
-export { getSurfaceType, faceGeomType, faceOrientation, flipFaceOrientation, uvBounds, pointOnSurface, uvCoordinates, normalAt, faceCenter, faceAxis, classifyPointOnFace, outerWire, innerWires, removeHolesFromFace, projectPointOnFace, type UVBounds, type PointProjectionResult, } from './topology/faceFns.js';
+export { getSurfaceType, faceGeomType, faceOrientation, flipFaceOrientation, uvBounds, pointOnSurface, uvCoordinates, normalAt, faceCenter, faceAxis, classifyPointOnFace, outerWire, innerWires, removeHolesFromFace, projectPointOnFace, type SurfaceType, type UVBounds, type PointProjectionResult, } from './topology/faceFns.js';
 export { exportSTEP, exportSTL, exportIGES, meshMultiLOD, meshLODs, meshLODsProgressive, type ShapeMesh, type EdgeMesh, type MeshOptions, type MultiLODMesh, type LODMesh, type MeshLODsOptions, type MeshLODsProgressiveOptions, type MeshLevelFn, } from './topology/meshFns.js';
 export { clearMeshCache, createMeshCache, type MeshCacheContext } from './topology/meshCache.js';
 export { toBufferGeometryData, toLineGeometryData, toGroupedBufferGeometryData, type BufferGeometryData, type LineGeometryData, type GroupedBufferGeometryData, type BufferGeometryGroup, toLODGeometryData, type LODGeometryData, toLODGeometryLevels, type LODGeometryLevel, } from './topology/threeHelpers.js';

package/dist/io.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_meshFns = require("./meshFns-nEvfwNRF.cjs");
-const require_importFns = require("./importFns-3IMBHQrQ.cjs");
+const require_meshFns = require("./meshFns-Czlt-GBJ.cjs");
+const require_importFns = require("./importFns-KEPAgbjj.cjs");
 exports.blueprintToDXF = require_importFns.blueprintToDXF;
 exports.exportDXF = require_importFns.exportDXF;
 exports.exportGlb = require_importFns.exportGlb;

package/dist/io.js

@@ -1,3 +1,3 @@
-import { n as exportSTEP, r as exportSTL, t as exportIGES } from "./meshFns-DaRZxa7B.js";
-import { a as importSVG, c as blueprintToDXF, d as exportGltf, f as exportOBJ, i as exportSTEPConfigured, l as exportDXF, n as importSTEP, o as importSVGPathD, r as importSTL, s as exportThreeMF, t as importIGES, u as exportGlb } from "./importFns-BCL4-H8e.js";
+import { n as exportSTEP, r as exportSTL, t as exportIGES } from "./meshFns-DmjMzNbH.js";
+import { a as importSVG, c as blueprintToDXF, d as exportGltf, f as exportOBJ, i as exportSTEPConfigured, l as exportDXF, n as importSTEP, o as importSVGPathD, r as importSTL, s as exportThreeMF, t as importIGES, u as exportGlb } from "./importFns-DUzIkns7.js";
 export { blueprintToDXF, exportDXF, exportGlb, exportGltf, exportIGES, exportOBJ, exportSTEP, exportSTEPConfigured, exportSTL, exportThreeMF, importIGES, importSTEP, importSTL, importSVG, importSVGPathD };

package/dist/kernel/bspline2dFit.d.ts

@@ -0,0 +1,42 @@
+import { Bezier2d, BSpline2d } from './geometry2d.js';
+type Pt = [number, number];
+/**
+ * Interpolate `points` with a clamped B-spline of `degree` (capped at
+ * `points.length - 1`). `params` are the increasing curve parameters assigned to
+ * the points, normalised to [0, 1]; chord length when omitted.
+ */
+export declare function interpolateBSpline2d(points: readonly Pt[], degree?: number, params?: readonly number[]): BSpline2d;
+interface FitOptions {
+    readonly degree?: number;
+    readonly minSegments?: number;
+    readonly maxSegments?: number;
+    /**
+     * Parameters in (s0, s1) where the curve may change abruptly, such as a
+     * source B-spline's knots. Each piece between them is fitted on its own, so
+     * a feature narrower than the sample spacing cannot fall between samples.
+     */
+    readonly breaks?: readonly number[];
+}
+/**
+ * Approximate the parametric curve `evaluate` over [s0, s1] by interpolating
+ * uniformly spaced samples, doubling the sample count until the interpolant is
+ * within `tolerance` of the curve at every mid-sample parameter (or the
+ * segment cap is reached). With `breaks`, each piece between them is fitted
+ * separately and the pieces are joined. The B-spline runs over [0, 1] in step
+ * with s.
+ */
+export declare function fitBSpline2d(evaluate: (s: number) => Pt, s0: number, s1: number, tolerance: number, options?: FitOptions): BSpline2d;
+/** The B-spline form of a Bezier; a B-spline is returned as is. */
+export declare function asBSpline2d(c: Bezier2d | BSpline2d): BSpline2d;
+/**
+ * The part of a clamped B-spline over [lo, hi] (inside its knot range, lo < hi)
+ * as a clamped B-spline of its own, exact by knot insertion.
+ */
+export declare function subBSpline2d(c: BSpline2d, lo: number, hi: number): BSpline2d;
+/**
+ * Bezier poles of every non-empty knot span (The NURBS Book A5.6). A malformed
+ * knot vector yields the whole control polygon as one segment, which still
+ * bounds the curve.
+ */
+export declare function bezierSegments2d(c: BSpline2d): Pt[][];
+export {};

package/dist/kernel/geometry2d.d.ts

@@ -69,6 +69,18 @@ export declare function curveBounds(c: Curve2dObj): {
     last: number;
 };
 export declare function curveTypeName(c: Curve2dObj): string;
+/**
+ * Collapse nested trimmed wrappers into a single trimmed curve over a
+ * non-trimmed basis (or return the curve itself when it is not trimmed).
+ * Evaluation is unchanged: both forms map t in [0, 1] to the same basis point.
+ */
+export declare function flattenTrimmed(c: Curve2dObj): Curve2dObj;
+/**
+ * The same geometry traversed in the opposite direction (OCCT `Geom2d_Curve::Reversed`).
+ * Trimmed curves keep an increasing trim range: the basis is reversed and the
+ * range is remapped onto it.
+ */
+export declare function reverseCurve2d(c: Curve2dObj): Curve2dObj;
 export declare function makeLine2d(x1: number, y1: number, x2: number, y2: number): Line2d;
 export declare function makeCircle2d(cx: number, cy: number, radius: number, sense?: boolean): Circle2d;
 export declare function makeArc2dThreePoints(x1: number, y1: number, xm: number, ym: number, x2: number, y2: number): Curve2dObj;
@@ -80,6 +92,39 @@ export declare function rotateCurve2d(c: Curve2dObj, angle: number, cx: number,
 export declare function scaleCurve2d(c: Curve2dObj, factor: number, cx: number, cy: number): Curve2dObj;
 export declare function mirrorAtPoint(c: Curve2dObj, cx: number, cy: number): Curve2dObj;
 export declare function mirrorAcrossAxis(c: Curve2dObj, ox: number, oy: number, dx: number, dy: number): Curve2dObj;
+/** The affine map x' = a*x + b*y + tx, y' = c*x + d*y + ty. */
+export interface Affine2d {
+    readonly a: number;
+    readonly b: number;
+    readonly c: number;
+    readonly d: number;
+    readonly tx: number;
+    readonly ty: number;
+}
+/**
+ * Exact image of a curve under an affine map (OCCT `Geom2d_Curve::Transformed`
+ * with a `gp_GTrsf2d`): lines stay lines, circles and ellipses become ellipses
+ * (or circles), and pole-based curves map their poles.
+ */
+export declare function affineCurve2d(c: Curve2dObj, m: Affine2d): Curve2dObj;
+/**
+ * Parameters of `c`, in its own parameter range, at the interior knots of its
+ * B-spline basis: where a fit of the curve (or of its offset) must sample.
+ */
+export declare function curveKnotParams(c: Curve2dObj): number[];
+/**
+ * Offset `distance` to the right of the direction of travel (OCCT
+ * `Geom2d_OffsetCurve`: a counter-clockwise circle grows). Lines and circles
+ * are offset exactly; other curves are fitted within `tolerance` (by default
+ * relative to the curve's size).
+ */
+export declare function offsetCurve2d(c: Curve2dObj, distance: number, tolerance?: number): Curve2dObj;
+/**
+ * Minimum distance between c1 over [from1, to1] and c2 over [from2, to2]
+ * (OCCT `Geom2dAPI_ExtremaCurveCurve`): every local minimum of a sampled
+ * distance grid seeds a Gauss-Newton refinement.
+ */
+export declare function distanceBetweenCurves2d(c1: Curve2dObj, c2: Curve2dObj, from1: number, to1: number, from2: number, to2: number): number;
 /**
  * Compute intersection points (and overlapping segments) between two 2D curves.
  * Handles analytic cases (line-line, line-circle, circle-circle) and falls back

package/dist/kernel/occt/kernel2dOps.d.ts

@@ -24,7 +24,7 @@ export declare function getCurve2dBounds(curve: Curve2dHandle): {
 };
 export declare function getCurve2dType(curve: Curve2dHandle): string;
 export declare function trimCurve2d(curve: Curve2dHandle, start: number, end: number): Curve2dHandle;
-export declare function reverseCurve2d(_curve: Curve2dHandle): void;
+export declare function reverseCurve2d(curve: Curve2dHandle): void;
 export declare function copyCurve2d(curve: Curve2dHandle): Curve2dHandle;
 export declare function offsetCurve2d(curve: Curve2dHandle, offset: number): Curve2dHandle;
 export declare function translateCurve2d(curve: Curve2dHandle, dx: number, dy: number): Curve2dHandle;

package/dist/kernel/occtWasm/constructionOps.d.ts

@@ -14,7 +14,7 @@ export declare function makeEllipseEdge(k: OcctKernelWasm, center: Vec3, normal:
 export declare function makeEllipseArc(k: OcctKernelWasm, center: Vec3, normal: Vec3, majorRadius: number, minorRadius: number, startAngle: number, endAngle: number, xDir?: Vec3): KernelShape;
 export declare function makeBezierEdge(k: OcctKernelWasm, Module: OcctWasmModule, points: [number, number, number][]): KernelShape;
 export declare function makeTangentArc(k: OcctKernelWasm, startPoint: [number, number, number], startTangent: [number, number, number], endPoint: [number, number, number]): KernelShape;
-export declare function makeHelixWire(k: OcctKernelWasm, pitch: number, height: number, radius: number, center?: [number, number, number], direction?: [number, number, number]): KernelShape;
+export declare function makeHelixWire(k: OcctKernelWasm, pitch: number, height: number, radius: number, center?: [number, number, number], direction?: [number, number, number], leftHanded?: boolean): KernelShape;
 export declare function makeCompound(k: OcctKernelWasm, Module: OcctWasmModule, shapes: KernelShape[]): KernelShape;
 export declare function solidFromShell(k: OcctKernelWasm, shell: KernelShape): KernelShape;
 export declare function buildSolidFromFaces(k: OcctKernelWasm, Module: OcctWasmModule, points: Array<{

package/dist/kernel/occtWasm/kernel2dOps.d.ts

@@ -31,7 +31,7 @@ export declare function getCurve2dBounds(curve: Curve2dHandle): {
 };
 export declare function getCurve2dType(curve: Curve2dHandle): string;
 export declare function trimCurve2d(curve: Curve2dHandle, start: number, end: number): Curve2dHandle;
-export declare function reverseCurve2d(_curve: Curve2dHandle): void;
+export declare function reverseCurve2d(curve: Curve2dHandle): void;
 export declare function copyCurve2d(curve: Curve2dHandle): Curve2dHandle;
 export declare function offsetCurve2d(curve: Curve2dHandle, offset: number): Curve2dHandle;
 export declare function translateCurve2d(curve: Curve2dHandle, dx: number, dy: number): Curve2dHandle;
@@ -42,8 +42,7 @@ export declare function mirrorCurve2dAcrossAxis(curve: Curve2dHandle, originX: n
 /**
  * Directional affinity matching OCCT `gp_GTrsf2d::SetAffinity`: scales the
  * component perpendicular to the axis `(dx, dy)` through `(ox, oy)` by `ratio`,
- * leaving the parallel component fixed. Applied by sampling and refitting as a
- * Bezier, since occt-wasm has no native Geom2d transform.
+ * leaving the parallel component fixed.
  */
 export declare function affinityCurve2d(curve: Curve2dHandle, ox: number, oy: number, dx: number, dy: number, ratio: number): Curve2dHandle;
 export declare function affinityTransform2d(curve: Curve2dHandle, ox: number, oy: number, dx: number, dy: number, ratio: number): Curve2dHandle;
@@ -65,7 +64,11 @@ export declare function projectPointOnCurve2d(curve: Curve2dHandle, x: number, y
     distance: number;
 } | null;
 export declare function distanceBetweenCurves2d(c1: Curve2dHandle, c2: Curve2dHandle, p1Start: number, p1End: number, p2Start: number, p2End: number): number;
-export declare function approximateCurve2dAsBSpline(curve: Curve2dHandle, maxSegments: number): Curve2dHandle;
+/**
+ * Degree <= 3 B-spline within `tolerance` of the curve (Geom2dConvert_ApproxCurve
+ * with MaxDegree 3, as brepjs calls it); exact where the curve already is one.
+ */
+export declare function approximateCurve2dAsBSpline(curve: Curve2dHandle, tolerance: number, maxSegments: number): Curve2dHandle;
 export declare function decomposeBSpline2dToBeziers(curve: Curve2dHandle): Curve2dHandle[];
 export declare function createBoundingBox2d(): BBox2dHandle;
 export declare function addCurveToBBox2d(bbox: BBox2dHandle, curve: Curve2dHandle, tolerance: number): void;

package/dist/kernel/occtWasm/occtWasmAdapter.cjs

@@ -1,3 +1,3 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_occtWasmAdapter = require("../../occtWasmAdapter-CRd9RFEu.cjs");
+const require_occtWasmAdapter = require("../../occtWasmAdapter-DVxLkjlJ.cjs");
 exports.OcctWasmAdapter = require_occtWasmAdapter.OcctWasmAdapter;

package/dist/kernel/occtWasm/occtWasmAdapter.d.ts

@@ -96,7 +96,7 @@ export declare class OcctWasmAdapter implements KernelAdapter {
     makeEllipseArc(center: [number, number, number], normal: [number, number, number], majorRadius: number, minorRadius: number, startAngle: number, endAngle: number, xDir?: [number, number, number]): KernelShape;
     makeBezierEdge(points: [number, number, number][]): KernelShape;
     makeTangentArc(startPoint: [number, number, number], startTangent: [number, number, number], endPoint: [number, number, number]): KernelShape;
-    makeHelixWire(pitch: number, height: number, radius: number, center?: [number, number, number], direction?: [number, number, number], _leftHanded?: boolean): KernelShape;
+    makeHelixWire(pitch: number, height: number, radius: number, center?: [number, number, number], direction?: [number, number, number], leftHanded?: boolean): KernelShape;
     makeWireFromMixed(items: KernelShape[]): KernelShape;
     makeCompound(shapes: KernelShape[]): KernelShape;
     solidFromShell(shell: KernelShape): KernelShape;
@@ -390,7 +390,7 @@ export declare class OcctWasmAdapter implements KernelAdapter {
     makeEllipse2d(cx: number, cy: number, majorRadius: number, minorRadius: number, xDirX?: number, xDirY?: number, sense?: boolean): Curve2dHandle;
     makeEllipseArc2d(cx: number, cy: number, majorRadius: number, minorRadius: number, startAngle: number, endAngle: number, xDirX?: number, xDirY?: number, sense?: boolean): Curve2dHandle;
     makeBezier2d(points: [number, number][]): Curve2dHandle;
-    makeBSpline2d(points: [number, number][], _options?: {
+    makeBSpline2d(points: [number, number][], options?: {
         degMin?: number;
         degMax?: number;
         continuity?: 'C0' | 'C1' | 'C2' | 'C3';
@@ -435,7 +435,7 @@ export declare class OcctWasmAdapter implements KernelAdapter {
         distance: number;
     } | null;
     distanceBetweenCurves2d(c1: Curve2dHandle, c2: Curve2dHandle, p1Start: number, p1End: number, p2Start: number, p2End: number): number;
-    approximateCurve2dAsBSpline(curve: Curve2dHandle, _tolerance: number, _continuity: 'C0' | 'C1' | 'C2' | 'C3', maxSegments: number): Curve2dHandle;
+    approximateCurve2dAsBSpline(curve: Curve2dHandle, tolerance: number, _continuity: 'C0' | 'C1' | 'C2' | 'C3', maxSegments: number): Curve2dHandle;
     decomposeBSpline2dToBeziers(curve: Curve2dHandle): Curve2dHandle[];
     createBoundingBox2d(): BBox2dHandle;
     addCurveToBBox2d(bbox: BBox2dHandle, curve: Curve2dHandle, tolerance: number): void;

package/dist/kernel/occtWasm/occtWasmAdapter.js

@@ -1 +1 @@
-export { t as OcctWasmAdapter } from "../../occtWasmAdapter-ipKUdNLN.js";
+export { t as OcctWasmAdapter } from "../../occtWasmAdapter-B9d0Q0Vl.js";

package/dist/kernel/occtWasm/occtWasmTypes.d.ts

@@ -170,8 +170,15 @@ export interface OcctKernelWasm {
     /** occt-wasm 5.8+: like makeEllipseArc with the major axis along (xx, xy, xz). */
     makeEllipseArcOriented?(cx: number, cy: number, cz: number, nx: number, ny: number, nz: number, xx: number, xy: number, xz: number, majorRadius: number, minorRadius: number, startAngle: number, endAngle: number): number;
     makeBezierEdge(flatPoints: EmVectorDouble): number;
+    /** occt-wasm 5.8+: non-rational when `weights` is empty; poles are flat xyz triples. */
+    makeBSplineEdge?(poles: EmVectorDouble, weights: EmVectorDouble, knots: EmVectorDouble, multiplicities: EmVectorInt, degree: number, periodic: boolean): number;
     makeTangentArc(x1: number, y1: number, z1: number, tx: number, ty: number, tz: number, x2: number, y2: number, z2: number): number;
     makeHelixWire(px: number, py: number, pz: number, dx: number, dy: number, dz: number, pitch: number, height: number, radius: number): number;
+    /**
+     * {@link makeHelixWire} with an explicit winding. Optional: absent on WASM
+     * builds older than occt-wasm 4.3.0, so callers must feature-detect it.
+     */
+    makeHelixWireHanded?(px: number, py: number, pz: number, dx: number, dy: number, dz: number, pitch: number, height: number, radius: number, leftHanded: boolean): number;
     makeWire(edgeIds: EmVectorUint32): number;
     makeFace(wireId: number): number;
     makeNonPlanarFace(wireId: number): number;

package/dist/{loftFns-DlG5oR0X.cjs → loftFns-D5AvfCGG.cjs}

@@ -1,4 +1,4 @@
-const require_shapeTypes = require("./shapeTypes-DJT3SnGK.cjs");
+const require_shapeTypes = require("./shapeTypes-Dc7j-MYg.cjs");
 const require_errors = require("./errors-O_blYTWT.cjs");
 const require_types = require("./types-CjF9Rofr.cjs");
 const require_vecOps = require("./vecOps-CrGEPPQM.cjs");
@@ -40,6 +40,14 @@ function makeSpineWire(start, end) {
 	kernel.dispose(edge);
 	return require_shapeTypes.castResultShape(wire);
 }
+/** A planar face bounded by `wire`, or `null` when the wire does not span one. */
+function planarFaceOf(wire) {
+	try {
+		return require_shapeTypes.getKernel().makeFace(wire.wrapped, true);
+	} catch {
+		return null;
+	}
+}
 /** Build a helix wire for twist extrusion. */
 function makeHelixWire(pitch, height, radius, center, dir, leftHanded = false) {
 	const kernel = require_shapeTypes.getKernel();
@@ -87,7 +95,14 @@ function castSweepShellTuple(result) {
 */
 function sweep(wire, spine, config = {}, shellMode = false) {
 	if (config.mode === "simple" && !shellMode) {
-		const resultOc = require_shapeTypes.getKernel().simplePipe(wire.wrapped, spine.wrapped);
+		const kernel = require_shapeTypes.getKernel();
+		const profileFace = planarFaceOf(wire);
+		let resultOc;
+		try {
+			resultOc = kernel.simplePipe(profileFace ?? wire.wrapped, spine.wrapped);
+		} finally {
+			if (profileFace) kernel.dispose(profileFace);
+		}
 		const shape = require_shapeTypes.castResultShape(resultOc);
 		if (!require_shapeTypes.isShape3D(shape)) {
 			require_shapeTypes.disposeResultShape(shape);

package/dist/{loftFns-H4ZOpRAk.js → loftFns-D5NJpHLZ.js}

@@ -1,4 +1,4 @@
-import { G as _usingCtx, T as isWire, h as disposeResultShape, n as castResultShape, q as getKernel, x as isShape3D } from "./shapeTypes-DAz6aAnJ.js";
+import { G as _usingCtx, T as isWire, h as disposeResultShape, n as castResultShape, q as getKernel, x as isShape3D } from "./shapeTypes-DwvQUp9M.js";
 import { E as ok, b as isErr, d as validationError, g as err, i as kernelError, l as typeCastError, t as BrepErrorCode } from "./errors-BTccWbtE.js";
 import { r as toVec3 } from "./types-CKXsIm9-.js";
 import { c as vecLength, t as vecAdd } from "./vecOps-S-m9H_fe.js";
@@ -40,6 +40,14 @@ function makeSpineWire(start, end) {
 	kernel.dispose(edge);
 	return castResultShape(wire);
 }
+/** A planar face bounded by `wire`, or `null` when the wire does not span one. */
+function planarFaceOf(wire) {
+	try {
+		return getKernel().makeFace(wire.wrapped, true);
+	} catch {
+		return null;
+	}
+}
 /** Build a helix wire for twist extrusion. */
 function makeHelixWire(pitch, height, radius, center, dir, leftHanded = false) {
 	const kernel = getKernel();
@@ -87,7 +95,14 @@ function castSweepShellTuple(result) {
 */
 function sweep(wire, spine, config = {}, shellMode = false) {
 	if (config.mode === "simple" && !shellMode) {
-		const resultOc = getKernel().simplePipe(wire.wrapped, spine.wrapped);
+		const kernel = getKernel();
+		const profileFace = planarFaceOf(wire);
+		let resultOc;
+		try {
+			resultOc = kernel.simplePipe(profileFace ?? wire.wrapped, spine.wrapped);
+		} finally {
+			if (profileFace) kernel.dispose(profileFace);
+		}
 		const shape = castResultShape(resultOc);
 		if (!isShape3D(shape)) {
 			disposeResultShape(shape);

package/dist/{measureFns-Ce01LVwq.cjs → measureFns-CZHNWkiA.cjs}

@@ -1,7 +1,7 @@
-const require_shapeTypes = require("./shapeTypes-DJT3SnGK.cjs");
+const require_shapeTypes = require("./shapeTypes-Dc7j-MYg.cjs");
 const require_errors = require("./errors-O_blYTWT.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-xh11vEQw.cjs");
-const require_faceFns = require("./faceFns-BjmlYcc9.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-5Frx8Y-0.cjs");
+const require_faceFns = require("./faceFns-B7MiDYj1.cjs");
 // src/measurement/measureCache.ts
 var cache = /* @__PURE__ */ new WeakMap();
 function getCachedMeasurement(shape, key) {
@@ -27,6 +27,66 @@ function nullShapeErr(fn) {
 	return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, `${fn}: shape is a null shape`));
 }
 /**
+* Run `fn` on fresh handles to the distinct sub-shapes of `type`, releasing them
+* afterwards. Unlike getFaces and friends this leaves the shape's topology cache
+* alone, so a measurement allocates nothing that outlives it.
+*/
+function withSubShapes(shape, type, fn) {
+	const kernel = require_shapeTypes.getKernel();
+	const items = kernel.iterShapes(shape.wrapped, type);
+	try {
+		return fn(items);
+	} finally {
+		for (const item of items) kernel.dispose(item);
+	}
+}
+/** Run `fn` on a throwaway compound of `parts`, releasing the compound afterwards. */
+function withCompoundOf(parts, fn) {
+	const kernel = require_shapeTypes.getKernel();
+	const c = kernel.makeCompound(parts);
+	try {
+		return fn(c);
+	} finally {
+		kernel.dispose(c);
+	}
+}
+function volumeOf(target) {
+	const kernel = require_shapeTypes.getKernel();
+	const m = kernel.volume(target);
+	const comResult = require_topologyQueryFns.kernelCallRaw(() => kernel.centerOfMass(target), require_errors.BrepErrorCode.CENTER_OF_MASS_FAILED, "Failed to compute center of mass");
+	if (!comResult.ok) return comResult;
+	return require_errors.ok({
+		mass: m,
+		volume: m,
+		centerOfMass: comResult.value
+	});
+}
+/** Area-weighted centroid of `faces`, from each face's own surface center of mass. */
+function surfaceCentroid(faces) {
+	const kernel = require_shapeTypes.getKernel();
+	let total = 0;
+	let x = 0;
+	let y = 0;
+	let z = 0;
+	for (const f of faces) {
+		const a = kernel.area(f);
+		const [cx, cy, cz] = kernel.surfaceCenterOfMass(f);
+		total += a;
+		x += a * cx;
+		y += a * cy;
+		z += a * cz;
+	}
+	return total > 0 ? [
+		x / total,
+		y / total,
+		z / total
+	] : [
+		0,
+		0,
+		0
+	];
+}
+/**
 * Measure volume properties of a 3D shape.
 *
 * @param shape - A solid or compound shape.
@@ -37,31 +97,23 @@ function measureVolumeProps(shape) {
 	const cached = getCachedMeasurement(shape.wrapped, "volume");
 	if (cached) return require_errors.ok(cached);
 	if (shapeIsNull(shape)) return nullShapeErr("measureVolumeProps");
-	const kernel = require_shapeTypes.getKernel();
-	const type = kernel.shapeType(shape.wrapped);
-	if (type !== "solid" && type !== "compsolid" && type !== "compound") {
-		const zero = {
-			mass: 0,
-			volume: 0,
-			centerOfMass: [
-				0,
-				0,
-				0
-			]
-		};
-		setCachedMeasurement(shape.wrapped, "volume", zero);
-		return require_errors.ok(zero);
-	}
-	const m = kernel.volume(shape.wrapped);
-	const comResult = require_topologyQueryFns.kernelCallRaw(() => kernel.centerOfMass(shape.wrapped), require_errors.BrepErrorCode.CENTER_OF_MASS_FAILED, "Failed to compute center of mass");
-	if (!comResult.ok) return comResult;
-	const result = {
-		mass: m,
-		volume: m,
-		centerOfMass: comResult.value
+	const type = require_shapeTypes.getKernel().shapeType(shape.wrapped);
+	const zero = {
+		mass: 0,
+		volume: 0,
+		centerOfMass: [
+			0,
+			0,
+			0
+		]
 	};
-	setCachedMeasurement(shape.wrapped, "volume", result);
-	return require_errors.ok(result);
+	let result;
+	if (type === "solid" || type === "compsolid") result = volumeOf(shape.wrapped);
+	else if (type === "compound") result = withSubShapes(shape, "solid", (solids) => solids.length === 0 ? require_errors.ok(zero) : withCompoundOf(solids, volumeOf));
+	else result = require_errors.ok(zero);
+	if (!result.ok) return result;
+	setCachedMeasurement(shape.wrapped, "volume", result.value);
+	return result;
 }
 /**
 * Measure surface properties of a face or 3D shape.
@@ -76,7 +128,7 @@ function measureSurfaceProps(shape) {
 	if (shapeIsNull(shape)) return nullShapeErr("measureSurfaceProps");
 	const kernel = require_shapeTypes.getKernel();
 	const m = kernel.area(shape.wrapped);
-	const comResult = require_topologyQueryFns.kernelCallRaw(() => kernel.centerOfMass(shape.wrapped), require_errors.BrepErrorCode.CENTER_OF_MASS_FAILED, "Failed to compute center of mass");
+	const comResult = require_topologyQueryFns.kernelCallRaw(() => kernel.shapeType(shape.wrapped) === "face" ? kernel.surfaceCenterOfMass(shape.wrapped) : withSubShapes(shape, "face", surfaceCentroid), require_errors.BrepErrorCode.CENTER_OF_MASS_FAILED, "Failed to compute center of mass");
 	if (!comResult.ok) return comResult;
 	const result = {
 		mass: m,
@@ -89,8 +141,9 @@ function measureSurfaceProps(shape) {
 /**
 * Measure linear properties of any shape.
 *
-* For edges this is the arc length; for wires/compounds it is the total
-* length of all edges.
+* For edges this is the arc length; for wires and faces it is the total length
+* of their edges; for shells, solids, and compounds it is the total length of
+* their distinct edges, each counted once.
 *
 * @param shape - Any shape whose linear extent is to be measured.
 * @returns `Result` containing length, center of mass, and raw mass property.
@@ -101,12 +154,26 @@ function measureLinearProps(shape) {
 	if (cached) return require_errors.ok(cached);
 	if (shapeIsNull(shape)) return nullShapeErr("measureLinearProps");
 	const kernel = require_shapeTypes.getKernel();
-	const m = kernel.length(shape.wrapped);
-	const result = {
-		mass: m,
-		length: m,
-		centerOfMass: kernel.linearCenterOfMass(shape.wrapped)
+	const type = kernel.shapeType(shape.wrapped);
+	const linearOf = (target) => {
+		const m = kernel.length(target);
+		return {
+			mass: m,
+			length: m,
+			centerOfMass: kernel.linearCenterOfMass(target)
+		};
 	};
+	let result;
+	if (type === "vertex" || type === "edge" || type === "wire" || type === "face") result = linearOf(shape.wrapped);
+	else result = withSubShapes(shape, "edge", (edges) => edges.length === 0 ? {
+		mass: 0,
+		length: 0,
+		centerOfMass: [
+			0,
+			0,
+			0
+		]
+	} : withCompoundOf(edges, linearOf));
 	setCachedMeasurement(shape.wrapped, "linear", result);
 	return require_errors.ok(result);
 }