brepjs 20.12.7 → 20.12.8

package/dist/{importFns-Bp-p0jiP.js → importFns-CwrJsNvg.js}

@@ -1,8 +1,12 @@
-import { n as castResultShape, q as getKernel } from "./shapeTypes-BNGu103j.js";
+import { C as isSolid, G as _usingCtx, n as castResultShape, q as getKernel } from "./shapeTypes-CIH-8d_a.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 { S as subShapeCount, c as getFaces, u as getShells } from "./topologyQueryFns-Cp0yekBh.js";
+import { n as HASH_CODE_MAX } from "./constants-iraOnb2p.js";
+import { t as makeCompound } from "./solidBuilders-q_hwYsdo.js";
+import { u as igesUnsupportedError } from "./meshFns-BGoJU6_P.js";
 import { n as getAtOrThrow } from "./arrayAccess-BpgouNir.js";
-import { c as make2dBezierCurve, h as make2dThreePointArc, p as make2dSegmentCurve, t as Blueprint } from "./blueprint-BS50D3J_.js";
+import { c as make2dBezierCurve, h as make2dThreePointArc, p as make2dSegmentCurve, t as Blueprint } from "./blueprint-RqemOtg5.js";
 // 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 err(ioError(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) => 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 = 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 = getKernel();
+	let current = body;
+	for (const inner of voids) try {
+		const next = 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 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 = _usingCtx();
+		const kernel = getKernel();
+		const solid = solidify(faces, tolerance);
+		if (solid !== null) return solid;
+		const sewn = castResultShape(kernel.sew(faces, tolerance));
+		const shells = getShells(sewn);
+		const hasLooseFaces = shells.reduce((n, shell) => n + subShapeCount(shell, "face"), 0) !== 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 = castResultShape(kernel.copyShape(face.wrapped));
+				owned.push(copy);
+				parts.push(copy);
+			}
+			return 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 = getKernel();
+	const inShells = /* @__PURE__ */ new Map();
+	for (const shell of shells) for (const face of getFaces(shell)) {
+		const hash = kernel.hashCode(face.wrapped, HASH_CODE_MAX);
+		const bucket = inShells.get(hash);
+		if (bucket) bucket.push(face.wrapped);
+		else inShells.set(hash, [face.wrapped]);
+	}
+	return getFaces(sewn).filter((face) => {
+		return !inShells.get(kernel.hashCode(face.wrapped, 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 = castResultShape(getKernel().sewAndSolidify(faces, tolerance));
+	} catch {
+		return null;
+	}
+	if (isSolid(shape)) return shape;
+	shape[Symbol.dispose]();
+	return null;
+}
+function solidifyShell(shell, tolerance) {
+	const kernel = getKernel();
+	const faces = kernel.iterShapes(shell, "face");
+	try {
+		return solidify(faces, tolerance) ?? 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 = 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 err(ioError(errorCode, "No valid triangular faces could be built"));
+	try {
+		return ok(sewFacesIntoSolids(triFaces, tolerance));
+	} catch (e) {
+		return err(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 err(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 = getKernel().importSTL(data);
-		if (shape.IsNull()) return err(ioError("STL_IMPORT_FAILED", "Failed to create solid from STL mesh"));
-		return ok(castResultShape(shape));
+		try {
+			var _usingCtx$1 = _usingCtx();
+			const data = await blob.arrayBuffer();
+			const raw = getKernel().importSTL(data);
+			if (raw.IsNull()) return err(ioError("STL_IMPORT_FAILED", "Failed to create solid from STL mesh"));
+			const shape = castResultShape(raw);
+			if (isSolid(shape)) return ok(shape);
+			const facets = _usingCtx$1.u(shape);
+			const faces = getFaces(facets).map((f) => f.wrapped);
+			return ok(sewFacesIntoSolids(faces, STL_SEW_TOLERANCE));
+		} catch (_) {
+			_usingCtx$1.e = _;
+		} finally {
+			_usingCtx$1.d();
+		}
 	} catch (e) {
 		return err(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 ok(castResultShape(shapes[0]));
 	} catch (e) {
-		return err(ioError("IGES_IMPORT_FAILED", "Failed to load IGES file", e));
+		return err(igesUnsupportedError("importIGES", e) ?? ioError("IGES_IMPORT_FAILED", "Failed to load IGES file", e));
 	}
 }
-export { importSVG as a, blueprintToDXF as c, exportGltf as d, exportOBJ as f, exportSTEPConfigured as i, exportDXF as l, importSTEP as n, importSVGPathD as o, importSTL as r, exportThreeMF as s, importIGES as t, exportGlb as u };
+export { exportSTEPConfigured as a, exportThreeMF as c, exportGlb as d, exportGltf as f, sewMeshToSolid as i, blueprintToDXF as l, importSTEP as n, importSVG as o, exportOBJ as p, importSTL as r, importSVGPathD as s, importIGES as t, exportDXF as u };

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-Djbb4PUC.cjs");
+const require_importFns = require("./importFns-BiRpt227.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-BGoJU6_P.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-CwrJsNvg.js";
 export { blueprintToDXF, exportDXF, exportGlb, exportGltf, exportIGES, exportOBJ, exportSTEP, exportSTEPConfigured, exportSTL, exportThreeMF, importIGES, importSTEP, importSTL, importSVG, importSVGPathD };

package/dist/kernel/occtWasm/occtWasmAdapter.cjs

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

package/dist/kernel/occtWasm/occtWasmAdapter.js

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

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

@@ -229,8 +229,10 @@ export interface OcctKernelWasm {
     importStep(data: string): number;
     exportStep(id: number): string;
     importStl(data: string): number;
-    importIges(data: string): number;
-    exportIges(id: number): string;
+    /** Absent from published occt-wasm builds (no IGES translator), so callers feature-detect. */
+    importIges?(data: string): number;
+    /** Absent from published occt-wasm builds (no IGES translator), so callers feature-detect. */
+    exportIges?(id: number): string;
     exportStl(id: number, linearDeflection: number, ascii: boolean): string;
     toBREP(id: number): string;
     fromBREP(data: string): number;

package/dist/{loftFns-DGV1z2NJ.cjs → loftFns-DgkK4Kj_.cjs}

@@ -1,4 +1,4 @@
-const require_shapeTypes = require("./shapeTypes-MUEH4XuH.cjs");
+const require_shapeTypes = require("./shapeTypes-DmThK_oa.cjs");
 const require_errors = require("./errors-O_blYTWT.cjs");
 const require_types = require("./types-CjF9Rofr.cjs");
 const require_vecOps = require("./vecOps-CrGEPPQM.cjs");

package/dist/{loftFns-DQ7Z29n3.js → loftFns-lwzTh1fI.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-BNGu103j.js";
+import { G as _usingCtx, T as isWire, h as disposeResultShape, n as castResultShape, q as getKernel, x as isShape3D } from "./shapeTypes-CIH-8d_a.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";

package/dist/{measureFns-BdSjw5fr.cjs → measureFns-D_RRjCZg.cjs}

@@ -1,7 +1,7 @@
-const require_shapeTypes = require("./shapeTypes-MUEH4XuH.cjs");
+const require_shapeTypes = require("./shapeTypes-DmThK_oa.cjs");
 const require_errors = require("./errors-O_blYTWT.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-C_fXO6xL.cjs");
-const require_faceFns = require("./faceFns-C-2ttg8X.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-CXbCFaU2.cjs");
+const require_faceFns = require("./faceFns-C4NOGZBg.cjs");
 // src/measurement/measureCache.ts
 var cache = /* @__PURE__ */ new WeakMap();
 function getCachedMeasurement(shape, key) {

package/dist/{measureFns-BrdCH4cH.js → measureFns-Q3K25IfN.js}

@@ -1,7 +1,7 @@
-import { q as getKernel } from "./shapeTypes-BNGu103j.js";
+import { q as getKernel } from "./shapeTypes-CIH-8d_a.js";
 import { E as ok, d as validationError, g as err, t as BrepErrorCode } from "./errors-BTccWbtE.js";
-import { E as kernelCallRaw } from "./topologyQueryFns-CltEv7Pi.js";
-import { m as uvBounds } from "./faceFns-Q87HCJrp.js";
+import { E as kernelCallRaw } from "./topologyQueryFns-Cp0yekBh.js";
+import { m as uvBounds } from "./faceFns-BgRNa5vx.js";
 // src/measurement/measureCache.ts
 var cache = /* @__PURE__ */ new WeakMap();
 function getCachedMeasurement(shape, key) {

package/dist/measurement.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_measureFns = require("./measureFns-BdSjw5fr.cjs");
-const require_principalBoxFns = require("./principalBoxFns-CiXzjOkr.cjs");
+const require_measureFns = require("./measureFns-D_RRjCZg.cjs");
+const require_principalBoxFns = require("./principalBoxFns-IY8FfPVj.cjs");
 exports.createDistanceQuery = require_measureFns.createDistanceQuery;
 exports.measureArea = require_measureFns.measureArea;
 exports.measureDistance = require_measureFns.measureDistance;

package/dist/measurement.js

@@ -1,3 +1,3 @@
-import { a as measureDistance, c as measureLinearProps, d as measureVolumeProps, l as measureSurfaceProps, n as measureArea, o as measureDistanceProps, s as measureLength, t as createDistanceQuery, u as measureVolume } from "./measureFns-BrdCH4cH.js";
-import { t as principalBoundingBox } from "./principalBoxFns-RMZItjfR.js";
+import { a as measureDistance, c as measureLinearProps, d as measureVolumeProps, l as measureSurfaceProps, n as measureArea, o as measureDistanceProps, s as measureLength, t as createDistanceQuery, u as measureVolume } from "./measureFns-Q3K25IfN.js";
+import { t as principalBoundingBox } from "./principalBoxFns-Dcp9gg5e.js";
 export { createDistanceQuery, measureArea, measureDistance, measureDistanceProps, measureLength, measureLinearProps, measureSurfaceProps, measureVolume, measureVolumeProps, principalBoundingBox };

package/dist/{meshFns-UE8tByyw.js → meshFns-BGoJU6_P.js}

@@ -1,7 +1,8 @@
-import { q as getKernel, ut as qualityDeflection } from "./shapeTypes-BNGu103j.js";
-import { E as ok, g as err, r as ioError } from "./errors-BTccWbtE.js";
-import { d as getSolids, n as getBounds } from "./topologyQueryFns-CltEv7Pi.js";
-import { t as getFaceOrigins } from "./originTrackingFns-c2qgRZ_9.js";
+import { q as getKernel, ut as qualityDeflection } from "./shapeTypes-CIH-8d_a.js";
+import { j as isUnsupportedKernelOperationError } from "./occtWasmAdapter-BCCwaYkq.js";
+import { E as ok, g as err, r as ioError, t as BrepErrorCode, u as unsupportedError } from "./errors-BTccWbtE.js";
+import { d as getSolids, n as getBounds } from "./topologyQueryFns-Cp0yekBh.js";
+import { d as getFaceOrigins } from "./solidBuilders-q_hwYsdo.js";
 // src/topology/meshCache.ts
 /**
 * Build a parameter key for the inner cache map (excludes shape identity).
@@ -107,6 +108,16 @@ function createMeshCache() {
 		}
 	};
 }
+// src/io/igesSupport.ts
+/**
+* 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.
+*/
+function igesUnsupportedError(operation, cause) {
+	if (!isUnsupportedKernelOperationError(cause)) return null;
+	const kernel = getKernel().kernelId;
+	return unsupportedError(BrepErrorCode.UNSUPPORTED_CAPABILITY, `${operation}: the ${kernel} kernel has no IGES support`, cause, { kernel }, "Exchange the model as STEP (importSTEP / exportSTEP) instead");
+}
 // src/topology/meshFns.ts
 /**
 * Meshing and export functions — functional replacements for Shape mesh/export methods.
@@ -297,13 +308,16 @@ function exportSTL(shape, opts = {}) {
 * Export a shape as an IGES file Blob.
 *
 * @returns Ok with a Blob (MIME type `application/iges`), or Err on failure.
+*
+* @remarks The default occt-wasm kernel is built without an IGES translator, so
+* there this returns an `UNSUPPORTED_CAPABILITY` error; export STEP instead.
 */
 function exportIGES(shape) {
 	try {
 		const igesString = getKernel().exportIGES([shape.wrapped]);
 		return ok(new Blob([igesString], { type: "application/iges" }));
 	} catch (e) {
-		return err(ioError("IGES_EXPORT_FAILED", "Failed to write IGES file", e));
+		return err(igesUnsupportedError("exportIGES", e) ?? ioError("IGES_EXPORT_FAILED", "Failed to write IGES file", e));
 	}
 }
 /**
@@ -436,4 +450,4 @@ async function meshLODsProgressive(shape, options = {}) {
 	}
 	return results;
 }
-export { meshEdges as a, meshMultiLOD as c, clearMeshCache as d, createMeshCache as f, mesh as i, scaleDefaultTolerance as l, exportSTEP as n, meshLODs as o, exportSTL as r, meshLODsProgressive as s, exportIGES as t, buildMeshCacheKey as u };
+export { meshEdges as a, meshMultiLOD as c, buildMeshCacheKey as d, clearMeshCache as f, mesh as i, scaleDefaultTolerance as l, exportSTEP as n, meshLODs as o, createMeshCache as p, exportSTL as r, meshLODsProgressive as s, exportIGES as t, igesUnsupportedError as u };