brepjs 20.12.13 → 20.12.15

package/dist/{importFns-BXiAHbyn.js → importFns-C9TUFscx.js}

@@ -1,12 +1,12 @@
-import { C as isSolid, G as _usingCtx, n as castResultShape, q as getKernel } from "./shapeTypes-DfBx__EF.js";
+import { C as isSolid, G as _usingCtx, S as isShell, _ as isCompound, n as castResultShape, q as getKernel } from "./shapeTypes-DiCMRU6Z.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-CTCsQIH_.js";
+import { S as subShapeCount, c as getFaces, u as getShells } from "./topologyQueryFns-CNOqc1rB.js";
 import { n as HASH_CODE_MAX } from "./constants-iraOnb2p.js";
-import { t as makeCompound } from "./solidBuilders-BZ1qXlFZ.js";
-import { u as igesUnsupportedError } from "./meshFns-Cp8uEpVt.js";
+import { t as makeCompound } from "./solidBuilders-Dzhk5L6w.js";
+import { u as igesUnsupportedError } from "./meshFns-BpBgKIIE.js";
 import { n as getAtOrThrow } from "./arrayAccess-BpgouNir.js";
-import { c as make2dBezierCurve, h as make2dThreePointArc, p as make2dSegmentCurve, t as Blueprint } from "./blueprint-BTccTqFy.js";
+import { c as make2dBezierCurve, h as make2dThreePointArc, p as make2dSegmentCurve, t as Blueprint } from "./blueprint-ku_wYIZl.js";
 // src/io/objExportFns.ts
 /** Read a vec3 from a typed array at the given vertex index. */
 function vec3At(arr, i) {
@@ -1314,9 +1314,20 @@ function exportSTEPConfigured(parts, options) {
 * 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.
+* casts against each body's triangles, because no kernel here can classify a point
+* against a solid.
 */
+/** The outline of `body`, read from the kernel; `shell` is the sewn shell it was built from. */
+function shellOutline(body, shell) {
+	let box;
+	let mesh;
+	const boxOf = () => box ??= getKernel().boundingBox(body.wrapped);
+	return {
+		box: boxOf,
+		mesh: () => mesh ??= meshShape(body, boxOf()),
+		facesInward: () => facesInward(shell, boxOf())
+	};
+}
 var RAY_LENGTH = Math.hypot(.5389, .6213, .5689);
 var RAY = [
 	.5389 / RAY_LENGTH,
@@ -1324,17 +1335,21 @@ var RAY = [
 	.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.
+* The parts to keep: `bodies` (each described by the same-index entry of
+* `outlines`) 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]
-	}] : []);
+function carveCavities(bodies, outlines, owned) {
+	const solids = bodies.flatMap((body, i) => {
+		const outline = outlines[i];
+		return isSolid(body) && outline !== void 0 ? [{
+			body,
+			outline
+		}] : [];
+	});
 	if (solids.length < 2) return [...bodies];
 	const voids = findVoids(solids);
 	const carved = /* @__PURE__ */ new Map();
@@ -1348,22 +1363,10 @@ function carveCavities(bodies, shells, owned) {
 }
 /** 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 boxes = solids.map(({ outline }) => outline.box());
+	const meshOf = (i) => solids[i].outline.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 isVoid = containers.map((around, j) => around.length > 0 && solids[j]?.outline.facesInward() === true);
 	const voids = /* @__PURE__ */ new Map();
 	containers.forEach((around, j) => {
 		if (!isVoid[j]) return;
@@ -1381,7 +1384,7 @@ function facesInward(shell, box) {
 	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])));
+		volume += dot(a, cross$1(vertexAt(mesh, t[i + 1]), vertexAt(mesh, t[i + 2])));
 	}
 	return volume < 0;
 }
