brepjs 20.12.7 → 20.12.9

package/dist/{importFns-DLiP26NW.cjs → importFns-tHr15Lhm.cjs}

@@ -1,8 +1,12 @@
-const require_shapeTypes = require("./shapeTypes-MUEH4XuH.cjs");
+const require_shapeTypes = require("./shapeTypes--7XBFlOD.cjs");
 const require_bug = require("./bug-CBcpIPuf.cjs");
 const require_errors = require("./errors-O_blYTWT.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-NszVx8a0.cjs");
+const require_constants = require("./constants-oee0S_x6.cjs");
+const require_solidBuilders = require("./solidBuilders-D0bIZX9K.cjs");
+const require_meshFns = require("./meshFns-DDgZ3vpr.cjs");
 const require_arrayAccess = require("./arrayAccess-DpJYARwv.cjs");
-const require_blueprint = require("./blueprint-17RUHsoP.cjs");
+const require_blueprint = require("./blueprint-DbJVzU9F.cjs");
 // src/io/objExportFns.ts
 /** Read a vec3 from a typed array at the given vertex index. */
 function vec3At(arr, i) {
@@ -1248,13 +1252,17 @@ function importSVGPathD(pathD) {
 */
 function importSVG(svgString) {
 	try {
-		const dAttrRe = /\bd\s*=\s*(?:"([^"]*)"|'([^']*)')/;
+		const dAttrRe = /\sd\s*=\s*(?:"([^"]*)"|'([^']*)')/;
 		const blueprints = [];
 		const lower = svgString.toLowerCase();
 		let pos = 0;
 		while (pos < lower.length) {
-			const tagStart = lower.indexOf("<path ", pos);
+			const tagStart = lower.indexOf("<path", pos);
 			if (tagStart === -1) break;
+			if (!/\s/.test(lower.charAt(tagStart + 5))) {
+				pos = tagStart + 5;
+				continue;
+			}
 			const tagEnd = svgString.indexOf(">", tagStart);
 			if (tagEnd === -1) break;
 			const tag = svgString.slice(tagStart, tagEnd + 1);
@@ -1297,6 +1305,275 @@ function exportSTEPConfigured(parts, options) {
 		return require_errors.err(require_errors.ioError(require_errors.BrepErrorCode.STEP_EXPORT_CONFIGURED_FAILED, "Configured STEP export failed", e));
 	}
 }
+// src/io/meshNesting.ts
+/**
+* Cavities in sewn mesh bodies.
+*
+* A hollow mesh is an outer shell plus inward-facing inner shells, and sewing makes
+* each of them a closed body of its own. A cavity is a shell whose triangles face
+* inward (negative signed volume, read before solidifying reorients it) that lies
+* inside another body; it is cut from the innermost body around it. An outward-facing
+* shell inside another is a separate part and stays one. Containment comes from ray
+* casts against each body's tessellation, because no kernel here can classify a
+* point against a solid.
+*/
+var RAY_LENGTH = Math.hypot(.5389, .6213, .5689);
+var RAY = [
+	.5389 / RAY_LENGTH,
+	.6213 / RAY_LENGTH,
+	.5689 / RAY_LENGTH
+];
+/**
+* The parts to keep: `bodies` (each built from the same-index shell of `shells`)
+* with every cavity cut from the body around it and left out. Cut results are
+* pushed to `owned` for the caller to dispose; no input is disposed here.
+*
+* @throws When meshing or a cut fails, rather than leave a cavity filled.
+*/
+function carveCavities(bodies, shells, owned) {
+	const solids = bodies.flatMap((body, i) => require_shapeTypes.isSolid(body) ? [{
+		body,
+		shell: shells[i]
+	}] : []);
+	if (solids.length < 2) return [...bodies];
+	const voids = findVoids(solids);
+	const carved = /* @__PURE__ */ new Map();
+	for (const [body, inner] of voids) {
+		const result = cutVoids(body, inner);
+		owned.push(result);
+		carved.set(body, result);
+	}
+	const consumed = new Set([...carved.keys()].flatMap((body) => voids.get(body) ?? []));
+	return bodies.filter((body) => !consumed.has(body)).map((body) => carved.get(body) ?? body);
+}
+/** The cavities of each body that has any, keyed by that body. */
+function findVoids(solids) {
+	const kernel = require_shapeTypes.getKernel();
+	const boxes = solids.map(({ body }) => kernel.boundingBox(body.wrapped));
+	const meshes = /* @__PURE__ */ new Map();
+	const meshOf = (i) => {
+		let mesh = meshes.get(i);
+		if (mesh === void 0) {
+			mesh = meshShape(solids[i].body, boxes[i]);
+			meshes.set(i, mesh);
+		}
+		return mesh;
+	};
+	const containers = solids.map((_inner, j) => solids.map((_outer, i) => i).filter((i) => i !== j && boxInside(boxes[j], boxes[i]) && insideMesh(firstVertex(meshOf(j)), meshOf(i))));
+	const isVoid = containers.map((around, j) => {
+		const shell = solids[j]?.shell;
+		return around.length > 0 && shell !== void 0 && facesInward(shell, boxes[j]);
+	});
+	const voids = /* @__PURE__ */ new Map();
+	containers.forEach((around, j) => {
+		if (!isVoid[j]) return;
+		const bodiesAround = around.filter((i) => !isVoid[i]);
+		if (bodiesAround.length === 0) return;
+		const body = solids[bodiesAround.reduce((a, b) => (containers[b]?.length ?? 0) > (containers[a]?.length ?? 0) ? b : a)].body;
+		voids.set(body, [...voids.get(body) ?? [], solids[j].body]);
+	});
+	return voids;
+}
+/** Whether a closed shell's triangles face inward, by the sign of its enclosed volume. */
+function facesInward(shell, box) {
+	const mesh = meshShape(shell, box);
+	const t = mesh.triangles;
+	let volume = 0;
+	for (let i = 0; i + 2 < t.length; i += 3) {
+		const a = vertexAt(mesh, t[i]);
+		volume += dot(a, cross(vertexAt(mesh, t[i + 1]), vertexAt(mesh, t[i + 2])));
+	}
+	return volume < 0;
+}
+function cutVoids(body, voids) {
+	const kernel = require_shapeTypes.getKernel();
+	let current = body;
+	for (const inner of voids) try {
+		const next = require_shapeTypes.castResultShape(kernel.cut(current.wrapped, inner.wrapped));
+		if (current !== body) current[Symbol.dispose]();
+		current = next;
+	} catch (e) {
+		if (current !== body) current[Symbol.dispose]();
+		throw e;
+	}
+	return current;
+}
+function meshShape(shape, box) {
+	const diagonal = Math.hypot(...box.max.map((v, i) => v - (box.min[i] ?? 0)));
+	return require_shapeTypes.getKernel().mesh(shape.wrapped, {
+		tolerance: Math.max(diagonal * .001, 1e-6),
+		angularTolerance: .5,
+		skipNormals: true
+	});
+}
+function boxInside(inner, outer) {
+	return inner.min.every((v, i) => v >= (outer.min[i] ?? 0) && (inner.max[i] ?? 0) <= (outer.max[i] ?? 0));
+}
+function firstVertex(mesh) {
+	return [
+		mesh.vertices[0] ?? 0,
+		mesh.vertices[1] ?? 0,
+		mesh.vertices[2] ?? 0
+	];
+}
+function vertexAt(mesh, index) {
+	const i = (index ?? 0) * 3;
+	return [
+		mesh.vertices[i] ?? 0,
+		mesh.vertices[i + 1] ?? 0,
+		mesh.vertices[i + 2] ?? 0
+	];
+}
+/** Whether `p` is inside the closed mesh, by the parity of a ray's crossings. */
+function insideMesh(p, mesh) {
+	const t = mesh.triangles;
+	let crossings = 0;
+	for (let i = 0; i + 2 < t.length; i += 3) if (rayHits(p, vertexAt(mesh, t[i]), vertexAt(mesh, t[i + 1]), vertexAt(mesh, t[i + 2]))) crossings++;
+	return crossings % 2 === 1;
+}
+var sub = (a, b) => [
+	a[0] - b[0],
+	a[1] - b[1],
+	a[2] - b[2]
+];
+var dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+var cross = (a, b) => [
+	a[1] * b[2] - a[2] * b[1],
+	a[2] * b[0] - a[0] * b[2],
+	a[0] * b[1] - a[1] * b[0]
+];
+/** Moller-Trumbore: does the ray from `p` along RAY cross triangle abc ahead of `p`? */
+function rayHits(p, a, b, c) {
+	const e1 = sub(b, a);
+	const e2 = sub(c, a);
+	const h = cross(RAY, e2);
+	const det = dot(e1, h);
+	if (det === 0) return false;
+	const s = sub(p, a);
+	const u = dot(s, h) / det;
+	if (u < 0 || u > 1) return false;
+	const q = cross(s, e1);
+	const v = dot(RAY, q) / det;
+	if (v < 0 || u + v > 1) return false;
+	return dot(e2, q) / det > 0;
+}
+// src/io/ioUtils.ts
+/**
+* Shared mesh-to-solid sewing utilities for mesh importers.
+*
+* Builds triangular B-Rep faces from vertex/index data and sews them into one
+* solid per closed body, keeping any open body as a shell.
+*/
+/**
+* Sew faces into one solid per closed body.
+*
+* A single body comes back on its own: a `Solid` when closed, a `Shell` when
+* open. Several bodies come back as a `Compound` holding a `Solid` per closed
+* body, a `Shell` per open one, and any face that joined no shell. An
+* inward-facing closed shell inside another body is a cavity, cut from that
+* body. The caller keeps ownership of `faces`.
+*
+* @throws When the kernel cannot sew the faces at all.
+*/
+function sewFacesIntoSolids(faces, tolerance) {
+	try {
+		var _usingCtx$2 = require_shapeTypes._usingCtx();
+		const kernel = require_shapeTypes.getKernel();
+		const solid = solidify(faces, tolerance);
+		if (solid !== null) return solid;
+		const sewn = require_shapeTypes.castResultShape(kernel.sew(faces, tolerance));
+		const shells = require_topologyQueryFns.getShells(sewn);
+		const hasLooseFaces = shells.reduce((n, shell) => n + require_topologyQueryFns.subShapeCount(shell, "face"), 0) !== require_topologyQueryFns.subShapeCount(sewn, "face");
+		if (shells.length === 0 || shells.length === 1 && !hasLooseFaces) return sewn;
+		_usingCtx$2.u(sewn);
+		const owned = [];
+		try {
+			const parts = carveCavities(shells.map((shell) => {
+				const body = solidifyShell(shell.wrapped, tolerance);
+				owned.push(body);
+				return body;
+			}), shells, owned);
+			if (hasLooseFaces) for (const face of facesOutsideShells(sewn, shells)) {
+				const copy = require_shapeTypes.castResultShape(kernel.copyShape(face.wrapped));
+				owned.push(copy);
+				parts.push(copy);
+			}
+			return require_solidBuilders.makeCompound(parts);
+		} finally {
+			for (const shape of owned) shape[Symbol.dispose]();
+		}
+	} catch (_) {
+		_usingCtx$2.e = _;
+	} finally {
+		_usingCtx$2.d();
+	}
+}
+function facesOutsideShells(sewn, shells) {
+	const kernel = require_shapeTypes.getKernel();
+	const inShells = /* @__PURE__ */ new Map();
+	for (const shell of shells) for (const face of require_topologyQueryFns.getFaces(shell)) {
+		const hash = kernel.hashCode(face.wrapped, require_constants.HASH_CODE_MAX);
+		const bucket = inShells.get(hash);
+		if (bucket) bucket.push(face.wrapped);
+		else inShells.set(hash, [face.wrapped]);
+	}
+	return require_topologyQueryFns.getFaces(sewn).filter((face) => {
+		return !inShells.get(kernel.hashCode(face.wrapped, require_constants.HASH_CODE_MAX))?.some((other) => kernel.isSame(face.wrapped, other));
+	});
+}
+/**
+* `sewAndSolidify` when it yields a single solid, else `null`. Kernels signal
+* "not one closed body" differently: occt-wasm's solid downcast throws (and
+* castResultShape releases the slot), while opencascade.js returns the sewn
+* shell or compound, so the result's type decides.
+*/
+function solidify(faces, tolerance) {
+	let shape;
+	try {
+		shape = require_shapeTypes.castResultShape(require_shapeTypes.getKernel().sewAndSolidify(faces, tolerance));
+	} catch {
+		return null;
+	}
+	if (require_shapeTypes.isSolid(shape)) return shape;
+	shape[Symbol.dispose]();
+	return null;
+}
+function solidifyShell(shell, tolerance) {
+	const kernel = require_shapeTypes.getKernel();
+	const faces = kernel.iterShapes(shell, "face");
+	try {
+		return solidify(faces, tolerance) ?? require_shapeTypes.castResultShape(kernel.copyShape(shell));
+	} finally {
+		for (const face of faces) kernel.dispose(face);
+	}
+}
+/**
+* Build triangular B-Rep faces from vertex data and sew them into solids.
+*
+* For each triple of vertex coordinates, calls `kernel.buildTriFace` to create
+* a planar triangular face, then sews them with {@link sewFacesIntoSolids}.
+*
+* @param triangles - Array of vertex triples, each triple being three [x,y,z] tuples.
+* @param errorCode - The error code to use in any returned errors.
+* @param tolerance - Sewing tolerance (default 1e-6).
+* @returns A `Result` wrapping the sewn shape, or an error.
+*/
+function sewMeshToSolid(triangles, errorCode, tolerance = 1e-6) {
+	const kernel = require_shapeTypes.getKernel();
+	const triFaces = [];
+	for (const [va, vb, vc] of triangles) {
+		const triFace = kernel.buildTriFace(va, vb, vc);
+		if (triFace !== null) triFaces.push(triFace);
+	}
+	if (triFaces.length === 0) return require_errors.err(require_errors.ioError(errorCode, "No valid triangular faces could be built"));
+	try {
+		return require_errors.ok(sewFacesIntoSolids(triFaces, tolerance));
+	} catch (e) {
+		return require_errors.err(require_errors.ioError(errorCode, "Failed to sew triangular faces", e));
+	} finally {
+		for (const triFace of triFaces) kernel.dispose(triFace);
+	}
+}
 // src/io/importFns.ts
 /**
 * Functional file import operations using branded shape types.
@@ -1333,16 +1610,25 @@ async function importSTEP(blob) {
 		return require_errors.err(require_errors.ioError("STEP_IMPORT_FAILED", "Failed to load STEP file", e));
 	}
 }
+var STL_SEW_TOLERANCE = 1e-6;
 /**
 * Import an STL file from a Blob.
 *
-* Reads the mesh, unifies same-domain faces with `ShapeUpgrade_UnifySameDomain`,
-* and wraps the result as a solid.
+* Reads the triangle mesh and sews its facets together. A closed mesh becomes a
+* `Solid` (one planar face per facet), so booleans and volume measurement work on
+* it directly. An open mesh has no interior, so it comes back as a sewn `Shell`.
+* A file with several bodies comes back as a `Compound` holding a `Solid` per
+* closed body and a `Shell` per open one.
 *
 * @param blob - A Blob or File containing STL data (binary or ASCII).
-* @returns A `Result` wrapping the imported solid, or an error if parsing fails.
+* @returns A `Result` wrapping the imported solid (a shell for an open mesh, a
+*   compound for several bodies), or an error if parsing fails.
 *
-* @remarks The temporary file on the WASM FS is cleaned up automatically.
+* @remarks Every triangle becomes its own B-Rep face, so import time grows with
+* the triangle count: on the default occt-wasm kernel, roughly 2.5 seconds per
+* 10,000 triangles (about 15 seconds for 50,000), and up to about twice that
+* when the file holds several bodies. The temporary file on the WASM FS is
+* cleaned up automatically.
 *
 * @example
 * ```ts
@@ -1351,10 +1637,21 @@ async function importSTEP(blob) {
 */
 async function importSTL(blob) {
 	try {
-		const data = await blob.arrayBuffer();
-		const shape = require_shapeTypes.getKernel().importSTL(data);
-		if (shape.IsNull()) return require_errors.err(require_errors.ioError("STL_IMPORT_FAILED", "Failed to create solid from STL mesh"));
-		return require_errors.ok(require_shapeTypes.castResultShape(shape));
+		try {
+			var _usingCtx$1 = require_shapeTypes._usingCtx();
+			const data = await blob.arrayBuffer();
+			const raw = require_shapeTypes.getKernel().importSTL(data);
+			if (raw.IsNull()) return require_errors.err(require_errors.ioError("STL_IMPORT_FAILED", "Failed to create solid from STL mesh"));
+			const shape = require_shapeTypes.castResultShape(raw);
+			if (require_shapeTypes.isSolid(shape)) return require_errors.ok(shape);
+			const facets = _usingCtx$1.u(shape);
+			const faces = require_topologyQueryFns.getFaces(facets).map((f) => f.wrapped);
+			return require_errors.ok(sewFacesIntoSolids(faces, STL_SEW_TOLERANCE));
+		} catch (_) {
+			_usingCtx$1.e = _;
+		} finally {
+			_usingCtx$1.d();
+		}
 	} catch (e) {
 		return require_errors.err(require_errors.ioError("STL_IMPORT_FAILED", "Failed to load STL file", e));
 	}
@@ -1365,7 +1662,9 @@ async function importSTL(blob) {
 * @param blob - A Blob or File containing IGES data (.iges / .igs).
 * @returns A `Result` wrapping the imported shape, or an error if parsing fails.
 *
-* @remarks The temporary file on the WASM FS is cleaned up automatically.
+* @remarks The temporary file on the WASM FS is cleaned up automatically. The
+* default occt-wasm kernel is built without an IGES translator, so there this
+* returns an `UNSUPPORTED_CAPABILITY` error; import STEP instead.
 *
 * @example
 * ```ts
@@ -1383,7 +1682,7 @@ async function importIGES(blob) {
 		}
 		return require_errors.ok(require_shapeTypes.castResultShape(shapes[0]));
 	} catch (e) {
-		return require_errors.err(require_errors.ioError("IGES_IMPORT_FAILED", "Failed to load IGES file", e));
+		return require_errors.err(require_meshFns.igesUnsupportedError("importIGES", e) ?? require_errors.ioError("IGES_IMPORT_FAILED", "Failed to load IGES file", e));
 	}
 }
 Object.defineProperty(exports, "blueprintToDXF", {
@@ -1458,3 +1757,9 @@ Object.defineProperty(exports, "importSVGPathD", {
 		return importSVGPathD;
 	}
 });
+Object.defineProperty(exports, "sewMeshToSolid", {
+	enumerable: true,
+	get: function() {
+		return sewMeshToSolid;
+	}
+});

package/dist/io/igesSupport.d.ts

@@ -0,0 +1,6 @@
+import { BrepError } from '../core/errors.js';
+/**
+ * The capability error for an IGES call on a kernel built without an IGES
+ * translator (occt-wasm), or `null` when `cause` is any other failure.
+ */
+export declare function igesUnsupportedError(operation: 'importIGES' | 'exportIGES', cause: unknown): BrepError | null;

package/dist/io/importFns.d.ts

@@ -21,13 +21,21 @@ export declare function importSTEP(blob: Blob): Promise<Result<UnknownDimShape>>
 /**
  * Import an STL file from a Blob.
  *
- * Reads the mesh, unifies same-domain faces with `ShapeUpgrade_UnifySameDomain`,
- * and wraps the result as a solid.
+ * Reads the triangle mesh and sews its facets together. A closed mesh becomes a
+ * `Solid` (one planar face per facet), so booleans and volume measurement work on
+ * it directly. An open mesh has no interior, so it comes back as a sewn `Shell`.
+ * A file with several bodies comes back as a `Compound` holding a `Solid` per
+ * closed body and a `Shell` per open one.
  *
  * @param blob - A Blob or File containing STL data (binary or ASCII).
- * @returns A `Result` wrapping the imported solid, or an error if parsing fails.
+ * @returns A `Result` wrapping the imported solid (a shell for an open mesh, a
+ *   compound for several bodies), or an error if parsing fails.
  *
- * @remarks The temporary file on the WASM FS is cleaned up automatically.
+ * @remarks Every triangle becomes its own B-Rep face, so import time grows with
+ * the triangle count: on the default occt-wasm kernel, roughly 2.5 seconds per
+ * 10,000 triangles (about 15 seconds for 50,000), and up to about twice that
+ * when the file holds several bodies. The temporary file on the WASM FS is
+ * cleaned up automatically.
  *
  * @example
  * ```ts
@@ -41,7 +49,9 @@ export declare function importSTL(blob: Blob): Promise<Result<UnknownDimShape>>;
  * @param blob - A Blob or File containing IGES data (.iges / .igs).
  * @returns A `Result` wrapping the imported shape, or an error if parsing fails.
  *
- * @remarks The temporary file on the WASM FS is cleaned up automatically.
+ * @remarks The temporary file on the WASM FS is cleaned up automatically. The
+ * default occt-wasm kernel is built without an IGES translator, so there this
+ * returns an `UNSUPPORTED_CAPABILITY` error; import STEP instead.
  *
  * @example
  * ```ts

package/dist/io/ioUtils.d.ts

@@ -1,11 +1,23 @@
+import { KernelShape } from '../kernel/types.js';
 import { UnknownDimShape } from '../core/shapeTypes.js';
 import { Result } from '../core/result.js';
 /**
- * Build triangular B-Rep faces from vertex data and sew them into a solid.
+ * Sew faces into one solid per closed body.
+ *
+ * A single body comes back on its own: a `Solid` when closed, a `Shell` when
+ * open. Several bodies come back as a `Compound` holding a `Solid` per closed
+ * body, a `Shell` per open one, and any face that joined no shell. An
+ * inward-facing closed shell inside another body is a cavity, cut from that
+ * body. The caller keeps ownership of `faces`.
+ *
+ * @throws When the kernel cannot sew the faces at all.
+ */
+export declare function sewFacesIntoSolids(faces: KernelShape[], tolerance: number): UnknownDimShape;
+/**
+ * Build triangular B-Rep faces from vertex data and sew them into solids.
  *
  * For each triple of vertex coordinates, calls `kernel.buildTriFace` to create
- * a planar triangular face, then attempts `sewAndSolidify`. If solidification
- * fails, falls back to `sew` (returning a shell or compound).
+ * a planar triangular face, then sews them with {@link sewFacesIntoSolids}.
  *
  * @param triangles - Array of vertex triples, each triple being three [x,y,z] tuples.
  * @param errorCode - The error code to use in any returned errors.

package/dist/io/meshNesting.d.ts

@@ -0,0 +1,11 @@
+import { AnyShape, Dimension, Shell } from '../core/shapeTypes.js';
+type Body = AnyShape<Dimension>;
+/**
+ * The parts to keep: `bodies` (each built from the same-index shell of `shells`)
+ * with every cavity cut from the body around it and left out. Cut results are
+ * pushed to `owned` for the caller to dispose; no input is disposed here.
+ *
+ * @throws When meshing or a cut fails, rather than leave a cavity filled.
+ */
+export declare function carveCavities(bodies: Body[], shells: Shell[], owned: Body[]): Body[];
+export {};

package/dist/io/threemfImportFns.d.ts

@@ -3,11 +3,14 @@ import { Result } from '../core/result.js';
 /**
  * Import a 3MF file from a Blob.
  *
- * Extracts the model XML from the ZIP archive, parses vertices and triangles,
- * and builds a solid by sewing the resulting triangular faces.
+ * Extracts the model XML from the ZIP archive and builds one solid per placed
+ * object by sewing its triangles. Build-item and component transforms are
+ * applied, and coordinates are scaled from the model `unit` to millimeters.
  *
  * @param blob - A Blob or File containing 3MF data (.3mf).
- * @returns A `Result` wrapping the imported solid, or an error if parsing fails.
+ * @returns A `Result` wrapping the imported solid (a `Compound` of solids when the
+ *   build places several objects), or an error if parsing fails or the build
+ *   expands to more than 100,000 placed objects or 2,000,000 triangles.
  *
  * @example
  * ```ts

package/dist/io.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_meshFns = require("./meshFns-BeubBqEI.cjs");
-const require_importFns = require("./importFns-DLiP26NW.cjs");
+const require_meshFns = require("./meshFns-DDgZ3vpr.cjs");
+const require_importFns = require("./importFns-tHr15Lhm.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-UE8tByyw.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-Bp-p0jiP.js";
+import { n as exportSTEP, r as exportSTL, t as exportIGES } from "./meshFns-Go1XSyUh.js";
+import { a as exportSTEPConfigured, c as exportThreeMF, d as exportGlb, f as exportGltf, l as blueprintToDXF, n as importSTEP, o as importSVG, p as exportOBJ, r as importSTL, s as importSVGPathD, t as importIGES, u as exportDXF } from "./importFns-D5Bt_44J.js";
 export { blueprintToDXF, exportDXF, exportGlb, exportGltf, exportIGES, exportOBJ, exportSTEP, exportSTEPConfigured, exportSTL, exportThreeMF, importIGES, importSTEP, importSTL, importSVG, importSVGPathD };

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

@@ -1,5 +1,6 @@
 import { BooleanOptions, DiagnosticOperationResult, KernelShape, KernelType, OperationResult } from '../types.js';
 import { OcctKernelWasm, OcctWasmModule } from './occtWasmTypes.js';
+import { EdgeValueSpec } from './helpers.js';
 /**
  * Parse an EvolutionData result from the WASM kernel into a ShapeEvolution.
  * The C++ facade returns flat vectors of [inputHash, count, out1, out2, ..., inputHash, count, ...].
@@ -16,10 +17,10 @@ export declare function intersectWithHistory(k: OcctKernelWasm, Module: OcctWasm
 export declare function fuseAllWithHistory(k: OcctKernelWasm, Module: OcctWasmModule, shapes: KernelShape[], inputFaceHashes: number[], hashUpperBound: number, options?: BooleanOptions): DiagnosticOperationResult;
 /** N-way cut with face history over the base and every tool. Needs `booleanOp`. */
 export declare function cutAllWithHistory(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, tools: KernelShape[], inputFaceHashes: number[], hashUpperBound: number, options?: BooleanOptions): DiagnosticOperationResult;
-export declare function filletWithHistory(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, edges: KernelShape[], radius: number | [number, number] | ((edge: KernelShape) => number | [number, number]), inputFaceHashes: number[], hashUpperBound: number): OperationResult;
-export declare function chamferWithHistory(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, edges: KernelShape[], distance: number | [number, number] | ((edge: KernelShape) => number | [number, number]), inputFaceHashes: number[], hashUpperBound: number): OperationResult;
+export declare function filletWithHistory(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, edges: KernelShape[], radius: EdgeValueSpec, inputFaceHashes: number[], hashUpperBound: number): OperationResult;
+export declare function chamferWithHistory(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, edges: KernelShape[], distance: EdgeValueSpec, inputFaceHashes: number[], hashUpperBound: number): OperationResult;
 export declare function shellWithHistory(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, faces: KernelShape[], thickness: number, inputFaceHashes: number[], hashUpperBound: number, tolerance?: number): OperationResult;
 export declare function thickenWithHistory(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, thickness: number, inputFaceHashes: number[], hashUpperBound: number): OperationResult;
 export declare function offsetWithHistory(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, distance: number, inputFaceHashes: number[], hashUpperBound: number, tolerance?: number): OperationResult;
-export declare function draftWithHistory(k: OcctKernelWasm, shape: KernelShape, faces: KernelShape[], pullDirection: [number, number, number], angleDeg: number | ((face: KernelShape) => number)): OperationResult;
+export declare function draftWithHistory(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, faces: KernelShape[], pullDirection: [number, number, number], neutralPlane: [number, number, number], angleDeg: number | ((face: KernelShape) => number), inputFaceHashes: number[], hashUpperBound: number): OperationResult;
 export declare function applyComposedTransformWithHistory(transformFn: (shape: KernelShape, trsf: KernelType) => KernelShape, iterShapesFn: (shape: KernelShape, type: 'face') => KernelShape[], hashCodeFn: (shape: KernelShape, upperBound: number) => number, shape: KernelShape, transformHandle: KernelType, inputFaceHashes: number[], hashUpperBound: number): OperationResult;

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

@@ -1,4 +1,5 @@
 import { KernelShape, ShapeEvolution, ShapeType } from '../types.js';
+import { UnsupportedKernelOperationError } from '../unsupported.js';
 import { EmEvolutionData, OcctWasmHandle, OcctWasmModule, OcctKernelWasm, EmVectorUint32, EmVectorInt, EmVectorDouble } from './occtWasmTypes.js';
 export declare const noop: () => void;
 /** Build an opaque kernel handle for an arena-allocated WASM shape. */
@@ -24,11 +25,20 @@ export declare function readVecInt(vec: EmVectorInt): number[];
  * and any other transform-stack composition.
  */
 export declare function multiplyMatrices4x4(a: number[], b: number[]): number[];
+/** A fillet's start and end radius, or a chamfer's two setbacks. A number is both. */
+type EdgeValue = number | [number, number];
+export type EdgeValueSpec = EdgeValue | ((edge: KernelShape) => EdgeValue);
 /**
- * Resolve a callback-style radius/distance to a uniform number.
- * occt-wasm's fillet/chamfer take a single radius — uniform per call.
+ * Run a fillet or chamfer over `edges`, naming the edges it fails on. Edges
+ * that all take one value go to `uniform`, the single-value entry point every
+ * occt-wasm build has; otherwise `perEdge` gets each edge's pair as `first`
+ * and `second`.
  */
-export declare function resolveUniformRadius(edges: KernelShape[], radius: number | [number, number] | ((edge: KernelShape) => number | [number, number])): number;
+export declare function runEdgeTreatment<T>(Module: OcctWasmModule, edges: KernelShape[], value: EdgeValueSpec, uniform: (edgeVec: EmVectorUint32, value: number) => T, perEdge: (edgeVec: EmVectorUint32, first: EmVectorDouble, second: EmVectorDouble) => T): T;
+/** Each face's draft angle, in radians. */
+export declare function draftAnglesRad(faces: readonly KernelShape[], angleDeg: number | ((face: KernelShape) => number)): number[];
+/** The peer range still admits older builds, which lack the per-edge and unit entry points. */
+export declare function needsOcctWasm59(what: string): UnsupportedKernelOperationError;
 /**
  * Rotate a shape from the kernel's default Z-axis to an arbitrary direction.
  * Used by primitives whose creation API only takes a Z-aligned form.
@@ -39,3 +49,4 @@ export declare function parseEvolution(evo: EmEvolutionData): {
     id: number;
     evolution: ShapeEvolution;
 };
+export {};

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

@@ -17,13 +17,17 @@ type MeshFn = (shape: KernelShape, options: {
         faceHash: number;
     }>;
 };
+interface StepUnitOptions {
+    unit?: string | undefined;
+    modelUnit?: string | undefined;
+}
 export declare function exportSTEP(k: OcctKernelWasm, makeCompound: CompoundFn, shapes: KernelShape[]): string;
 export declare function exportSTL(mesh: MeshFn, shape: KernelShape, binary?: boolean, tolerance?: number, angularTolerance?: number): string | ArrayBuffer;
 export declare function importSTEP(k: OcctKernelWasm, data: string | ArrayBuffer): KernelShape[];
 export declare function importSTL(k: OcctKernelWasm, Module: OcctWasmModule, data: string | ArrayBuffer): KernelShape;
 export declare function exportIGES(k: OcctKernelWasm, makeCompound: CompoundFn, shapes: KernelShape[]): string;
 export declare function importIGES(k: OcctKernelWasm, data: string | ArrayBuffer): KernelShape[];
-export declare function exportSTEPAssembly(k: OcctKernelWasm, Module: OcctWasmModule, parts: StepAssemblyPart[], _options?: {
+export declare function exportSTEPAssembly(k: OcctKernelWasm, parts: StepAssemblyPart[], options?: {
     unit?: string;
 }): string;
 export declare function exportGLB(mesh: MeshFn, shape: KernelShape, tolerance: number): ArrayBuffer;
@@ -31,22 +35,18 @@ export declare function exportOBJ(mesh: MeshFn, shape: KernelShape, tolerance: n
 export declare function exportPLY(mesh: MeshFn, shape: KernelShape, tolerance: number): ArrayBuffer;
 export declare function toBREP(k: OcctKernelWasm, shape: KernelShape): string;
 export declare function fromBREP(k: OcctKernelWasm, data: string): KernelShape;
-export declare function createXCAFDocument(k: OcctKernelWasm, _Module: OcctWasmModule, shapes: Array<{
+interface XcafPart {
+    readonly shape: KernelShape;
+    readonly name?: string | undefined;
+    readonly color?: [number, number, number, number] | undefined;
+}
+export declare function createXCAFDocument(k: OcctKernelWasm, makeCompound: CompoundFn, shapes: Array<{
     shape: KernelShape;
     name: string;
     color?: [number, number, number, number] | undefined;
 }>): KernelType;
-export declare function writeXCAFToSTEP(k: OcctKernelWasm, doc: KernelType, _options?: {
-    unit?: string | undefined;
-    modelUnit?: string | undefined;
-}): string;
-export declare function exportSTEPConfigured(k: OcctKernelWasm, Module: OcctWasmModule, shapes: Array<{
-    shape: KernelShape;
-    name?: string | undefined;
-    color?: [number, number, number, number] | undefined;
-}>, _options?: {
-    unit?: string | undefined;
-    modelUnit?: string | undefined;
+export declare function writeXCAFToSTEP(k: OcctKernelWasm, doc: KernelType, options?: StepUnitOptions): string;
+export declare function exportSTEPConfigured(k: OcctKernelWasm, makeCompound: CompoundFn, shapes: XcafPart[], options?: StepUnitOptions & {
     schema?: number | undefined;
 }): string;
 export {};

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

@@ -1,13 +1,15 @@
 import { KernelShape } from '../types.js';
 import { OcctKernelWasm, OcctWasmModule } from './occtWasmTypes.js';
-export declare function fillet(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, edges: KernelShape[], radius: number | [number, number] | ((edge: KernelShape) => number | [number, number])): KernelShape;
-export declare function chamfer(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, edges: KernelShape[], distance: number | [number, number] | ((edge: KernelShape) => number | [number, number])): KernelShape;
+import { EdgeValueSpec } from './helpers.js';
+export declare function fillet(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, edges: KernelShape[], radius: EdgeValueSpec): KernelShape;
+export declare function chamfer(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, edges: KernelShape[], distance: EdgeValueSpec): KernelShape;
 export declare function chamferDistAngle(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, edges: KernelShape[], distance: number, angleDeg: number): KernelShape;
 export declare function shell(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, faces: KernelShape[], thickness: number, tolerance?: number): KernelShape;
 export declare function thicken(k: OcctKernelWasm, shape: KernelShape, thickness: number): KernelShape;
 export declare function offset(k: OcctKernelWasm, shape: KernelShape, distance: number, tolerance?: number): KernelShape;
 export declare function filletVariable(k: OcctKernelWasm, shape: KernelShape, spec: string): KernelShape;
-export declare function draft(k: OcctKernelWasm, shape: KernelShape, faces: KernelShape[], pullDirection: [number, number, number], _neutralPlane: [number, number, number], angleDeg: number | ((face: KernelShape) => number)): KernelShape;
+/** Draft every face in one operation about the plane through `neutralPlane` normal to the pull. */
+export declare function draft(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, faces: KernelShape[], pullDirection: [number, number, number], neutralPlane: [number, number, number], angleDeg: number | ((face: KernelShape) => number)): KernelShape;
 export declare function defeature(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, faces: KernelShape[]): KernelShape;
 export declare function offsetWire2D(k: OcctKernelWasm, wire: KernelShape, offset: number, joinType?: number | 'arc' | 'intersection' | 'tangent'): KernelShape;
 export declare function simplify(k: OcctKernelWasm, shape: KernelShape): KernelShape;