brepjs 18.115.0 → 18.116.0

package/dist/brepjs.cjs

@@ -17,7 +17,7 @@ const require_arrayAccess = require("./arrayAccess-e4H9cBfh.cjs");
 const require_surfaceBuilders = require("./surfaceBuilders-UyyfZy8w.cjs");
 const require_solidBuilders = require("./solidBuilders-DiUv_mD0.cjs");
 const require_healingFns = require("./healingFns-xLJ6Cp_O.cjs");
-const require_threadFns = require("./threadFns-C8bErjVC.cjs");
+const require_threadFns = require("./threadFns-KrG_i9_w.cjs");
 const require_blueprintSketcher = require("./blueprintSketcher-RK-cH6ps.cjs");
 const require_helpers = require("./helpers-BSLPCflF.cjs");
 const require_drawFns = require("./drawFns-DNxs7PAT.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-pRVyjy35.cjs");
+const require_refResolveFns = require("./refResolveFns-BiEBAREW.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

@@ -15,7 +15,7 @@ import { n as getAtOrThrow, r as lastOrThrow, t as firstOrThrow } from "./arrayA
 import { _ as makeThreePointArc, d as makeCircle, h as makeLine, l as makeBSplineInterpolation, n as fill, r as makeFace, s as assembleWire } from "./surfaceBuilders-rkE-jE90.js";
 import { _ as section$1, b as split$1, d as booleanPipeline, f as cut$2, g as intersect$2, h as fuseAll$2, m as fuse$2, p as cutAll$2, r as makeCylinder, t as makeCompound, v as sectionToFace$1, y as slice$1 } from "./solidBuilders-C32wXQWG.js";
 import { A as toBufferGeometryData, C as shellWithEvolution, D as getNurbsCurveData, E as fuseAllBisect, M as toLODGeometryData, N as toLODGeometryLevels, O as getNurbsSurfaceData, P as toLineGeometryData, S as intersectWithEvolution, T as cutAllBisect, _ as positionOnCurve, a as healFace, b as filletWithEvolution, c as isValid$1, d as draft$1, f as fillet$1, g as variableFillet, h as thicken$1, i as heal$1, j as toGroupedBufferGeometryData, k as chamferDistAngle, l as solidFromShell, m as shell$1, n as fixSelfIntersection, o as healSolid, p as offset$1, r as fixShape, s as healWire, t as autoHeal, u as chamfer$1, v as chamferWithEvolution, w as checkBoolean, x as fuseWithEvolution, y as cutWithEvolution } from "./healingFns-2TJHHDg5.js";
-import { A as setJointValue, B as findNode, C as cylindricalJoint, D as planarJoint, E as mechanismDOF, F as quatRotate, G as gridPattern, H as updateNode, I as addChild, J as createAssembly, K as linearPattern, L as collectShapes, M as sphericalJoint, N as quatFromAxisAngle, O as prismaticJoint, P as quatFromTo, R as countNodes, S as addJoint, T as jointTransform, U as walkAssembly, V as removeChild, W as circularPattern, _ as exportURDF, a as deserializeHistory, 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, p as serializeHistory, q as exportAssemblySTEP, 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 createAssemblyNode } from "./threadFns-bCOhVQLb.js";
+import { A as setJointValue, B as findNode, C as cylindricalJoint, D as planarJoint, E as mechanismDOF, F as quatRotate, G as gridPattern, H as updateNode, I as addChild, J as createAssembly, K as linearPattern, L as collectShapes, M as sphericalJoint, N as quatFromAxisAngle, O as prismaticJoint, P as quatFromTo, R as countNodes, S as addJoint, T as jointTransform, U as walkAssembly, V as removeChild, W as circularPattern, _ as exportURDF, a as deserializeHistory, 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, p as serializeHistory, q as exportAssemblySTEP, 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 createAssemblyNode } from "./threadFns-Dgr2qyJv.js";
 import { n as BaseSketcher2d, r as organiseBlueprints, t as BlueprintSketcher } from "./blueprintSketcher-7rtwqUHZ.js";
 import { a as createTypedFinder, i as wireFinder, n as edgeFinder, r as faceFinder, t as getSingleFace } from "./helpers-DhJwFrkC.js";
 import { A as sketchEllipse, D as makeBaseBox, E as deserializeDrawing, F as sketchRectangle, I as sketchRoundedRectangle, L as FaceSketcher, M as sketchHelix, N as sketchParametricFunction, O as polysideInnerRadius, P as sketchPolysides, R as Sketcher, S as drawText, _ as drawPolysides, a as drawingIntersect, b as drawSingleCircle, c as rotateDrawing, d as drawFaceOutline, f as drawProjection, g as drawPointsInterpolation, h as drawParametricFunction, i as drawingFuse, j as sketchFaceOffset, k as sketchCircle, l as scaleDrawing, m as drawEllipse, n as drawingCut, o as drawingToSketchOnPlane, p as drawCircle, r as drawingFillet, s as mirrorDrawing, t as drawingChamfer, u as translateDrawing, v as drawRectangle, w as draw, x as drawSingleEllipse, y as drawRoundedRectangle } from "./drawFns-SQIBls6p.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-hEOEcFZ8.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-Ck6kJzLE.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/operations.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_threadFns = require("./threadFns-C8bErjVC.cjs");
+const require_threadFns = require("./threadFns-KrG_i9_w.cjs");
 const require_loftFns = require("./loftFns-fpTmrIdd.cjs");
 exports.addChild = require_threadFns.addChild;
 exports.addJoint = require_threadFns.addJoint;

package/dist/operations.js

@@ -1,3 +1,3 @@
-import { A as setJointValue, B as findNode, C as cylindricalJoint, D as planarJoint, E as mechanismDOF, G as gridPattern, H as updateNode, I as addChild, J as createAssembly, K as linearPattern, L as collectShapes, M as sphericalJoint, O as prismaticJoint, R as countNodes, S as addJoint, T as jointTransform, U as walkAssembly, V as removeChild, W as circularPattern, _ 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 exportAssemblySTEP, 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 createAssemblyNode } from "./threadFns-bCOhVQLb.js";
+import { A as setJointValue, B as findNode, C as cylindricalJoint, D as planarJoint, E as mechanismDOF, G as gridPattern, H as updateNode, I as addChild, J as createAssembly, K as linearPattern, L as collectShapes, M as sphericalJoint, O as prismaticJoint, R as countNodes, S as addJoint, T as jointTransform, U as walkAssembly, V as removeChild, W as circularPattern, _ 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 exportAssemblySTEP, 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 createAssemblyNode } from "./threadFns-Dgr2qyJv.js";
 import { d as twistExtrude, l as supportExtrude, o as complexExtrude, u as sweep } from "./loftFns-CmShFQlv.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/{refResolveFns-pRVyjy35.cjs → refResolveFns-BiEBAREW.cjs}

@@ -739,19 +739,38 @@ function resolveRefIn(ref, shape) {
 	return resolveLineageRef(ref, rolesFor(ref, shape, /* @__PURE__ */ new Map()), shape);
 }
 /**
+* A plain options object worth recursing into for nested refs — a literal `{}`
+* (or null-prototype) that isn't a lineage ref, a shape handle, or a Date/Map/
+* class instance (which `Object.entries` would silently flatten away).
+*/
+function isPlainOptions(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null) return false;
+	return !("wrapped" in value);
+}
+/**
 * Replace every lineage ref in an operation's params with the live entity it
-* resolves to in `shape`, recursing into arrays (multi-entity selections like a
-* fillet's edge list). Refs that can't resolve are left as-is. Role tables are
-* re-derived once per `origin` and reused across the whole params map. Lets a
-* replay engine pass stable entity selections that survive upstream edits.
+* resolves to in `shape`, recursing into arrays (a fillet's edge list) and
+* nested plain objects (a `{ selection: { edge } }` options bag). Refs that
+* can't resolve are left as-is. Role tables are re-derived once per `origin` and
+* reused across the whole params map. Lets a replay engine pass stable entity
+* selections that survive upstream edits.
 */
 function resolveRefParams(params, shape) {
 	const roleCache = /* @__PURE__ */ new Map();
 	const resolveValue = (value) => {
+		if (isLineageRef(value)) {
+			const res = resolveLineageRef(value, rolesFor(value, shape, roleCache), shape);
+			return res.ok ? res.entity : value;
+		}
 		if (Array.isArray(value)) return value.map(resolveValue);
-		if (!isLineageRef(value)) return value;
-		const res = resolveLineageRef(value, rolesFor(value, shape, roleCache), shape);
-		return res.ok ? res.entity : value;
+		if (isPlainOptions(value)) {
+			const nested = {};
+			for (const [k, v] of Object.entries(value)) nested[k] = resolveValue(v);
+			return nested;
+		}
+		return value;
 	};
 	const out = { ...params };
 	for (const [key, value] of Object.entries(params)) out[key] = resolveValue(value);

package/dist/{refResolveFns-hEOEcFZ8.js → refResolveFns-Ck6kJzLE.js}

@@ -739,19 +739,38 @@ function resolveRefIn(ref, shape) {
 	return resolveLineageRef(ref, rolesFor(ref, shape, /* @__PURE__ */ new Map()), shape);
 }
 /**
+* A plain options object worth recursing into for nested refs — a literal `{}`
+* (or null-prototype) that isn't a lineage ref, a shape handle, or a Date/Map/
+* class instance (which `Object.entries` would silently flatten away).
+*/
+function isPlainOptions(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null) return false;
+	return !("wrapped" in value);
+}
+/**
 * Replace every lineage ref in an operation's params with the live entity it
-* resolves to in `shape`, recursing into arrays (multi-entity selections like a
-* fillet's edge list). Refs that can't resolve are left as-is. Role tables are
-* re-derived once per `origin` and reused across the whole params map. Lets a
-* replay engine pass stable entity selections that survive upstream edits.
+* resolves to in `shape`, recursing into arrays (a fillet's edge list) and
+* nested plain objects (a `{ selection: { edge } }` options bag). Refs that
+* can't resolve are left as-is. Role tables are re-derived once per `origin` and
+* reused across the whole params map. Lets a replay engine pass stable entity
+* selections that survive upstream edits.
 */
 function resolveRefParams(params, shape) {
 	const roleCache = /* @__PURE__ */ new Map();
 	const resolveValue = (value) => {
+		if (isLineageRef(value)) {
+			const res = resolveLineageRef(value, rolesFor(value, shape, roleCache), shape);
+			return res.ok ? res.entity : value;
+		}
 		if (Array.isArray(value)) return value.map(resolveValue);
-		if (!isLineageRef(value)) return value;
-		const res = resolveLineageRef(value, rolesFor(value, shape, roleCache), shape);
-		return res.ok ? res.entity : value;
+		if (isPlainOptions(value)) {
+			const nested = {};
+			for (const [k, v] of Object.entries(value)) nested[k] = resolveValue(v);
+			return nested;
+		}
+		return value;
 	};
 	const out = { ...params };
 	for (const [key, value] of Object.entries(params)) out[key] = resolveValue(value);

package/dist/shapeRef.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_refResolveFns = require("./refResolveFns-pRVyjy35.cjs");
+const require_refResolveFns = require("./refResolveFns-BiEBAREW.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-hEOEcFZ8.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-Ck6kJzLE.js";
 export { assignRoles, captureHint, createDerivedFaceRef, createEdgeRef, createRef, createVertexRef, defaultScorer, isDerivedFaceRef, isEdgeRef, isFaceRef, isLineageRef, isVertexRef, resolveDerivedFaceRef, resolveEdgeRef, resolveLineageRef, resolveRef, resolveRefIn, resolveRefParams, resolveVertexRef, updateRoles };

package/dist/{threadFns-bCOhVQLb.js → threadFns-Dgr2qyJv.js}

@@ -1,10 +1,11 @@
-import { B as createKernelHandle, R as DisposalScope, Y as _usingCtx, Z as getKernel, t as castShape } from "./shapeTypes-Dpu6mD3m.js";
+import { B as createKernelHandle, R as DisposalScope, Y as _usingCtx, Z as getKernel, h as isShape3D, t as castShape } from "./shapeTypes-Dpu6mD3m.js";
 import { A as ok, T as isOk, b as err, d as validationError, n as computationError, r as ioError, t as BrepErrorCode } from "./errors-DNWJsfVU.js";
 import { d as vecNormalize, s as vecIsZero } from "./vecOps-SKPRvPH-.js";
 import { y as fromBREP } from "./faceFns-B86WGqDg.js";
 import { s as toBREP } from "./shapeFns-DrZOVwHX.js";
 import { h as fuseAll } from "./solidBuilders-C32wXQWG.js";
 import { t as loft } from "./loftFns-CmShFQlv.js";
+import { c as resolveRefParams } from "./refResolveFns-Ck6kJzLE.js";
 import { E as wire, h as line } from "./primitiveFns-CBrOyk5S.js";
 //#region src/utils/uuid.ts
 /** Generate a v4-style UUID string using `crypto.getRandomValues`. */
@@ -1300,6 +1301,22 @@ function registerOperation(registry, type, fn) {
 	return { operations: ops };
 }
 /**
+* Resolve any lineage refs in a step's params against its input shape, so an
+* operation re-targets the SAME entity (edge/face/vertex) after an upstream
+* parameter edit rebuilds the model. The stored step keeps its refs; resolution
+* happens fresh at replay.
+*
+* Only **single-input** steps auto-resolve: with multiple inputs we can't tell
+* which input a ref targets, and resolving against the wrong one could silently
+* return an entity from the wrong shape. Multi-input refs (and ref-free or non-3D
+* cases) are left raw for the operation to resolve against the input it chooses.
+*/
+function resolveStepParams(params, inputs) {
+	const [primary, second] = inputs;
+	if (primary !== void 0 && second === void 0 && isShape3D(primary)) return resolveRefParams(params, primary);
+	return { ...params };
+}
+/**
 * Replay an entire history from scratch using the given registry.
 *
 * All initial shapes (those not produced by any step) must already be in the
@@ -1323,7 +1340,7 @@ function replayHistory(history, registry) {
 			inputs.push(shape);
 		}
 		try {
-			const output = fn(inputs, step.parameters);
+			const output = fn(inputs, resolveStepParams(step.parameters, inputs));
 			current = addStep(current, {
 				id: step.id,
 				type: step.type,
@@ -1367,7 +1384,7 @@ function replayFrom(history, stepId, registry) {
 			inputs.push(shape);
 		}
 		try {
-			const output = fn(inputs, step.parameters);
+			const output = fn(inputs, resolveStepParams(step.parameters, inputs));
 			current = addStep(current, {
 				id: step.id,
 				type: step.type,

package/dist/{threadFns-C8bErjVC.cjs → threadFns-KrG_i9_w.cjs}

@@ -5,6 +5,7 @@ const require_faceFns = require("./faceFns-BV0GnTlt.cjs");
 const require_shapeFns = require("./shapeFns-ybo0INGL.cjs");
 const require_solidBuilders = require("./solidBuilders-DiUv_mD0.cjs");
 const require_loftFns = require("./loftFns-fpTmrIdd.cjs");
+const require_refResolveFns = require("./refResolveFns-BiEBAREW.cjs");
 const require_primitiveFns = require("./primitiveFns-DLIWtQWA.cjs");
 //#region src/utils/uuid.ts
 /** Generate a v4-style UUID string using `crypto.getRandomValues`. */
@@ -1300,6 +1301,22 @@ function registerOperation(registry, type, fn) {
 	return { operations: ops };
 }
 /**
+* Resolve any lineage refs in a step's params against its input shape, so an
+* operation re-targets the SAME entity (edge/face/vertex) after an upstream
+* parameter edit rebuilds the model. The stored step keeps its refs; resolution
+* happens fresh at replay.
+*
+* Only **single-input** steps auto-resolve: with multiple inputs we can't tell
+* which input a ref targets, and resolving against the wrong one could silently
+* return an entity from the wrong shape. Multi-input refs (and ref-free or non-3D
+* cases) are left raw for the operation to resolve against the input it chooses.
+*/
+function resolveStepParams(params, inputs) {
+	const [primary, second] = inputs;
+	if (primary !== void 0 && second === void 0 && require_shapeTypes.isShape3D(primary)) return require_refResolveFns.resolveRefParams(params, primary);
+	return { ...params };
+}
+/**
 * Replay an entire history from scratch using the given registry.
 *
 * All initial shapes (those not produced by any step) must already be in the
@@ -1323,7 +1340,7 @@ function replayHistory(history, registry) {
 			inputs.push(shape);
 		}
 		try {
-			const output = fn(inputs, step.parameters);
+			const output = fn(inputs, resolveStepParams(step.parameters, inputs));
 			current = addStep(current, {
 				id: step.id,
 				type: step.type,
@@ -1367,7 +1384,7 @@ function replayFrom(history, stepId, registry) {
 			inputs.push(shape);
 		}
 		try {
-			const output = fn(inputs, step.parameters);
+			const output = fn(inputs, resolveStepParams(step.parameters, inputs));
 			current = addStep(current, {
 				id: step.id,
 				type: step.type,

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

@@ -45,9 +45,10 @@ export declare function resolveLineageRef(ref: LineageRef, roles: RoleTable, sha
 export declare function resolveRefIn(ref: LineageRef, shape: Shape3D): LineageResolution;
 /**
  * Replace every lineage ref in an operation's params with the live entity it
- * resolves to in `shape`, recursing into arrays (multi-entity selections like a
- * fillet's edge list). Refs that can't resolve are left as-is. Role tables are
- * re-derived once per `origin` and reused across the whole params map. Lets a
- * replay engine pass stable entity selections that survive upstream edits.
+ * resolves to in `shape`, recursing into arrays (a fillet's edge list) and
+ * nested plain objects (a `{ selection: { edge } }` options bag). Refs that
+ * can't resolve are left as-is. Role tables are re-derived once per `origin` and
+ * reused across the whole params map. Lets a replay engine pass stable entity
+ * selections that survive upstream edits.
  */
 export declare function resolveRefParams(params: Readonly<Record<string, unknown>>, shape: Shape3D): Record<string, unknown>;

package/package.json

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