@@ -1410,11 +1413,7 @@ 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
-	];
+	return vertexAt(mesh, mesh.triangles[0]);
 }
 function vertexAt(mesh, index) {
 	const i = (index ?? 0) * 3;
@@ -1431,32 +1430,247 @@ function insideMesh(p, mesh) {
 	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) => [
+var sub$1 = (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) => [
+var cross$1 = (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 e1 = sub$1(b, a);
+	const e2 = sub$1(c, a);
+	const h = cross$1(RAY, e2);
 	const det = dot(e1, h);
 	if (det === 0) return false;
-	const s = sub(p, a);
+	const s = sub$1(p, a);
 	const u = dot(s, h) / det;
 	if (u < 0 || u > 1) return false;
-	const q = cross(s, e1);
+	const q = cross$1(s, e1);
 	const v = dot(RAY, q) / det;
 	if (v < 0 || u + v > 1) return false;
 	return dot(e2, q) / det > 0;
 }
+// src/io/meshTopology.ts
+/**
+* The topology of the triangles in `positions` (nine coordinates per triangle),
+* welding vertices whose coordinates are identical.
+*
+* Returns `null` for a mesh that sewing might change rather than reproduce: a
+* non-finite coordinate, a triangle with a repeated vertex or no area, an edge
+* shared by more than two triangles, two triangles running the same direction
+* along their shared edge, or a closed body that encloses no volume.
+*/
+function analyzeMesh(positions) {
+	const welded = weld(positions);
+	if (welded === null) return null;
+	const { vertices, corners } = welded;
+	const triangleCount = corners.length / 3;
+	if (triangleCount === 0) return null;
+	for (let t = 0; t < triangleCount; t++) if (!hasArea(vertices, corners, t)) return null;
+	const edges = pairEdges(corners, vertices.length / 3);
+	if (edges === null) return null;
+	const bodies = [];
+	const stamp = new Int32Array(vertices.length / 3).fill(-1);
+	for (const triangles of edges.groups) {
+		const body = describeBody(triangles, vertices, corners, edges.boundary, stamp, bodies.length);
+		if (body === null) return null;
+		bodies.push(body);
+	}
+	return {
+		vertexCount: vertices.length / 3,
+		edgeCount: edges.count,
+		bodies,
+		vertices,
+		corners
+	};
+}
+/** What nesting needs to know about a closed body of `mesh`, read from its triangles. */
+function meshBodyOutline(mesh, body) {
+	const triangles = new Uint32Array(body.triangles.length * 3);
+	body.triangles.forEach((t, i) => {
+		triangles.set(mesh.corners.subarray(t * 3, t * 3 + 3), i * 3);
+	});
+	const box = {
+		min: [
+			Infinity,
+			Infinity,
+			Infinity
+		],
+		max: [
+			-Infinity,
+			-Infinity,
+			-Infinity
+		]
+	};
+	for (const v of triangles) for (let axis = 0; axis < 3; axis++) {
+		const c = mesh.vertices[v * 3 + axis] ?? 0;
+		if (c < (box.min[axis] ?? 0)) box.min[axis] = c;
+		if (c > (box.max[axis] ?? 0)) box.max[axis] = c;
+	}
+	return {
+		box: () => box,
+		mesh: () => ({
+			vertices: mesh.vertices,
+			triangles
+		}),
+		facesInward: () => body.volume < 0
+	};
+}
+function weld(positions) {
+	if (positions.length % 9 !== 0) return null;
+	const corners = new Uint32Array(positions.length / 3);
+	const index = /* @__PURE__ */ new Map();
+	const coords = [];
+	for (let i = 0; i < corners.length; i++) {
+		const x = positions[i * 3] ?? NaN;
+		const y = positions[i * 3 + 1] ?? NaN;
+		const z = positions[i * 3 + 2] ?? NaN;
+		if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) return null;
+		const key = `${x},${y},${z}`;
+		let v = index.get(key);
+		if (v === void 0) {
+			v = index.size;
+			index.set(key, v);
+			coords.push(x, y, z);
+		}
+		corners[i] = v;
+	}
+	return {
+		vertices: Float64Array.from(coords),
+		corners
+	};
+}
+function hasArea(vertices, corners, t) {
+	const a = corners[t * 3] ?? 0;
+	const b = corners[t * 3 + 1] ?? 0;
+	const c = corners[t * 3 + 2] ?? 0;
+	if (a === b || b === c || c === a) return false;
+	const n = cross(sub(point(vertices, b), point(vertices, a)), sub(point(vertices, c), point(vertices, a)));
+	return n[0] !== 0 || n[1] !== 0 || n[2] !== 0;
+}
+/**
+* Match every edge with the triangle on its other side. Groups triangles joined
+* by shared edges, and counts each triangle's unshared (boundary) edges.
+*/
+function pairEdges(corners, vertexCount) {
+	const triangleCount = corners.length / 3;
+	const parent = new Int32Array(triangleCount).map((_, i) => i);
+	const find = (t) => {
+		let root = t;
+		while (parent[root] !== root) root = parent[root] ?? root;
+		while (parent[t] !== root) {
+			const next = parent[t] ?? root;
+			parent[t] = root;
+			t = next;
+		}
+		return root;
+	};
+	const open = /* @__PURE__ */ new Map();
+	for (let t = 0; t < triangleCount; t++) for (let k = 0; k < 3; k++) {
+		const a = corners[t * 3 + k] ?? 0;
+		const b = corners[t * 3 + (k + 1) % 3] ?? 0;
+		const forward = a < b;
+		const key = forward ? a * vertexCount + b : b * vertexCount + a;
+		const first = open.get(key);
+		if (first === void 0) {
+			open.set(key, forward ? t + 1 : -(t + 1));
+			continue;
+		}
+		if (first === 0 || first > 0 === forward) return null;
+		parent[find(t)] = find(Math.abs(first) - 1);
+		open.set(key, 0);
+	}
+	const boundary = new Uint8Array(triangleCount);
+	for (const first of open.values()) {
+		const t = Math.abs(first) - 1;
+		if (first !== 0) boundary[t] = (boundary[t] ?? 0) + 1;
+	}
+	const groupOf = /* @__PURE__ */ new Map();
+	for (let t = 0; t < triangleCount; t++) {
+		const root = find(t);
+		const group = groupOf.get(root);
+		if (group) group.push(t);
+		else groupOf.set(root, [t]);
+	}
+	return {
+		count: open.size,
+		groups: [...groupOf.values()],
+		boundary
+	};
+}
+function describeBody(triangles, vertices, corners, boundary, stamp, id) {
+	let vertexCount = 0;
+	let boundaryEdges = 0;
+	for (const t of triangles) {
+		boundaryEdges += boundary[t] ?? 0;
+		for (let k = 0; k < 3; k++) {
+			const v = corners[t * 3 + k] ?? 0;
+			if (stamp[v] !== id) {
+				stamp[v] = id;
+				vertexCount++;
+			}
+		}
+	}
+	const closed = boundaryEdges === 0;
+	let volume = 0;
+	if (closed) {
+		const enclosed = enclosedVolume(triangles, vertices, corners);
+		if (Math.abs(enclosed.value) <= FLAT_VOLUME * enclosed.size ** 3) return null;
+		volume = enclosed.value;
+	}
+	return {
+		triangles,
+		vertexCount,
+		edgeCount: (triangles.length * 3 + boundaryEdges) / 2,
+		closed,
+		volume
+	};
+}
+/** Below this fraction of its size cubed, a closed body is a flat sheet with no inside. */
+var FLAT_VOLUME = 1e-12;
+/**
+* Signed volume by the divergence theorem, measured from the body's first vertex
+* so a body far from the origin keeps its precision, and the body's size: its
+* farthest coordinate offset from that vertex.
+*/
+function enclosedVolume(triangles, vertices, corners) {
+	const origin = point(vertices, corners[(triangles[0] ?? 0) * 3] ?? 0);
+	let sum = 0;
+	let size = 0;
+	for (const t of triangles) {
+		const a = sub(point(vertices, corners[t * 3] ?? 0), origin);
+		const n = cross(sub(point(vertices, corners[t * 3 + 1] ?? 0), origin), sub(point(vertices, corners[t * 3 + 2] ?? 0), origin));
+		sum += a[0] * n[0] + a[1] * n[1] + a[2] * n[2];
+		size = Math.max(size, Math.abs(a[0]), Math.abs(a[1]), Math.abs(a[2]));
+	}
+	return {
+		value: sum / 6,
+		size
+	};
+}
+function point(vertices, v) {
+	return [
+		vertices[v * 3] ?? 0,
+		vertices[v * 3 + 1] ?? 0,
+		vertices[v * 3 + 2] ?? 0
+	];
+}
+var sub = (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]
+];
 // src/io/ioUtils.ts
 /**
 * Shared mesh-to-solid sewing utilities for mesh importers.
@@ -1473,11 +1687,21 @@ function rayHits(p, a, b, c) {
 * inward-facing closed shell inside another body is a cavity, cut from that
 * body. The caller keeps ownership of `faces`.
 *
+* Pass `mesh`, the {@link sewableTopology} of the triangles `faces` were built
+* from (face `i` from triangle `i`), to skip the kernel's orientation
+* repair, which is nearly all of the time: when the sewn faces have exactly the
+* vertices, edges, and shells it predicts, each closed body becomes a solid
+* straight from its shell.
+*
 * @throws When the kernel cannot sew the faces at all.
 */
-function sewFacesIntoSolids(faces, tolerance) {
+function sewFacesIntoSolids(faces, tolerance, mesh) {
 	try {
 		var _usingCtx$2 = _usingCtx();
+		if (mesh) {
+			const sewn = sewKnownMesh(faces, tolerance, mesh);
+			if (sewn !== null) return sewn;
+		}
 		const kernel = getKernel();
 		const solid = solidify(faces, tolerance);
 		if (solid !== null) return solid;
@@ -1488,11 +1712,15 @@ function sewFacesIntoSolids(faces, tolerance) {
 		_usingCtx$2.u(sewn);
 		const owned = [];
 		try {
-			const parts = carveCavities(shells.map((shell) => {
+			const bodies = [];
+			const outlines = [];
+			for (const shell of shells) {
 				const body = solidifyShell(shell.wrapped, tolerance);
 				owned.push(body);
-				return body;
-			}), shells, owned);
+				bodies.push(body);
+				outlines.push(shellOutline(body, shell));
+			}
+			const parts = carveCavities(bodies, outlines, owned);
 			if (hasLooseFaces) for (const face of facesOutsideShells(sewn, shells)) {
 				const copy = castResultShape(kernel.copyShape(face.wrapped));
 				owned.push(copy);
@@ -1508,6 +1736,96 @@ function sewFacesIntoSolids(faces, tolerance) {
 		_usingCtx$2.d();
 	}
 }
+/**
+* {@link sewFacesIntoSolids} for a mesh whose topology is known, or `null` when
+* the kernel's sewing doesn't reproduce it exactly (say, it merged two vertices
+* within tolerance, or a triangle built no face), leaving the caller to repair.
+*/
+function sewKnownMesh(faces, tolerance, mesh) {
+	try {
+		var _usingCtx3 = _usingCtx();
+		if (faces.length !== mesh.corners.length / 3) return null;
+		const sewn = castResultShape(getKernel().sew(faces, tolerance));
+		const shellBodies = mesh.bodies.filter((body) => body.triangles.length > 1);
+		if (!hasTopology(sewn, mesh.vertexCount, mesh.edgeCount, faces.length) || getShells(sewn).length !== shellBodies.length) {
+			sewn[Symbol.dispose]();
+			return null;
+		}
+		const [single, ...more] = mesh.bodies;
+		if (single === void 0 || shellBodies.length === 0) return sewn;
+		if (more.length > 0) try {
+			var _usingCtx4 = _usingCtx();
+			_usingCtx4.u(sewn);
+			return sewBodies(faces, tolerance, mesh);
+		} catch (_) {
+			_usingCtx4.e = _;
+		} finally {
+			_usingCtx4.d();
+		}
+		if (!single.closed) return sewn;
+		const shell = _usingCtx3.u(sewn);
+		return isShell(shell) ? outwardSolid(shell, single.volume) : null;
+	} catch (_) {
+		_usingCtx3.e = _;
+	} finally {
+		_usingCtx3.d();
+	}
+}
+/** Each body of `mesh` sewn on its own, so its triangles say which way it faces. */
+function sewBodies(faces, tolerance, mesh) {
+	const kernel = getKernel();
+	const owned = [];
+	try {
+		const bodies = [];
+		const outlines = [];
+		const looseFaces = [];
+		for (const body of mesh.bodies) {
+			const own = body.triangles.flatMap((t) => faces[t] ?? []);
+			const [face] = own;
+			if (own.length === 1 && face !== void 0) {
+				const copy = castResultShape(kernel.copyShape(face));
+				owned.push(copy);
+				looseFaces.push(copy);
+				continue;
+			}
+			const shell = castResultShape(kernel.sew(own, tolerance));
+			owned.push(shell);
+			if (!isShell(shell) || !hasTopology(shell, body.vertexCount, body.edgeCount, own.length)) return null;
+			if (!body.closed) {
+				bodies.push(shell);
+				outlines.push(void 0);
+				continue;
+			}
+			const solid = outwardSolid(shell, body.volume);
+			owned.push(solid);
+			bodies.push(solid);
+			outlines.push(meshBodyOutline(mesh, body));
+		}
+		return makeCompound([...carveCavities(bodies, outlines, owned), ...looseFaces]);
+	} finally {
+		for (const shape of owned) shape[Symbol.dispose]();
+	}
+}
+function hasTopology(shape, vertices, edges, faces) {
+	return subShapeCount(shape, "face") === faces && subShapeCount(shape, "edge") === edges && subShapeCount(shape, "vertex") === vertices;
+}
+/**
+* The solid bounded by a consistently oriented closed shell, turned outward when
+* the shell's triangles face in (`volume` negative).
+*/
+function outwardSolid(shell, volume) {
+	try {
+		var _usingCtx5 = _usingCtx();
+		const kernel = getKernel();
+		if (volume > 0) return castResultShape(kernel.solidFromShell(shell.wrapped));
+		const reversed = _usingCtx5.u(castResultShape(kernel.reverseShape(shell.wrapped)));
+		return castResultShape(kernel.solidFromShell(reversed.wrapped));
+	} catch (_) {
+		_usingCtx5.e = _;
+	} finally {
+		_usingCtx5.d();
+	}
+}
 function facesOutsideShells(sewn, shells) {
 	const kernel = getKernel();
 	const inShells = /* @__PURE__ */ new Map();
@@ -1548,17 +1866,78 @@ function solidifyShell(shell, tolerance) {
 	}
 }
 /**
-* Build triangular B-Rep faces from vertex data and sew them into solids.
+* A compound of one face per triangle, in order, sharing vertices and edges so
+* that sewing it is cheap. The kernel's STL reader is the only way to build
+* faces that share them; a text STL carries every coordinate exactly, because a
+* number prints as the shortest decimal that parses back to it. `null` when the
+* kernel returns anything else (some read an STL straight into a solid).
+*/
+function readerFacets(triangles) {
+	const lines = ["solid mesh"];
+	for (const [a, b, c] of triangles) lines.push("facet normal 0 0 0", "outer loop", `vertex ${a[0]} ${a[1]} ${a[2]}`, `vertex ${b[0]} ${b[1]} ${b[2]}`, `vertex ${c[0]} ${c[1]} ${c[2]}`, "endloop", "endfacet");
+	lines.push("endsolid mesh", "");
+	let facets;
+	try {
+		facets = castResultShape(getKernel().importSTL(lines.join("\n")));
+	} catch {
+		return null;
+	}
+	if (isCompound(facets) && subShapeCount(facets, "face") === triangles.length) return facets;
+	facets[Symbol.dispose]();
+	return null;
+}
+/**
+* The {@link analyzeMesh} topology of the triangles in `positions` (nine
+* coordinates per triangle) for {@link sewFacesIntoSolids}, or `null` when the
+* mesh fails the analysis or the kernel's sewing may reorient faces.
+*/
+function sewableTopology(positions) {
+	if (positions === null || getKernel().capabilities.sewKeepsOrientation !== true) return null;
+	return analyzeMesh(positions);
+}
+/** {@link sewableTopology} of `triangles`, without copying them on a kernel that can't use it. */
+function sewableTriangles(triangles) {
+	if (getKernel().capabilities.sewKeepsOrientation !== true) return null;
+	return sewableTopology(trianglePositions(triangles));
+}
+function trianglePositions(triangles) {
+	const positions = new Float64Array(triangles.length * 9);
+	triangles.forEach((triangle, t) => {
+		triangle.forEach((vertex, k) => {
+			positions.set(vertex, t * 9 + k * 3);
+		});
+	});
+	return positions;
+}
+/**
+* Build triangular B-Rep faces from vertex data and sew them into solids with
+* {@link sewFacesIntoSolids}.
 *
-* For each triple of vertex coordinates, calls `kernel.buildTriFace` to create
-* a planar triangular face, then sews them with {@link sewFacesIntoSolids}.
+* A mesh with a {@link sewableTopology} gets its faces from the kernel's STL
+* reader, already sharing edges, when the kernel reads an STL into faces.
+* Otherwise `kernel.buildTriFace` builds a planar face per triangle.
 *
 * @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).
+* @param mesh - The triangles' {@link sewableTopology}, when the caller already has it.
 * @returns A `Result` wrapping the sewn shape, or an error.
 */
-function sewMeshToSolid(triangles, errorCode, tolerance = 1e-6) {
+function sewMeshToSolid(triangles, errorCode, tolerance = 1e-6, mesh = sewableTriangles(triangles)) {
+	const facets = mesh ? readerFacets(triangles) : null;
+	if (facets !== null) try {
+		var _usingCtx6 = _usingCtx();
+		_usingCtx6.u(facets);
+		try {
+			return ok(sewFacesIntoSolids(getFaces(facets).map((face) => face.wrapped), tolerance, mesh));
+		} catch (e) {
+			return err(ioError(errorCode, "Failed to sew triangular faces", e));
+		}
+	} catch (_) {
+		_usingCtx6.e = _;
+	} finally {
+		_usingCtx6.d();
+	}
 	const kernel = getKernel();
 	const triFaces = [];
 	for (const [va, vb, vc] of triangles) {
@@ -1567,13 +1946,53 @@ function sewMeshToSolid(triangles, errorCode, tolerance = 1e-6) {
 	}
 	if (triFaces.length === 0) return err(ioError(errorCode, "No valid triangular faces could be built"));
 	try {
-		return ok(sewFacesIntoSolids(triFaces, tolerance));
+		return ok(sewFacesIntoSolids(triFaces, tolerance, mesh));
 	} catch (e) {
 		return err(ioError(errorCode, "Failed to sew triangular faces", e));
 	} finally {
 		for (const triFace of triFaces) kernel.dispose(triFace);
 	}
 }
+// src/io/stlTriangles.ts
+/**
+* The triangles of an STL file, read in JavaScript so the importer can check the
+* mesh's topology before the kernel sews it.
+*/
+var HEADER_BYTES = 80;
+var FACET_BYTES = 50;
+/** OCCT's reader takes anything shorter than one binary facet as text. */
+var MIN_BINARY_BYTES = 134;
+var VERTEX_LINE = /^[ \t]*vertex[ \t]+(\S+)[ \t]+(\S+)[ \t]+(\S+)/gim;
+/**
+* The corner coordinates of every facet, nine per triangle in file order, or
+* `null` when the file is malformed. Text versus binary is decided as OCCT's
+* reader decides it: binary when any of the first 134 bytes is above `~`.
+*/
+function stlTrianglePositions(data) {
+	const bytes = new Uint8Array(data);
+	return isText(bytes) ? textPositions(bytes) : binaryPositions(data);
+}
+function isText(bytes) {
+	if (bytes.length < MIN_BINARY_BYTES) return true;
+	for (let i = 0; i < MIN_BINARY_BYTES; i++) if ((bytes[i] ?? 0) > 126) return false;
+	return true;
+}
+function textPositions(bytes) {
+	const coords = [];
+	for (const [, x, y, z] of new TextDecoder().decode(bytes).matchAll(VERTEX_LINE)) coords.push(Number(x), Number(y), Number(z));
+	return coords.length % 9 === 0 ? Float64Array.from(coords) : null;
+}
+function binaryPositions(data) {
+	const view = new DataView(data);
+	const count = view.getUint32(HEADER_BYTES, true);
+	if (84 + count * FACET_BYTES > data.byteLength) return null;
+	const positions = new Float64Array(count * 9);
+	for (let t = 0; t < count; t++) {
+		const corners = 84 + t * FACET_BYTES + 12;
+		for (let k = 0; k < 9; k++) positions[t * 9 + k] = view.getFloat32(corners + k * 4, true);
+	}
+	return positions;
+}
 // src/io/importFns.ts
 /**
 * Functional file import operations using branded shape types.
@@ -1625,10 +2044,12 @@ var STL_SEW_TOLERANCE = 1e-6;
 *   compound for several bodies), or an error if parsing fails.
 *
 * @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.
+* the triangle count. On the default occt-wasm kernel a mesh whose shared edges
+* each join two consistently wound triangles takes about 0.3 seconds per 10,000
+* triangles (about 1.7 seconds for 50,000). One that needs its winding repaired
+* takes about 2 seconds per 10,000 (about 13 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
@@ -1646,7 +2067,8 @@ async function importSTL(blob) {
 			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));
+			const mesh = sewableTopology(stlTrianglePositions(data));
+			return ok(sewFacesIntoSolids(faces, STL_SEW_TOLERANCE, mesh));
 		} catch (_) {
 			_usingCtx$1.e = _;
 		} finally {