brepjs 18.119.2 → 18.119.4

package/dist/{loftFns-ChHjzUK-.cjs → loftFns-BdpZ8FMN.cjs}

@@ -1,5 +1,5 @@
-const require_shapeTypes = require("./shapeTypes-Bpsu5KJO.cjs");
-const require_errors = require("./errors-CJU8CHng.cjs");
+const require_shapeTypes = require("./shapeTypes-CkcIL7zv.cjs");
+const require_errors = require("./errors-RHkKO5bZ.cjs");
 const require_types = require("./types-KjA8tY4Y.cjs");
 const require_vecOps = require("./vecOps-CCnJt-yH.cjs");
 //#region src/operations/extrudeUtils.ts
@@ -337,111 +337,6 @@ function guidedSweep(profile, spine, guides, options = {}) {
 	}
 }
 //#endregion
-//#region src/operations/extrudeFns.ts
-/**
-* Basic extrusion operations — extrude and revolve.
-*
-* Sweep-based operations (sweep, supportExtrude, complexExtrude, twistExtrude)
-* have moved to `./sweepFns.js`.
-*/
-/**
-* Extrude a face along a vector to produce a solid.
-*
-* @param face - The planar face to extrude.
-* @param extrusionVec - Direction and magnitude of the extrusion as `[x, y, z]`.
-* @returns `Result` containing the extruded solid, or an error if validation or operation fails.
-*/
-function extrude(face, extrusionVec) {
-	if (require_shapeTypes.getKernel().isNull(face.wrapped)) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, "extrude: face is a null shape"));
-	if (require_vecOps.vecLength(extrusionVec) < 1e-10) return require_errors.err(require_errors.validationError("EXTRUDE_ZERO_VECTOR", "extrude: extrusion vector has zero length"));
-	try {
-		const kernel = require_shapeTypes.getKernel();
-		const len = require_vecOps.vecLength(extrusionVec);
-		const dir = require_vecOps.vecNormalize(extrusionVec);
-		const shape = kernel.extrude(face.wrapped, [...dir], len);
-		const solid = require_shapeTypes.createSolid(kernel.downcast(shape, "solid"));
-		require_shapeTypes.disposeDowncastSource(shape, solid);
-		return require_errors.ok(solid);
-	} catch (e) {
-		return require_errors.err(require_errors.kernelError("EXTRUDE_FAILED", "Extrusion operation failed", e, {
-			operation: "extrude",
-			vectorLength: require_vecOps.vecLength(extrusionVec)
-		}));
-	}
-}
-/**
-* Revolve a face around an axis to create a solid of revolution.
-*
-* @param face - The face to revolve.
-* @param center - A point on the rotation axis. Defaults to the origin.
-* @param direction - Direction vector of the rotation axis. Defaults to Z-up.
-* @param angle - Rotation angle in **radians**. Defaults to 2π (a full revolution).
-* @returns `Result` containing the revolved 3D shape, or an error if the result is not 3D.
-*/
-function revolve(face, center = [
-	0,
-	0,
-	0
-], direction = [
-	0,
-	0,
-	1
-], angle = 2 * Math.PI) {
-	if (require_shapeTypes.getKernel().isNull(face.wrapped)) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, "revolve: face is a null shape"));
-	try {
-		const result = require_shapeTypes.castResultShape(require_shapeTypes.getKernel().revolveVec(face.wrapped, [...center], [...direction], angle));
-		if (!require_shapeTypes.isShape3D(result)) {
-			require_shapeTypes.disposeResultShape(result);
-			return require_errors.err(require_errors.typeCastError("REVOLUTION_NOT_3D", "Revolution did not produce a 3D shape"));
-		}
-		return require_errors.ok(result);
-	} catch (e) {
-		return require_errors.err(require_errors.kernelError("REVOLVE_FAILED", "Revolution operation failed", e, {
-			operation: "revolve",
-			angle
-		}));
-	}
-}
-/**
-* Batch extrude: build N independent extrusions in a single kernel call.
-*
-* Uses the C++ ExtrudeBatch extractor when available (single WASM call),
-* falling back to N individual extrude operations otherwise.
-*
-* @returns Array of valid solids, one per entry.
-*/
-function extrudeAll(entries) {
-	if (entries.length === 0) return require_errors.ok([]);
-	const kernel = require_shapeTypes.getKernel();
-	const kernelEntries = [];
-	for (let i = 0; i < entries.length; i++) {
-		const e = entries[i];
-		if (!e) continue;
-		const vec = typeof e.height === "number" ? [
-			0,
-			0,
-			e.height
-		] : e.height;
-		const len = require_vecOps.vecLength(vec);
-		if (len < 1e-10) return require_errors.err(require_errors.validationError("EXTRUDE_ALL_ZERO_VECTOR", `extrudeAll: entry ${i} has zero-length extrusion vector`));
-		const direction = [...require_vecOps.vecNormalize(vec)];
-		kernelEntries.push({
-			face: e.face.wrapped,
-			direction,
-			length: len
-		});
-	}
-	try {
-		return require_errors.ok((kernel.extrudeBatch?.(kernelEntries) ?? kernelEntries.map((e) => kernel.extrude(e.face, e.direction, e.length))).map((shape) => {
-			const solid = require_shapeTypes.createSolid(kernel.downcast(shape, "solid"));
-			require_shapeTypes.disposeDowncastSource(shape, solid);
-			return solid;
-		}));
-	} catch (e) {
-		return require_errors.err(require_errors.kernelError("EXTRUDE_ALL_FAILED", "Batch extrusion operation failed", e));
-	}
-}
-//#endregion
 //#region src/operations/loftFns.ts
 /**
 * Functional loft operation using branded shape types.
@@ -544,18 +439,6 @@ Object.defineProperty(exports, "complexExtrude", {
 		return complexExtrude;
 	}
 });
-Object.defineProperty(exports, "extrude", {
-	enumerable: true,
-	get: function() {
-		return extrude;
-	}
-});
-Object.defineProperty(exports, "extrudeAll", {
-	enumerable: true,
-	get: function() {
-		return extrudeAll;
-	}
-});
 Object.defineProperty(exports, "guidedSweep", {
 	enumerable: true,
 	get: function() {
@@ -580,12 +463,6 @@ Object.defineProperty(exports, "multiSectionSweep", {
 		return multiSectionSweep;
 	}
 });
-Object.defineProperty(exports, "revolve", {
-	enumerable: true,
-	get: function() {
-		return revolve;
-	}
-});
 Object.defineProperty(exports, "supportExtrude", {
 	enumerable: true,
 	get: function() {

package/dist/{loftFns-BF5X7ltI.js → loftFns-BeGJ6dxx.js}

@@ -1,7 +1,7 @@
-import { T as isWire, d as createSolid, h as disposeResultShape, it as getKernel, m as disposeDowncastSource, n as castResultShape, nt as _usingCtx, x as isShape3D } from "./shapeTypes-CnKFSfDT.js";
-import { O as ok, S as isErr, d as validationError, i as kernelError, l as typeCastError, t as BrepErrorCode, v as err } from "./errors-B3CDG537.js";
+import { K as getKernel, T as isWire, W as _usingCtx, h as disposeResultShape, n as castResultShape, x as isShape3D } from "./shapeTypes-t49f64Dx.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-MHLiNE-C.js";
 import { r as toVec3 } from "./types-D24Y27N0.js";
-import { c as vecLength, d as vecNormalize, t as vecAdd } from "./vecOps-SKPRvPH-.js";
+import { c as vecLength, t as vecAdd } from "./vecOps-SKPRvPH-.js";
 //#region src/operations/extrudeUtils.ts
 /**
 * Shared utilities for extrusion operations.
@@ -337,111 +337,6 @@ function guidedSweep(profile, spine, guides, options = {}) {
 	}
 }
 //#endregion
-//#region src/operations/extrudeFns.ts
-/**
-* Basic extrusion operations — extrude and revolve.
-*
-* Sweep-based operations (sweep, supportExtrude, complexExtrude, twistExtrude)
-* have moved to `./sweepFns.js`.
-*/
-/**
-* Extrude a face along a vector to produce a solid.
-*
-* @param face - The planar face to extrude.
-* @param extrusionVec - Direction and magnitude of the extrusion as `[x, y, z]`.
-* @returns `Result` containing the extruded solid, or an error if validation or operation fails.
-*/
-function extrude(face, extrusionVec) {
-	if (getKernel().isNull(face.wrapped)) return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, "extrude: face is a null shape"));
-	if (vecLength(extrusionVec) < 1e-10) return err(validationError("EXTRUDE_ZERO_VECTOR", "extrude: extrusion vector has zero length"));
-	try {
-		const kernel = getKernel();
-		const len = vecLength(extrusionVec);
-		const dir = vecNormalize(extrusionVec);
-		const shape = kernel.extrude(face.wrapped, [...dir], len);
-		const solid = createSolid(kernel.downcast(shape, "solid"));
-		disposeDowncastSource(shape, solid);
-		return ok(solid);
-	} catch (e) {
-		return err(kernelError("EXTRUDE_FAILED", "Extrusion operation failed", e, {
-			operation: "extrude",
-			vectorLength: vecLength(extrusionVec)
-		}));
-	}
-}
-/**
-* Revolve a face around an axis to create a solid of revolution.
-*
-* @param face - The face to revolve.
-* @param center - A point on the rotation axis. Defaults to the origin.
-* @param direction - Direction vector of the rotation axis. Defaults to Z-up.
-* @param angle - Rotation angle in **radians**. Defaults to 2π (a full revolution).
-* @returns `Result` containing the revolved 3D shape, or an error if the result is not 3D.
-*/
-function revolve(face, center = [
-	0,
-	0,
-	0
-], direction = [
-	0,
-	0,
-	1
-], angle = 2 * Math.PI) {
-	if (getKernel().isNull(face.wrapped)) return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, "revolve: face is a null shape"));
-	try {
-		const result = castResultShape(getKernel().revolveVec(face.wrapped, [...center], [...direction], angle));
-		if (!isShape3D(result)) {
-			disposeResultShape(result);
-			return err(typeCastError("REVOLUTION_NOT_3D", "Revolution did not produce a 3D shape"));
-		}
-		return ok(result);
-	} catch (e) {
-		return err(kernelError("REVOLVE_FAILED", "Revolution operation failed", e, {
-			operation: "revolve",
-			angle
-		}));
-	}
-}
-/**
-* Batch extrude: build N independent extrusions in a single kernel call.
-*
-* Uses the C++ ExtrudeBatch extractor when available (single WASM call),
-* falling back to N individual extrude operations otherwise.
-*
-* @returns Array of valid solids, one per entry.
-*/
-function extrudeAll(entries) {
-	if (entries.length === 0) return ok([]);
-	const kernel = getKernel();
-	const kernelEntries = [];
-	for (let i = 0; i < entries.length; i++) {
-		const e = entries[i];
-		if (!e) continue;
-		const vec = typeof e.height === "number" ? [
-			0,
-			0,
-			e.height
-		] : e.height;
-		const len = vecLength(vec);
-		if (len < 1e-10) return err(validationError("EXTRUDE_ALL_ZERO_VECTOR", `extrudeAll: entry ${i} has zero-length extrusion vector`));
-		const direction = [...vecNormalize(vec)];
-		kernelEntries.push({
-			face: e.face.wrapped,
-			direction,
-			length: len
-		});
-	}
-	try {
-		return ok((kernel.extrudeBatch?.(kernelEntries) ?? kernelEntries.map((e) => kernel.extrude(e.face, e.direction, e.length))).map((shape) => {
-			const solid = createSolid(kernel.downcast(shape, "solid"));
-			disposeDowncastSource(shape, solid);
-			return solid;
-		}));
-	} catch (e) {
-		return err(kernelError("EXTRUDE_ALL_FAILED", "Batch extrusion operation failed", e));
-	}
-}
-//#endregion
 //#region src/operations/loftFns.ts
 /**
 * Functional loft operation using branded shape types.
@@ -538,4 +433,4 @@ function loftAll(entries) {
 	}
 }
 //#endregion
-export { revolve as a, multiSectionSweep as c, twistExtrude as d, extrudeAll as i, supportExtrude as l, loftAll as n, complexExtrude as o, extrude as r, guidedSweep as s, loft as t, sweep as u };
+export { multiSectionSweep as a, twistExtrude as c, guidedSweep as i, loftAll as n, supportExtrude as o, complexExtrude as r, sweep as s, loft as t };

package/dist/{measureFns-B5Zzg1qM.cjs → measureFns-CJGrmhHT.cjs}

@@ -1,7 +1,7 @@
-const require_shapeTypes = require("./shapeTypes-Bpsu5KJO.cjs");
-const require_errors = require("./errors-CJU8CHng.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-C3fhJndG.cjs");
-const require_faceFns = require("./faceFns-CPswi9Cm.cjs");
+const require_shapeTypes = require("./shapeTypes-CkcIL7zv.cjs");
+const require_errors = require("./errors-RHkKO5bZ.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-Bia7o8l_.cjs");
+const require_faceFns = require("./faceFns-BK4r7Dxk.cjs");
 //#region src/measurement/measureCache.ts
 var cache = /* @__PURE__ */ new WeakMap();
 function getCachedMeasurement(shape, key) {

package/dist/{measureFns-CC7HhAH3.js → measureFns-CMnbcUZC.js}

@@ -1,7 +1,7 @@
-import { it as getKernel } from "./shapeTypes-CnKFSfDT.js";
-import { O as ok, d as validationError, t as BrepErrorCode, v as err } from "./errors-B3CDG537.js";
-import { T as kernelCallRaw } from "./topologyQueryFns-DNqT88yx.js";
-import { m as uvBounds } from "./faceFns-CB6uzvOg.js";
+import { K as getKernel } from "./shapeTypes-t49f64Dx.js";
+import { E as ok, d as validationError, g as err, t as BrepErrorCode } from "./errors-MHLiNE-C.js";
+import { T as kernelCallRaw } from "./topologyQueryFns-BkQ6Q7gN.js";
+import { m as uvBounds } from "./faceFns-DJj9Nb6T.js";
 //#region src/measurement/measureCache.ts
 var cache = /* @__PURE__ */ new WeakMap();
 function getCachedMeasurement(shape, key) {

package/dist/measurement.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_measureFns = require("./measureFns-B5Zzg1qM.cjs");
+const require_measureFns = require("./measureFns-CJGrmhHT.cjs");
 exports.createDistanceQuery = require_measureFns.createDistanceQuery;
 exports.measureArea = require_measureFns.measureArea;
 exports.measureDistance = require_measureFns.measureDistance;

package/dist/measurement.js

@@ -1,2 +1,2 @@
-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-CC7HhAH3.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-CMnbcUZC.js";
 export { createDistanceQuery, measureArea, measureDistance, measureDistanceProps, measureLength, measureLinearProps, measureSurfaceProps, measureVolume, measureVolumeProps };

package/dist/{meshFns-D57Fyqyf.js → meshFns-Cs5EBsf7.js}

@@ -1,7 +1,7 @@
-import { Ct as qualityDeflection, it as getKernel } from "./shapeTypes-CnKFSfDT.js";
-import { O as ok, r as ioError, v as err } from "./errors-B3CDG537.js";
-import { d as getSolids, n as getBounds } from "./topologyQueryFns-DNqT88yx.js";
-import { j as getFaceOrigins } from "./shapeFns-BrHFNLMA.js";
+import { K as getKernel, lt as qualityDeflection } from "./shapeTypes-t49f64Dx.js";
+import { E as ok, g as err, r as ioError } from "./errors-MHLiNE-C.js";
+import { d as getSolids, n as getBounds } from "./topologyQueryFns-BkQ6Q7gN.js";
+import { t as getFaceOrigins } from "./originTrackingFns-DZmdiQ-O.js";
 //#region src/topology/meshCache.ts
 /**
 * Build a parameter key for the inner cache map (excludes shape identity).

package/dist/{meshFns-CaXmWmhe.cjs → meshFns-Dqf5QBhQ.cjs}

@@ -1,7 +1,7 @@
-const require_shapeTypes = require("./shapeTypes-Bpsu5KJO.cjs");
-const require_errors = require("./errors-CJU8CHng.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-C3fhJndG.cjs");
-const require_shapeFns = require("./shapeFns-qm9VRo4i.cjs");
+const require_shapeTypes = require("./shapeTypes-CkcIL7zv.cjs");
+const require_errors = require("./errors-RHkKO5bZ.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-Bia7o8l_.cjs");
+const require_originTrackingFns = require("./originTrackingFns-fpEgTIwV.cjs");
 //#region src/topology/meshCache.ts
 /**
 * Build a parameter key for the inner cache map (excludes shape identity).
@@ -137,7 +137,7 @@ function mesh(shape, opts = {}) {
 		includeUVs,
 		...signal ? { signal } : {}
 	});
-	const origins = require_shapeFns.getFaceOrigins(shape);
+	const origins = require_originTrackingFns.getFaceOrigins(shape);
 	const mesh = {
 		vertices: result.vertices,
 		normals: result.normals,

package/dist/operations.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_threadFns = require("./threadFns-Co6vWEWx.cjs");
-const require_loftFns = require("./loftFns-ChHjzUK-.cjs");
+const require_threadFns = require("./threadFns-DRrk9Qod.cjs");
+const require_loftFns = require("./loftFns-BdpZ8FMN.cjs");
 exports.addChild = require_threadFns.addChild;
 exports.addJoint = require_threadFns.addJoint;
 exports.addStep = require_threadFns.addStep;

package/dist/operations.js

@@ -1,3 +1,3 @@
-import { A as setJointValue, B as createAssemblyNode, C as cylindricalJoint, D as planarJoint, E as mechanismDOF, G as circularPattern, H as removeChild, J as exportAssemblySTEP, K as gridPattern, L as addChild, M as sphericalJoint, O as prismaticJoint, R as collectShapes, S as addJoint, T as jointTransform, U as updateNode, V as findNode, W as walkAssembly, Y as createAssembly, _ as exportURDF, b as inverseKinematics, c as modifyStep, d as replayFrom, f as replayHistory, g as undoLast, h as stepsFrom, i as createRegistry, j as setJointValues, k as revoluteJoint, l as registerOperation, m as stepCount, n as addStep, o as findStep, q as linearPattern, r as createHistory, s as getShape, t as thread, u as registerShape, v as importURDF, w as forwardKinematics, x as jointTrajectory, y as jointsFromDH, z as countNodes } from "./threadFns-CqSMNyTZ.js";
-import { d as twistExtrude, l as supportExtrude, o as complexExtrude, u as sweep } from "./loftFns-BF5X7ltI.js";
+import { A as setJointValue, B as createAssemblyNode, C as cylindricalJoint, D as planarJoint, E as mechanismDOF, G as circularPattern, H as removeChild, J as exportAssemblySTEP, K as gridPattern, L as addChild, M as sphericalJoint, O as prismaticJoint, R as collectShapes, S as addJoint, T as jointTransform, U as updateNode, V as findNode, W as walkAssembly, Y as createAssembly, _ as exportURDF, b as inverseKinematics, c as modifyStep, d as replayFrom, f as replayHistory, g as undoLast, h as stepsFrom, i as createRegistry, j as setJointValues, k as revoluteJoint, l as registerOperation, m as stepCount, n as addStep, o as findStep, q as linearPattern, r as createHistory, s as getShape, t as thread, u as registerShape, v as importURDF, w as forwardKinematics, x as jointTrajectory, y as jointsFromDH, z as countNodes } from "./threadFns-BOtXTHZ9.js";
+import { c as twistExtrude, o as supportExtrude, r as complexExtrude, s as sweep } from "./loftFns-BeGJ6dxx.js";
 export { addChild, addJoint, addStep, circularPattern, collectShapes, complexExtrude, countNodes, createAssembly, createAssemblyNode, createHistory, createRegistry, cylindricalJoint, exportAssemblySTEP, exportURDF, findNode, findStep, forwardKinematics, getShape as getHistoryShape, gridPattern, importURDF, inverseKinematics, jointTrajectory, jointTransform, jointsFromDH, linearPattern, mechanismDOF, modifyStep, planarJoint, prismaticJoint, registerOperation, registerShape, removeChild, replayFrom, replayHistory, revoluteJoint, setJointValue, setJointValues, sphericalJoint, stepCount, stepsFrom, supportExtrude, sweep, thread, twistExtrude, undoLast, updateNode, walkAssembly };

package/dist/originTrackingFns-DZmdiQ-O.js

@@ -0,0 +1,203 @@
+import { K as getKernel } from "./shapeTypes-t49f64Dx.js";
+import { S as subShapeHashes, c as getFaces, l as getOrCreateCache, r as getCacheEntry } from "./topologyQueryFns-BkQ6Q7gN.js";
+import { n as HASH_CODE_MAX } from "./constants-ITRzCnCp.js";
+//#region src/topology/metadata/originTrackingFns.ts
+/**
+* Face origin tracking — tag faces with integer origins and propagate
+* them through kernel operations via ShapeEvolution records.
+*/
+/**
+* Tag all faces of a shape with an opaque integer origin.
+* Consumers assign meaning (e.g., source line number).
+*/
+function setShapeOrigin(shape, origin) {
+	const cache = getOrCreateCache(shape);
+	const map = /* @__PURE__ */ new Map();
+	for (const hash of subShapeHashes(shape, "face")) map.set(hash, origin);
+	cache.faceOrigins = map;
+}
+/**
+* Get the face origin map for a shape (faceHash → originTag).
+* Returns undefined if no origins have been set or propagated.
+*/
+function getFaceOrigins(shape) {
+	return getCacheEntry(shape)?.faceOrigins;
+}
+/**
+* Propagate face origins using a kernel-provided ShapeEvolution record.
+*/
+function propagateOriginsFromEvolution(evolution, inputs, result) {
+	const inputOrigins = /* @__PURE__ */ new Map();
+	for (const input of inputs) {
+		const origins = getFaceOrigins(input);
+		if (!origins) continue;
+		for (const [hash, origin] of origins) inputOrigins.set(hash, origin);
+	}
+	if (inputOrigins.size === 0) return;
+	const resultMap = /* @__PURE__ */ new Map();
+	for (const [hash, origin] of inputOrigins) {
+		if (evolution.deleted.has(hash)) continue;
+		const modifiedHashes = evolution.modified.get(hash);
+		if (modifiedHashes && modifiedHashes.length > 0) for (const modHash of modifiedHashes) resultMap.set(modHash, origin);
+		else resultMap.set(hash, origin);
+		const generatedHashes = evolution.generated.get(hash);
+		if (generatedHashes) {
+			for (const genHash of generatedHashes) if (!resultMap.has(genHash)) resultMap.set(genHash, origin);
+		}
+	}
+	if (resultMap.size > 0) {
+		const cache = getOrCreateCache(result);
+		cache.faceOrigins = resultMap;
+	}
+}
+/** Max 3D centroid separation (mm²) for a "near" match — the general case. */
+var MAX_MATCH_DIST_SQ = 100;
+/** Min |outNormal·inNormal| for two faces to count as sharing a plane's orientation. */
+var COPLANAR_NORMAL_MIN = .985;
+/**
+* Max squared perpendicular offset (mm²) from an input face's plane for the
+* output face to count as *coplanar* with it — i.e. a piece the boolean sliced
+* off that same planar surface. 0.1mm² tolerates kernel/mesh float noise while
+* still separating floors that sit even a fraction of a mm apart in depth.
+*/
+var COPLANAR_OFFSET_SQ = .1;
+/**
+* Find the best origin match for a result face by comparing normals and centroids
+* against input face signatures. Returns `undefined` if no good match exists.
+*
+* Two passes, near strictly preferred:
+*  1. Near match — same-facing normal (signed dot ≥ 0.707) and centroids within
+*     {@link MAX_MATCH_DIST_SQ}. The general case for regenerated seam faces
+*     (feature tops, flush walls). Unchanged legacy behavior. If any near match
+*     exists it wins outright — the coplanar pass never runs — so a distant
+*     coplanar candidate can't outscore a valid near one.
+*  2. Coplanar match (only when no near match, and only between PLANAR faces) —
+*     the output face lies on an input face's plane (parallel *or* antiparallel
+*     normal, tiny perpendicular offset) regardless of how far its centroid
+*     drifted in-plane. Two cases pass 1 misses:
+*       • A boolean that splits a large planar face — a wide cutout floor sliced
+*         by an overlapping deeper cutout — leaves pieces >10mm from the parent
+*         centroid (past pass 1's cutoff).
+*       • A cut flips the cavity face's normal versus the tool face it came from,
+*         so the floor is antiparallel to its origin's input face.
+*     Both left the surface tagless → body color in multi-color consumers
+*     (gridfinity GH #2443). The planar gate keeps a curved output face from
+*     inheriting an origin off an unrelated face that merely shares a sampled
+*     tangent plane; among coplanar candidates the nearest in-plane wins.
+*/
+function findBestOriginMatch(outNormal, outCentroid, outPlanar, inputSigs) {
+	let bestNearScore = -Infinity;
+	let bestNear;
+	for (const inp of inputSigs) {
+		const dot = outNormal[0] * inp.normal[0] + outNormal[1] * inp.normal[1] + outNormal[2] * inp.normal[2];
+		if (dot < .707) continue;
+		const dx = outCentroid[0] - inp.centroid[0];
+		const dy = outCentroid[1] - inp.centroid[1];
+		const dz = outCentroid[2] - inp.centroid[2];
+		const distSq = dx * dx + dy * dy + dz * dz;
+		if (distSq > MAX_MATCH_DIST_SQ) continue;
+		const score = dot - distSq / MAX_MATCH_DIST_SQ;
+		if (score > bestNearScore) {
+			bestNearScore = score;
+			bestNear = inp.origin;
+		}
+	}
+	if (bestNear !== void 0) return bestNear;
+	if (!outPlanar) return void 0;
+	let bestInPlaneSq = Infinity;
+	let bestCoplanar;
+	for (const inp of inputSigs) {
+		if (!inp.planar) continue;
+		const dot = outNormal[0] * inp.normal[0] + outNormal[1] * inp.normal[1] + outNormal[2] * inp.normal[2];
+		if (Math.abs(dot) < COPLANAR_NORMAL_MIN) continue;
+		const dx = outCentroid[0] - inp.centroid[0];
+		const dy = outCentroid[1] - inp.centroid[1];
+		const dz = outCentroid[2] - inp.centroid[2];
+		const perp = dx * inp.normal[0] + dy * inp.normal[1] + dz * inp.normal[2];
+		if (perp * perp > COPLANAR_OFFSET_SQ) continue;
+		const inPlaneSq = Math.max(0, dx * dx + dy * dy + dz * dz - perp * perp);
+		if (inPlaneSq < bestInPlaneSq) {
+			bestInPlaneSq = inPlaneSq;
+			bestCoplanar = inp.origin;
+		}
+	}
+	return bestCoplanar;
+}
+/**
+* Fallback origin propagation when no kernel op object is available
+* (native `fuseAll` / `cutAll`, which expose no ShapeEvolution record).
+*
+* Matches result faces to input faces by hash code first. Faces that pass
+* through the boolean unchanged keep their hash and recover their origin
+* directly. Faces the boolean *regenerates* (split, merged, or re-created at
+* the intersection) get a fresh hash that matches no input — these fall back
+* to geometric matching (normal + centroid) against the input face
+* signatures.
+*
+* The geometric pass runs for every unmatched face, not only when the hash
+* pass found nothing. A partial hash match is the common case for additive
+* features (pass-through side walls match by hash; the surfaces where the
+* tool meets the body — feature tops, flush walls — are regenerated and need
+* the geometric pass). Gating the fallback on "zero hash matches" left those
+* regenerated faces with no origin, so they fell back to 0 (body) at mesh
+* time — the multi-color export bug where a scoop/label/lip top printed in
+* the body color. Matching against the full signature set (body origin 0
+* included) keeps body faces body and feature faces feature.
+*/
+function propagateOriginsByHash(inputs, result) {
+	const lookup = /* @__PURE__ */ new Map();
+	for (const input of inputs) {
+		const origins = getFaceOrigins(input);
+		if (!origins) continue;
+		for (const [hash, origin] of origins) lookup.set(hash, origin);
+	}
+	if (lookup.size === 0) return;
+	const kernel = getKernel();
+	const resultMap = /* @__PURE__ */ new Map();
+	const resultFaces = getFaces(result);
+	const unmatched = [];
+	for (const f of resultFaces) {
+		const hash = kernel.hashCode(f.wrapped, HASH_CODE_MAX);
+		const origin = lookup.get(hash);
+		if (origin !== void 0) resultMap.set(hash, origin);
+		else unmatched.push(f);
+	}
+	if (unmatched.length > 0) {
+		const inputSigs = [];
+		for (const input of inputs) {
+			const origins = getFaceOrigins(input);
+			if (!origins) continue;
+			for (const f of getFaces(input)) {
+				const hash = kernel.hashCode(f.wrapped, HASH_CODE_MAX);
+				const origin = origins.get(hash);
+				if (origin === void 0) continue;
+				try {
+					const bounds = kernel.uvBounds(f.wrapped);
+					const normal = kernel.surfaceNormal(f.wrapped, .5 * (bounds.uMin + bounds.uMax), .5 * (bounds.vMin + bounds.vMax));
+					const centroid = kernel.surfaceCenterOfMass(f.wrapped);
+					const planar = kernel.surfaceType(f.wrapped) === "plane";
+					inputSigs.push({
+						origin,
+						normal,
+						centroid,
+						planar
+					});
+				} catch {}
+			}
+		}
+		if (inputSigs.length > 0) for (const f of unmatched) {
+			const hash = kernel.hashCode(f.wrapped, HASH_CODE_MAX);
+			try {
+				const outBounds = kernel.uvBounds(f.wrapped);
+				const bestOrigin = findBestOriginMatch(kernel.surfaceNormal(f.wrapped, .5 * (outBounds.uMin + outBounds.uMax), .5 * (outBounds.vMin + outBounds.vMax)), kernel.surfaceCenterOfMass(f.wrapped), kernel.surfaceType(f.wrapped) === "plane", inputSigs);
+				if (bestOrigin !== void 0) resultMap.set(hash, bestOrigin);
+			} catch {}
+		}
+	}
+	if (resultMap.size > 0) {
+		const cache = getOrCreateCache(result);
+		cache.faceOrigins = resultMap;
+	}
+}
+//#endregion
+export { setShapeOrigin as i, propagateOriginsByHash as n, propagateOriginsFromEvolution as r, getFaceOrigins as t };