brepjs 18.115.0 → 18.115.1

package/dist/brepjs.cjs

@@ -5837,6 +5837,76 @@ function cacheKey(node, env, kernelId, tolerance) {
 	const tolHash = tolerance === void 0 ? "d" : fnvMixNumber(fnvInit(), tolerance).toString(16);
 	return `${toHex(node.structuralHash)}:${kernelId}:${toHex(projHash)}:${tolHash}`;
 }
+/**
+* Peel outer Translate nodes off `node`, accumulating their env-evaluated
+* offsets. Pure translations compose by addition, so the inner geometry is
+* placement-independent: it meshes once and the cached mesh is shifted per
+* placement instead of re-tessellating. Stops at the first non-Translate node
+* (or one whose offset can't be evaluated in `env`).
+*/
+function peelTranslate(node, env) {
+	let inner = node;
+	let ox = 0;
+	let oy = 0;
+	let oz = 0;
+	while (inner.kind === "Translate") {
+		const v = evalVec3(inner.vector, env, "evaluateMesh.peelTranslate");
+		if (!v.ok) break;
+		ox += v.value[0];
+		oy += v.value[1];
+		oz += v.value[2];
+		inner = inner.target;
+	}
+	return {
+		inner,
+		offset: [
+			ox,
+			oy,
+			oz
+		]
+	};
+}
+/** Shift every vertex of a mesh by `offset`; normals, UVs and triangles are unchanged. */
+function translateMesh(m, offset) {
+	const [dx, dy, dz] = offset;
+	if (dx === 0 && dy === 0 && dz === 0) return m;
+	const vertices = new Float32Array(m.vertices.length);
+	for (let i = 0; i < m.vertices.length; i += 3) {
+		vertices[i] = (m.vertices[i] ?? 0) + dx;
+		vertices[i + 1] = (m.vertices[i + 1] ?? 0) + dy;
+		vertices[i + 2] = (m.vertices[i + 2] ?? 0) + dz;
+	}
+	return {
+		...m,
+		vertices
+	};
+}
+/**
+* Re-key a reused inner mesh's face groups onto the PLACED shape. `locate` gives
+* moved faces location-dependent hashes, so the inner mesh's `faceId`s describe
+* the *unplaced* shape; remap them to the placed faces (1:1 by iteration order,
+* since `locate` shares the source TShape) so face picking and metadata lookup
+* resolve against the placed mesh. Origins are translation-invariant, so only
+* `faceId` changes.
+*
+* Takes pre-captured hash arrays (not shapes): a bounded shape cache can evict
+* and dispose one shape while the other is being evaluated, so the caller reads
+* each shape's face hashes immediately after evaluating it, never holding a
+* shape handle across the next `evaluate`.
+*/
+function relocateFaceGroups(faceGroups, innerHashes, placedHashes) {
+	const remap = /* @__PURE__ */ new Map();
+	const n = Math.min(innerHashes.length, placedHashes.length);
+	for (let i = 0; i < n; i++) {
+		const a = innerHashes[i];
+		const b = placedHashes[i];
+		if (a !== void 0 && b !== void 0) remap.set(a, b);
+	}
+	return faceGroups.map((g) => ({
+		...g,
+		faceId: remap.get(g.faceId) ?? g.faceId
+	}));
+}
 var Evaluator = class {
 	cache = /* @__PURE__ */ new Map();
 	refCounts = /* @__PURE__ */ new Map();
@@ -5913,6 +5983,29 @@ var Evaluator = class {
 				}
 				return require_errors.ok(cached);
 			}
+			const { inner, offset } = peelTranslate(node, env);
+			if (inner !== node) {
+				const innerMesh = this.evaluateMesh(inner, env, meshOpts);
+				if (!innerMesh.ok) return innerMesh;
+				const innerShape = this.evaluate(inner, env);
+				if (!innerShape.ok) return innerShape;
+				const innerHashes = require_topologyQueryFns.getFaces(innerShape.value).map(require_shapeFns.getHashCode);
+				const placedShape = this.evaluate(node, env);
+				if (!placedShape.ok) return placedShape;
+				const placedHashes = require_topologyQueryFns.getFaces(placedShape.value).map(require_shapeFns.getHashCode);
+				const moved = translateMesh(innerMesh.value, offset);
+				const faceGroups = relocateFaceGroups(moved.faceGroups, innerHashes, placedHashes);
+				const placedSet = new Set(placedHashes);
+				if (faceGroups.every((g) => placedSet.has(g.faceId))) {
+					const placed = {
+						...moved,
+						faceGroups
+					};
+					this.meshCache.set(meshKey, placed);
+					if (this.maxMeshCacheEntries !== void 0) this.trimMeshCache(this.maxMeshCacheEntries);
+					return require_errors.ok(placed);
+				}
+			}
 		}
 		const shape = this.evaluate(node, env);
 		if (!shape.ok) return shape;

