brepjs 18.114.0 → 18.115.1

package/dist/brepjs.cjs

@@ -30,7 +30,7 @@ const require_loftFns = require("./loftFns-fpTmrIdd.cjs");
 const require_cameraFns = require("./cameraFns-uo1sZbBT.cjs");
 const require_textMetrics = require("./textMetrics-IC_IoI7l.cjs");
 const require_adjacencyFns = require("./adjacencyFns-d8ZabkvX.cjs");
-const require_refResolveFns = require("./refResolveFns-BK5NSDFd.cjs");
+const require_refResolveFns = require("./refResolveFns-pRVyjy35.cjs");
 const require_workerPool = require("./workerPool-D30NsiIW.cjs");
 const require_primitiveFns = require("./primitiveFns-DLIWtQWA.cjs");
 //#region src/topology/shapeBooleans.ts
@@ -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

@@ -29,7 +29,7 @@ import { a as Sketch, c as compoundSketchLoft, d as sketchFace, f as sketchLoft,
 import { a as makeProjectedEdges, i as projectEdges, n as cameraLookAt, r as createCamera, s as isProjectionPlane, t as cameraFromPlane } from "./cameraFns-bk9e0F-T.js";
 import { n as textMetrics, r as sketchText, t as fontMetrics } from "./textMetrics-COGYk0LE.js";
 import { a as sharedEdges, c as wiresOfFace, i as facesOfVertex, n as edgesOfFace, o as verticesOfEdge, r as facesOfEdge, s as verticesOfFace, t as adjacentFaces } from "./adjacencyFns-BYnyXXqt.js";
-import { _ as createRef, a as isVertexRef, b as defaultScorer, c as resolveRefParams, d as createVertexRef, f as resolveVertexRef, g as captureHint, h as assignRoles, i as isLineageRef, l as createDerivedFaceRef, m as resolveEdgeRef, n as isEdgeRef, o as resolveLineageRef, p as createEdgeRef, r as isFaceRef, s as resolveRefIn, t as isDerivedFaceRef, u as resolveDerivedFaceRef, v as resolveRef, y as updateRoles } from "./refResolveFns-CayDQeug.js";
+import { _ as createRef, a as isVertexRef, b as defaultScorer, c as resolveRefParams, d as createVertexRef, f as resolveVertexRef, g as captureHint, h as assignRoles, i as isLineageRef, l as createDerivedFaceRef, m as resolveEdgeRef, n as isEdgeRef, o as resolveLineageRef, p as createEdgeRef, r as isFaceRef, s as resolveRefIn, t as isDerivedFaceRef, u as resolveDerivedFaceRef, v as resolveRef, y as updateRoles } from "./refResolveFns-hEOEcFZ8.js";
 import { _ as isSuccessResponse, a as createWorkerClient, c as enqueueTask, d as rejectAll, f as isBatchRequest, g as isOperationRequest, h as isInitRequest, i as registerHandler, l as isEmpty$1, m as isErrorResponse, n as createOperationRegistry, o as createTaskQueue, p as isDisposeRequest, r as createWorkerHandler, s as dequeueTask, t as createWorkerPool, u as pendingCount } from "./workerPool-XcYX2UZ0.js";
 import { C as threePointArc, D as wireLoop, E as wire, S as tangentArc, T as vertex, _ as polygon, a as circle, b as sphere$1, c as cylinder, d as ellipsoid, f as face, g as offsetFace, h as line, i as bsplineApprox, l as ellipse, m as helix, n as bezier, o as compound, p as filledFace, r as box, s as cone, t as addHoles, u as ellipseArc, v as sewShells, w as torus$1, x as subFace, y as solid } from "./primitiveFns-CBrOyk5S.js";
 //#region \0rolldown/runtime.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/dist/{refResolveFns-CayDQeug.js → refResolveFns-hEOEcFZ8.js}

@@ -70,33 +70,56 @@ function boxRoleFromNormal(n) {
 	if (n[0] > AXIS_THRESHOLD) return "box:right";
 	if (n[0] < -.9) return "box:left";
 }
+/** Axial cap name for a Z-axis primitive: 'top' (+Z) / 'bottom' (-Z). */
+function axialCapName(prefix, face) {
+	if (faceGeomType(face) !== "PLANE") return void 0;
+	const z = normalAt(face)[2];
+	if (z > AXIS_THRESHOLD) return `${prefix}:top`;
+	if (z < -.9) return `${prefix}:bottom`;
+}
+/** Semantic role for a Z-axis cylinder face: top/bottom caps + lateral wall. */
+function cylinderRole(face) {
+	return faceGeomType(face) === "CYLINDRE" ? "cylinder:lateral" : axialCapName("cylinder", face);
+}
+/** Semantic role for a Z-axis cone/frustum face: top/bottom caps + lateral. */
+function coneRole(face) {
+	return faceGeomType(face) === "CONE" ? "cone:lateral" : axialCapName("cone", face);
+}
+/** Semantic role for a sphere's single spherical face. */
+function sphereRole(face) {
+	return faceGeomType(face) === "SPHERE" ? "sphere:surface" : void 0;
+}
+/** Per-primitive semantic face namers, keyed by operation type. */
+var ROLE_ASSIGNERS = {
+	box: (face) => boxRoleFromNormal(normalAt(face)),
+	cylinder: cylinderRole,
+	cone: coneRole,
+	sphere: sphereRole
+};
 /**
-* Auto-assign role names to the faces of a shape based on operation type.
+* Auto-assign role names to a shape's faces from its operation type.
 *
-* For 'box': uses face normals to assign cardinal names
-* ('box:top', 'box:bottom', 'box:front', 'box:back', 'box:left', 'box:right').
-* **Note:** Box role detection assumes axis-aligned faces (normal within 0.9 of
-* a cardinal axis). Rotated boxes may receive fewer than 6 named roles; remaining
-* faces fall through to sequential naming.
+* Known primitives get **semantic** names from face geometry — rebuild-stable
+* across parameter edits that preserve orientation:
+* - `box`: cardinal names by normal ('box:top'/'bottom'/'front'/'back'/'left'/'right').
+* - `cylinder`/`cone` (Z-axis): 'top'/'bottom' caps + 'lateral' wall.
+* - `sphere`: 'sphere:surface'.
 *
-* For other types: sequential naming ('opType:face_0', 'opType:face_1', ...).
+* Faces a primitive namer doesn't recognize (a rotated box's non-cardinal faces),
+* and every face of any other operation type, fall back to positional names
+* ('opType:face_0', 'opType:face_1', ...) — so each face always gets a role.
 *
 * @returns Map from role name to its face hash codes (one at assignment time;
 *   a role accrues more hashes only later, when `updateRoles` tracks a split).
 */
 function assignRoles(shape, operationType) {
-	const faces = getFaces(shape);
 	const roles = /* @__PURE__ */ new Map();
-	if (operationType === "box") {
-		for (const face of faces) {
-			const role = boxRoleFromNormal(normalAt(face));
-			if (role !== void 0 && !roles.has(role)) roles.set(role, [getHashCode(face)]);
-		}
-		return roles;
-	}
+	const assigner = ROLE_ASSIGNERS[operationType];
 	let index = 0;
-	for (const face of faces) {
-		roles.set(`${operationType}:face_${index}`, [getHashCode(face)]);
+	for (const face of getFaces(shape)) {
+		const semantic = assigner?.(face);
+		const role = semantic !== void 0 && !roles.has(semantic) ? semantic : `${operationType}:face_${index}`;
+		roles.set(role, [getHashCode(face)]);
 		index++;
 	}
 	return roles;

package/dist/{refResolveFns-BK5NSDFd.cjs → refResolveFns-pRVyjy35.cjs}

@@ -70,33 +70,56 @@ function boxRoleFromNormal(n) {
 	if (n[0] > AXIS_THRESHOLD) return "box:right";
 	if (n[0] < -.9) return "box:left";
 }
+/** Axial cap name for a Z-axis primitive: 'top' (+Z) / 'bottom' (-Z). */
+function axialCapName(prefix, face) {
+	if (require_faceFns.faceGeomType(face) !== "PLANE") return void 0;
+	const z = require_faceFns.normalAt(face)[2];
+	if (z > AXIS_THRESHOLD) return `${prefix}:top`;
+	if (z < -.9) return `${prefix}:bottom`;
+}
+/** Semantic role for a Z-axis cylinder face: top/bottom caps + lateral wall. */
+function cylinderRole(face) {
+	return require_faceFns.faceGeomType(face) === "CYLINDRE" ? "cylinder:lateral" : axialCapName("cylinder", face);
+}
+/** Semantic role for a Z-axis cone/frustum face: top/bottom caps + lateral. */
+function coneRole(face) {
+	return require_faceFns.faceGeomType(face) === "CONE" ? "cone:lateral" : axialCapName("cone", face);
+}
+/** Semantic role for a sphere's single spherical face. */
+function sphereRole(face) {
+	return require_faceFns.faceGeomType(face) === "SPHERE" ? "sphere:surface" : void 0;
+}
+/** Per-primitive semantic face namers, keyed by operation type. */
+var ROLE_ASSIGNERS = {
+	box: (face) => boxRoleFromNormal(require_faceFns.normalAt(face)),
+	cylinder: cylinderRole,
+	cone: coneRole,
+	sphere: sphereRole
+};
 /**
-* Auto-assign role names to the faces of a shape based on operation type.
+* Auto-assign role names to a shape's faces from its operation type.
 *
-* For 'box': uses face normals to assign cardinal names
-* ('box:top', 'box:bottom', 'box:front', 'box:back', 'box:left', 'box:right').
-* **Note:** Box role detection assumes axis-aligned faces (normal within 0.9 of
-* a cardinal axis). Rotated boxes may receive fewer than 6 named roles; remaining
-* faces fall through to sequential naming.
+* Known primitives get **semantic** names from face geometry — rebuild-stable
+* across parameter edits that preserve orientation:
+* - `box`: cardinal names by normal ('box:top'/'bottom'/'front'/'back'/'left'/'right').
+* - `cylinder`/`cone` (Z-axis): 'top'/'bottom' caps + 'lateral' wall.
+* - `sphere`: 'sphere:surface'.
 *
-* For other types: sequential naming ('opType:face_0', 'opType:face_1', ...).
+* Faces a primitive namer doesn't recognize (a rotated box's non-cardinal faces),
+* and every face of any other operation type, fall back to positional names
+* ('opType:face_0', 'opType:face_1', ...) — so each face always gets a role.
 *
 * @returns Map from role name to its face hash codes (one at assignment time;
 *   a role accrues more hashes only later, when `updateRoles` tracks a split).
 */
 function assignRoles(shape, operationType) {
-	const faces = require_topologyQueryFns.getFaces(shape);
 	const roles = /* @__PURE__ */ new Map();
-	if (operationType === "box") {
-		for (const face of faces) {
-			const role = boxRoleFromNormal(require_faceFns.normalAt(face));
-			if (role !== void 0 && !roles.has(role)) roles.set(role, [require_shapeFns.getHashCode(face)]);
-		}
-		return roles;
-	}
+	const assigner = ROLE_ASSIGNERS[operationType];
 	let index = 0;
-	for (const face of faces) {
-		roles.set(`${operationType}:face_${index}`, [require_shapeFns.getHashCode(face)]);
+	for (const face of require_topologyQueryFns.getFaces(shape)) {
+		const semantic = assigner?.(face);
+		const role = semantic !== void 0 && !roles.has(semantic) ? semantic : `${operationType}:face_${index}`;
+		roles.set(role, [require_shapeFns.getHashCode(face)]);
 		index++;
 	}
 	return roles;

package/dist/shapeRef.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_refResolveFns = require("./refResolveFns-BK5NSDFd.cjs");
+const require_refResolveFns = require("./refResolveFns-pRVyjy35.cjs");
 exports.assignRoles = require_refResolveFns.assignRoles;
 exports.captureHint = require_refResolveFns.captureHint;
 exports.createDerivedFaceRef = require_refResolveFns.createDerivedFaceRef;

package/dist/shapeRef.js

@@ -1,2 +1,2 @@
-import { _ as createRef, a as isVertexRef, b as defaultScorer, c as resolveRefParams, d as createVertexRef, f as resolveVertexRef, g as captureHint, h as assignRoles, i as isLineageRef, l as createDerivedFaceRef, m as resolveEdgeRef, n as isEdgeRef, o as resolveLineageRef, p as createEdgeRef, r as isFaceRef, s as resolveRefIn, t as isDerivedFaceRef, u as resolveDerivedFaceRef, v as resolveRef, y as updateRoles } from "./refResolveFns-CayDQeug.js";
+import { _ as createRef, a as isVertexRef, b as defaultScorer, c as resolveRefParams, d as createVertexRef, f as resolveVertexRef, g as captureHint, h as assignRoles, i as isLineageRef, l as createDerivedFaceRef, m as resolveEdgeRef, n as isEdgeRef, o as resolveLineageRef, p as createEdgeRef, r as isFaceRef, s as resolveRefIn, t as isDerivedFaceRef, u as resolveDerivedFaceRef, v as resolveRef, y as updateRoles } from "./refResolveFns-hEOEcFZ8.js";
 export { assignRoles, captureHint, createDerivedFaceRef, createEdgeRef, createRef, createVertexRef, defaultScorer, isDerivedFaceRef, isEdgeRef, isFaceRef, isLineageRef, isVertexRef, resolveDerivedFaceRef, resolveEdgeRef, resolveLineageRef, resolveRef, resolveRefIn, resolveRefParams, resolveVertexRef, updateRoles };

package/dist/topology/shapeRef/shapeRefFns.d.ts

@@ -5,15 +5,17 @@ import { FaceScorer } from './scoring.js';
 /** Snapshot the geometric properties of a face for later matching. */
 export declare function captureHint(face: Face): GeometricHint;
 /**
- * Auto-assign role names to the faces of a shape based on operation type.
+ * Auto-assign role names to a shape's faces from its operation type.
  *
- * For 'box': uses face normals to assign cardinal names
- * ('box:top', 'box:bottom', 'box:front', 'box:back', 'box:left', 'box:right').
- * **Note:** Box role detection assumes axis-aligned faces (normal within 0.9 of
- * a cardinal axis). Rotated boxes may receive fewer than 6 named roles; remaining
- * faces fall through to sequential naming.
+ * Known primitives get **semantic** names from face geometry — rebuild-stable
+ * across parameter edits that preserve orientation:
+ * - `box`: cardinal names by normal ('box:top'/'bottom'/'front'/'back'/'left'/'right').
+ * - `cylinder`/`cone` (Z-axis): 'top'/'bottom' caps + 'lateral' wall.
+ * - `sphere`: 'sphere:surface'.
  *
- * For other types: sequential naming ('opType:face_0', 'opType:face_1', ...).
+ * Faces a primitive namer doesn't recognize (a rotated box's non-cardinal faces),
+ * and every face of any other operation type, fall back to positional names
+ * ('opType:face_0', 'opType:face_1', ...) — so each face always gets a role.
  *
  * @returns Map from role name to its face hash codes (one at assignment time;
  *   a role accrues more hashes only later, when `updateRoles` tracks a split).

package/package.json

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