package/dist/brepjs.js

@@ -5840,6 +5840,76 @@ function cacheKey(node, env, kernelId, tolerance) {
 	const tolHash = tolerance === void 0 ? "d" : fnvMixNumber(fnvInit(), tolerance).toString(16);
 	return `${toHex(node.structuralHash)}:${kernelId}:${toHex(projHash)}:${tolHash}`;
 }
+/**
+* Peel outer Translate nodes off `node`, accumulating their env-evaluated
+* offsets. Pure translations compose by addition, so the inner geometry is
+* placement-independent: it meshes once and the cached mesh is shifted per
+* placement instead of re-tessellating. Stops at the first non-Translate node
+* (or one whose offset can't be evaluated in `env`).
+*/
+function peelTranslate(node, env) {
+	let inner = node;
+	let ox = 0;
+	let oy = 0;
+	let oz = 0;
+	while (inner.kind === "Translate") {
+		const v = evalVec3(inner.vector, env, "evaluateMesh.peelTranslate");
+		if (!v.ok) break;
+		ox += v.value[0];
+		oy += v.value[1];
+		oz += v.value[2];
+		inner = inner.target;
+	}
+	return {
+		inner,
+		offset: [
+			ox,
+			oy,
+			oz
+		]
+	};
+}
+/** Shift every vertex of a mesh by `offset`; normals, UVs and triangles are unchanged. */
+function translateMesh(m, offset) {
+	const [dx, dy, dz] = offset;
+	if (dx === 0 && dy === 0 && dz === 0) return m;
+	const vertices = new Float32Array(m.vertices.length);
+	for (let i = 0; i < m.vertices.length; i += 3) {
+		vertices[i] = (m.vertices[i] ?? 0) + dx;
+		vertices[i + 1] = (m.vertices[i + 1] ?? 0) + dy;
+		vertices[i + 2] = (m.vertices[i + 2] ?? 0) + dz;
+	}
+	return {
+		...m,
+		vertices
+	};
+}
+/**
+* Re-key a reused inner mesh's face groups onto the PLACED shape. `locate` gives
+* moved faces location-dependent hashes, so the inner mesh's `faceId`s describe
+* the *unplaced* shape; remap them to the placed faces (1:1 by iteration order,
+* since `locate` shares the source TShape) so face picking and metadata lookup
+* resolve against the placed mesh. Origins are translation-invariant, so only
+* `faceId` changes.
+*
+* Takes pre-captured hash arrays (not shapes): a bounded shape cache can evict
+* and dispose one shape while the other is being evaluated, so the caller reads
+* each shape's face hashes immediately after evaluating it, never holding a
+* shape handle across the next `evaluate`.
+*/
+function relocateFaceGroups(faceGroups, innerHashes, placedHashes) {
+	const remap = /* @__PURE__ */ new Map();
+	const n = Math.min(innerHashes.length, placedHashes.length);
+	for (let i = 0; i < n; i++) {
+		const a = innerHashes[i];
+		const b = placedHashes[i];
+		if (a !== void 0 && b !== void 0) remap.set(a, b);
+	}
+	return faceGroups.map((g) => ({
+		...g,
+		faceId: remap.get(g.faceId) ?? g.faceId
+	}));
+}
 var Evaluator = class {
 	cache = /* @__PURE__ */ new Map();
 	refCounts = /* @__PURE__ */ new Map();
@@ -5916,6 +5986,29 @@ var Evaluator = class {
 				}
 				return ok(cached);
 			}
+			const { inner, offset } = peelTranslate(node, env);
+			if (inner !== node) {
+				const innerMesh = this.evaluateMesh(inner, env, meshOpts);
+				if (!innerMesh.ok) return innerMesh;
+				const innerShape = this.evaluate(inner, env);
+				if (!innerShape.ok) return innerShape;
+				const innerHashes = getFaces(innerShape.value).map(getHashCode);
+				const placedShape = this.evaluate(node, env);
+				if (!placedShape.ok) return placedShape;
+				const placedHashes = getFaces(placedShape.value).map(getHashCode);
+				const moved = translateMesh(innerMesh.value, offset);
+				const faceGroups = relocateFaceGroups(moved.faceGroups, innerHashes, placedHashes);
+				const placedSet = new Set(placedHashes);
+				if (faceGroups.every((g) => placedSet.has(g.faceId))) {
+					const placed = {
+						...moved,
+						faceGroups
+					};
+					this.meshCache.set(meshKey, placed);
+					if (this.maxMeshCacheEntries !== void 0) this.trimMeshCache(this.maxMeshCacheEntries);
+					return ok(placed);
+				}
+			}
 		}
 		const shape = this.evaluate(node, env);
 		if (!shape.ok) return shape;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brepjs",
-  "version": "18.115.0",
+  "version": "18.115.1",
   "description": "Web CAD library with pluggable geometry kernel",
   "keywords": [
     "cad",