brepjs 18.108.0 → 18.110.0

package/dist/{shapeFns-DyBbhU30.js → shapeFns-DrZOVwHX.js}

@@ -1,6 +1,6 @@
-import { Z as getKernel, t as castShape } from "./shapeTypes-C4lPfrc2.js";
+import { Z as getKernel, t as castShape } from "./shapeTypes-Dpu6mD3m.js";
 import { A as ok, b as err, d as validationError, t as BrepErrorCode } from "./errors-DNWJsfVU.js";
-import { C as kernelCall, c as getFaces, l as getOrCreateCache, r as getCacheEntry, w as kernelCallRaw } from "./topologyQueryFns-Do8E4EXj.js";
+import { C as kernelCall, c as getFaces, l as getOrCreateCache, r as getCacheEntry, w as kernelCallRaw } from "./topologyQueryFns-BeKaWpNm.js";
 import { n as HASH_CODE_MAX, t as DEG2RAD } from "./constants-ITRzCnCp.js";
 //#region src/topology/metadata/originTrackingFns.ts
 /**
@@ -376,8 +376,16 @@ function propagateColorsFromEvolution(evolution, inputs, result) {
 * Fast-path: returns empty array when no inputs have any metadata (origins,
 * tags, or colors), avoiding expensive WASM topology exploration.
 */
+/**
+* O(1) check: does a shape carry any propagatable metadata (face origins,
+* tags, or colors)? Lets callers skip both expensive face iteration and
+* metadata-preserving slow paths when there's nothing to preserve.
+*/
+function hasAnyMetadata(shape) {
+	return getFaceOrigins(shape) !== void 0 || hasFaceTags(shape) || hasColorMetadata(shape);
+}
 function collectInputFaceHashes(inputs) {
-	if (!inputs.some((s) => getFaceOrigins(s) !== void 0 || hasFaceTags(s) || hasColorMetadata(s))) return [];
+	if (!inputs.some(hasAnyMetadata)) return [];
 	const kernel = getKernel();
 	const hashes = [];
 	for (const input of inputs) {
@@ -412,6 +420,38 @@ function propagateAllMetadata(evolution, inputs, result) {
 function propagateMetadataByHash(inputs, result) {
 	propagateOriginsByHash(inputs, result);
 }
+/**
+* Propagate all metadata through a *rigid relocation* (a `locate` re-tag).
+*
+* A relocated shape shares the source's TShape, so its faces correspond 1:1 to
+* the source faces in iteration order — but carry new, location-dependent
+* hashes, so the hash-keyed metadata must be re-keyed rather than left as-is.
+* This synthesizes a 1:1 `modified` evolution (source face hash → moved face
+* hash) and runs the standard propagation pipeline, so origins, tags, and
+* colors all survive a move at `locate` cost (O(faces)), not a full copy.
+*
+* Callers should gate on {@link hasAnyMetadata} first: with no metadata this
+* does pointless face iteration. The face counts always match for a rigid
+* relocation; the length guard is purely defensive.
+*/
+function propagateMetadataThroughRelocation(source, moved) {
+	const kernel = getKernel();
+	const srcFaces = [...kernel.iterShapes(source.wrapped, "face")];
+	const movedFaces = [...kernel.iterShapes(moved.wrapped, "face")];
+	if (srcFaces.length !== movedFaces.length) return;
+	const modified = /* @__PURE__ */ new Map();
+	for (let i = 0; i < srcFaces.length; i++) {
+		const sf = srcFaces[i];
+		const mf = movedFaces[i];
+		if (sf === void 0 || mf === void 0) continue;
+		modified.set(kernel.hashCode(sf, HASH_CODE_MAX), [kernel.hashCode(mf, HASH_CODE_MAX)]);
+	}
+	propagateAllMetadata({
+		modified,
+		generated: /* @__PURE__ */ new Map(),
+		deleted: /* @__PURE__ */ new Set()
+	}, [source], moved);
+}
 //#endregion
 //#region src/topology/transformFns.ts
 /**
@@ -653,4 +693,4 @@ function simplify(shape) {
 	return kernelCall(() => getKernel().simplify(shape.wrapped), BrepErrorCode.SIMPLIFY_FAILED, "Failed to simplify shape");
 }
 //#endregion
-export { findFacesByTag as C, tagFaces as D, setTagMetadata as E, getFaceOrigins as O, getShapeColor as S, getTagMetadata as T, propagateAllMetadata as _, isSameShape as a, colorShape as b, applyMatrix as c, resize as d, rotate as f, collectInputFaceHashes as g, translate as h, isEqualShape as i, setShapeOrigin as k, composeTransforms as l, transformCopy as m, getHashCode as n, simplify as o, scale as p, isEmpty as r, toBREP as s, clone as t, mirror as u, propagateMetadataByHash as v, getFaceTags as w, getFaceColor as x, colorFaces as y };
+export { getFaceOrigins as A, getFaceColor as C, getTagMetadata as D, getFaceTags as E, setTagMetadata as O, colorShape as S, findFacesByTag as T, hasAnyMetadata as _, isSameShape as a, propagateMetadataThroughRelocation as b, applyMatrix as c, resize as d, rotate as f, collectInputFaceHashes as g, translate as h, isEqualShape as i, setShapeOrigin as j, tagFaces as k, composeTransforms as l, transformCopy as m, getHashCode as n, simplify as o, scale as p, isEmpty as r, toBREP as s, clone as t, mirror as u, propagateAllMetadata as v, getShapeColor as w, colorFaces as x, propagateMetadataByHash as y };

package/dist/{shapeFns-L4a8kH_A.cjs → shapeFns-ybo0INGL.cjs}

@@ -1,6 +1,6 @@
-const require_shapeTypes = require("./shapeTypes-Bwgm5N6R.cjs");
+const require_shapeTypes = require("./shapeTypes-BTTwjHy5.cjs");
 const require_errors = require("./errors-CXJtc4I7.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-ygBBXxnP.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-CoXVHuN7.cjs");
 const require_constants = require("./constants-BOVyEYGH.cjs");
 //#region src/topology/metadata/originTrackingFns.ts
 /**
@@ -376,8 +376,16 @@ function propagateColorsFromEvolution(evolution, inputs, result) {
 * Fast-path: returns empty array when no inputs have any metadata (origins,
 * tags, or colors), avoiding expensive WASM topology exploration.
 */
+/**
+* O(1) check: does a shape carry any propagatable metadata (face origins,
+* tags, or colors)? Lets callers skip both expensive face iteration and
+* metadata-preserving slow paths when there's nothing to preserve.
+*/
+function hasAnyMetadata(shape) {
+	return getFaceOrigins(shape) !== void 0 || hasFaceTags(shape) || hasColorMetadata(shape);
+}
 function collectInputFaceHashes(inputs) {
-	if (!inputs.some((s) => getFaceOrigins(s) !== void 0 || hasFaceTags(s) || hasColorMetadata(s))) return [];
+	if (!inputs.some(hasAnyMetadata)) return [];
 	const kernel = require_shapeTypes.getKernel();
 	const hashes = [];
 	for (const input of inputs) {
@@ -412,6 +420,38 @@ function propagateAllMetadata(evolution, inputs, result) {
 function propagateMetadataByHash(inputs, result) {
 	propagateOriginsByHash(inputs, result);
 }
+/**
+* Propagate all metadata through a *rigid relocation* (a `locate` re-tag).
+*
+* A relocated shape shares the source's TShape, so its faces correspond 1:1 to
+* the source faces in iteration order — but carry new, location-dependent
+* hashes, so the hash-keyed metadata must be re-keyed rather than left as-is.
+* This synthesizes a 1:1 `modified` evolution (source face hash → moved face
+* hash) and runs the standard propagation pipeline, so origins, tags, and
+* colors all survive a move at `locate` cost (O(faces)), not a full copy.
+*
+* Callers should gate on {@link hasAnyMetadata} first: with no metadata this
+* does pointless face iteration. The face counts always match for a rigid
+* relocation; the length guard is purely defensive.
+*/
+function propagateMetadataThroughRelocation(source, moved) {
+	const kernel = require_shapeTypes.getKernel();
+	const srcFaces = [...kernel.iterShapes(source.wrapped, "face")];
+	const movedFaces = [...kernel.iterShapes(moved.wrapped, "face")];
+	if (srcFaces.length !== movedFaces.length) return;
+	const modified = /* @__PURE__ */ new Map();
+	for (let i = 0; i < srcFaces.length; i++) {
+		const sf = srcFaces[i];
+		const mf = movedFaces[i];
+		if (sf === void 0 || mf === void 0) continue;
+		modified.set(kernel.hashCode(sf, require_constants.HASH_CODE_MAX), [kernel.hashCode(mf, require_constants.HASH_CODE_MAX)]);
+	}
+	propagateAllMetadata({
+		modified,
+		generated: /* @__PURE__ */ new Map(),
+		deleted: /* @__PURE__ */ new Set()
+	}, [source], moved);
+}
 //#endregion
 //#region src/topology/transformFns.ts
 /**
@@ -731,6 +771,12 @@ Object.defineProperty(exports, "getTagMetadata", {
 		return getTagMetadata;
 	}
 });
+Object.defineProperty(exports, "hasAnyMetadata", {
+	enumerable: true,
+	get: function() {
+		return hasAnyMetadata;
+	}
+});
 Object.defineProperty(exports, "isEmpty", {
 	enumerable: true,
 	get: function() {
@@ -767,6 +813,12 @@ Object.defineProperty(exports, "propagateMetadataByHash", {
 		return propagateMetadataByHash;
 	}
 });
+Object.defineProperty(exports, "propagateMetadataThroughRelocation", {
+	enumerable: true,
+	get: function() {
+		return propagateMetadataThroughRelocation;
+	}
+});
 Object.defineProperty(exports, "resize", {
 	enumerable: true,
 	get: function() {

package/dist/shapeRef.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_shapeRefFns = require("./shapeRefFns-Dij41NuC.cjs");
+const require_shapeRefFns = require("./shapeRefFns-CuepnFOm.cjs");
 exports.assignRoles = require_shapeRefFns.assignRoles;
 exports.captureHint = require_shapeRefFns.captureHint;
 exports.createRef = require_shapeRefFns.createRef;

package/dist/shapeRef.js

@@ -1,2 +1,2 @@
-import { a as updateRoles, i as resolveRef, n as captureHint, o as defaultScorer, r as createRef, t as assignRoles } from "./shapeRefFns-Cn4WNb3q.js";
+import { a as updateRoles, i as resolveRef, n as captureHint, o as defaultScorer, r as createRef, t as assignRoles } from "./shapeRefFns-ChMnsOAF.js";
 export { assignRoles, captureHint, createRef, defaultScorer, resolveRef, updateRoles };

package/dist/{shapeRefFns-Cn4WNb3q.js → shapeRefFns-ChMnsOAF.js}

@@ -1,8 +1,7 @@
-import { n as wasmIndex } from "./vec3-Dpha8d5k.js";
-import { c as getFaces } from "./topologyQueryFns-Do8E4EXj.js";
-import { i as faceGeomType, l as normalAt, r as faceCenter } from "./faceFns-mo4ThIHz.js";
-import { n as getHashCode } from "./shapeFns-DyBbhU30.js";
-import { n as measureArea } from "./measureFns-Dkh_DmrE.js";
+import { c as getFaces } from "./topologyQueryFns-BeKaWpNm.js";
+import { i as faceGeomType, l as normalAt, r as faceCenter } from "./faceFns-B86WGqDg.js";
+import { n as getHashCode } from "./shapeFns-DrZOVwHX.js";
+import { n as measureArea } from "./measureFns-a5Vx25or.js";
 //#region src/topology/shapeRef/scoring.ts
 /**
 * Default face scorer combining surface type, normal alignment, centroid proximity,
@@ -81,7 +80,8 @@ function boxRoleFromNormal(n) {
 *
 * For other types: sequential naming ('opType:face_0', 'opType:face_1', ...).
 *
-* @returns Map from role name to face hash code
+* @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);
@@ -89,13 +89,13 @@ function assignRoles(shape, operationType) {
 	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));
+			if (role !== void 0 && !roles.has(role)) roles.set(role, [getHashCode(face)]);
 		}
 		return roles;
 	}
 	let index = 0;
 	for (const face of faces) {
-		roles.set(`${operationType}:face_${index}`, getHashCode(face));
+		roles.set(`${operationType}:face_${index}`, [getHashCode(face)]);
 		index++;
 	}
 	return roles;
@@ -109,31 +109,47 @@ function createRef(origin, role, face) {
 	};
 }
 /**
+* Advance a role's face hashes through one evolution: drop deleted faces,
+* replace a modified face with *all* its successors (a 1→many split keeps every
+* fragment), and keep unchanged faces. Deduped so a shared successor isn't
+* doubled.
+*/
+function nextHashes(hashes, evolution) {
+	const successors = [];
+	for (const hash of hashes) {
+		if (evolution.deleted.has(hash)) continue;
+		const modified = evolution.modified.get(hash);
+		const targets = modified && modified.length > 0 ? modified : [hash];
+		for (const h of targets) if (!successors.includes(h)) successors.push(h);
+	}
+	return successors;
+}
+/**
 * Propagate a role table through a ShapeEvolution record.
 * Returns a new RoleTable with hashes updated according to the evolution.
 *
-* - Deleted faces: role removed
-* - Modified faces: hash updated to first result hash
-* - Unchanged faces: hash preserved
+* - Deleted faces: hash dropped (role removed once all its hashes are gone).
+* - Modified faces: hash replaced by **all** successor hashes — so a 1→many
+*   split keeps every fragment, and `resolveRef` disambiguates among them.
+* - Unchanged faces: hash preserved.
 *
-* **Limitation:** When a face splits (1→many in `evolution.modified`), only the
-* first successor hash is tracked. The geometric fallback in `resolveRef` handles
-* cases where this picks the "wrong" successor. A future version may return
-* multi-hash mappings for split-aware resolution.
+* Note: `evolution.generated` is intentionally not consumed here — on the OCCT
+* kernels its hashes refer to an intermediate shape, not the final result, so
+* naming generated faces produces roles that never resolve (verified: 0 live
+* generated hashes across cut/fuse on occt-wasm). Stable names for generated
+* geometry (fillet rounds, boolean seams) need history-fidelity work tracked
+* separately.
 */
 function updateRoles(roles, origin, evolution) {
 	const originRoles = roles.get(origin);
 	if (!originRoles) return roles;
 	const updatedOriginRoles = /* @__PURE__ */ new Map();
-	for (const [role, hash] of originRoles) {
-		if (evolution.deleted.has(hash)) continue;
-		const modifiedHashes = evolution.modified.get(hash);
-		if (modifiedHashes && modifiedHashes.length > 0) updatedOriginRoles.set(role, wasmIndex(modifiedHashes, 0));
-		else updatedOriginRoles.set(role, hash);
+	for (const [role, hashes] of originRoles) {
+		const successors = nextHashes(hashes, evolution);
+		if (successors.length > 0) updatedOriginRoles.set(role, successors);
 	}
 	const newRoles = /* @__PURE__ */ new Map();
-	for (const [key, value] of roles) if (key === origin) newRoles.set(key, updatedOriginRoles);
-	else newRoles.set(key, value);
+	for (const [key, value] of roles) newRoles.set(key, key === origin ? updatedOriginRoles : value);
 	return newRoles;
 }
 /** Ambiguity threshold: if two scores are within this range, it's ambiguous. */
@@ -141,34 +157,19 @@ var AMBIGUITY_THRESHOLD = .1;
 /** Minimum score for geometric fallback to accept a match. */
 var MIN_SCORE = .5;
 /**
-* Resolve a ShapeRef to a face in the current shape.
-*
-* Resolution strategy:
-* 1. Exact lookup via role table hash match
-* 2. Geometric fallback using scorer against all faces
-* 3. Ambiguous if multiple faces score within threshold
-* 4. Not-found if no match above minimum score
+* Score `candidates` against `hint`, returning the best match, a tie within
+* {@link AMBIGUITY_THRESHOLD}, or nothing above {@link MIN_SCORE}. Scoping the
+* candidates to a role's tracked successors (rather than every face) is what
+* makes split-face disambiguation reliable — the fragments compete only with
+* each other, not with unrelated geometry.
 */
-function resolveRef(ref, roles, currentShape, scorer) {
-	const faces = getFaces(currentShape);
-	const scoreFn = scorer ?? defaultScorer;
-	const targetHash = roles.get(ref.origin)?.get(ref.role);
-	if (targetHash !== void 0) {
-		for (const face of faces) if (getHashCode(face) === targetHash) return {
-			face,
-			confidence: "exact"
-		};
-		return {
-			ref,
-			reason: "deleted"
-		};
-	}
+function scoreFaces(hint, candidates, scoreFn) {
 	let bestScore = -Infinity;
 	let bestFace;
 	let secondBestScore = -Infinity;
 	const scored = [];
-	for (const face of faces) {
-		const score = scoreFn(ref.hint, face);
+	for (const face of candidates) {
+		const score = scoreFn(hint, face);
 		if (score > MIN_SCORE) scored.push([face, score]);
 		if (score > bestScore) {
 			secondBestScore = bestScore;
@@ -178,15 +179,66 @@ function resolveRef(ref, roles, currentShape, scorer) {
 	}
 	if (bestFace !== void 0 && bestScore > MIN_SCORE) {
 		if (bestScore - secondBestScore < AMBIGUITY_THRESHOLD && scored.length > 1) return {
-			ref,
-			reason: "ambiguous",
+			kind: "ambiguous",
 			candidates: scored.filter(([, s]) => s >= bestScore - AMBIGUITY_THRESHOLD).map(([f]) => f)
 		};
 		return {
-			face: bestFace,
-			confidence: "geometric-fallback"
+			kind: "match",
+			face: bestFace
+		};
+	}
+	return { kind: "none" };
+}
+/**
+* Resolve a ShapeRef to a face in the current shape.
+*
+* Resolution strategy:
+* 1. Exact: the role's tracked successor hashes. One survivor → exact match;
+*    several survivors (a face that split) → disambiguate among *only those*
+*    fragments; none survive → deleted.
+* 2. Geometric fallback over the whole shape when the role isn't tracked (or a
+*    scoped score turned up nothing): best-scoring face, else ambiguous /
+*    not-found.
+*/
+function resolveRef(ref, roles, currentShape, scorer) {
+	const faces = getFaces(currentShape);
+	const scoreFn = scorer ?? defaultScorer;
+	const targetHashes = roles.get(ref.origin)?.get(ref.role);
+	if (targetHashes !== void 0 && targetHashes.length > 0) {
+		const survivors = faces.filter((f) => targetHashes.includes(getHashCode(f)));
+		if (survivors.length === 1) {
+			const [only] = survivors;
+			if (only !== void 0) return {
+				face: only,
+				confidence: "exact"
+			};
+		} else if (survivors.length === 0) return {
+			ref,
+			reason: "deleted"
 		};
+		else {
+			const outcome = scoreFaces(ref.hint, survivors, scoreFn);
+			if (outcome.kind === "match") return {
+				face: outcome.face,
+				confidence: "geometric-fallback"
+			};
+			if (outcome.kind === "ambiguous") return {
+				ref,
+				reason: "ambiguous",
+				candidates: outcome.candidates
+			};
+		}
 	}
+	const outcome = scoreFaces(ref.hint, faces, scoreFn);
+	if (outcome.kind === "match") return {
+		face: outcome.face,
+		confidence: "geometric-fallback"
+	};
+	if (outcome.kind === "ambiguous") return {
+		ref,
+		reason: "ambiguous",
+		candidates: outcome.candidates
+	};
 	return {
 		ref,
 		reason: "not-found"

package/dist/{shapeRefFns-Dij41NuC.cjs → shapeRefFns-CuepnFOm.cjs}

@@ -1,8 +1,7 @@
-const require_vec3 = require("./vec3-CFwOI0ZI.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-ygBBXxnP.cjs");
-const require_faceFns = require("./faceFns-DKg2St8b.cjs");
-const require_shapeFns = require("./shapeFns-L4a8kH_A.cjs");
-const require_measureFns = require("./measureFns-Q2dnokUU.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-CoXVHuN7.cjs");
+const require_faceFns = require("./faceFns-BV0GnTlt.cjs");
+const require_shapeFns = require("./shapeFns-ybo0INGL.cjs");
+const require_measureFns = require("./measureFns-DblG0Yaz.cjs");
 //#region src/topology/shapeRef/scoring.ts
 /**
 * Default face scorer combining surface type, normal alignment, centroid proximity,
@@ -81,7 +80,8 @@ function boxRoleFromNormal(n) {
 *
 * For other types: sequential naming ('opType:face_0', 'opType:face_1', ...).
 *
-* @returns Map from role name to face hash code
+* @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);
@@ -89,13 +89,13 @@ function assignRoles(shape, operationType) {
 	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));
+			if (role !== void 0 && !roles.has(role)) roles.set(role, [require_shapeFns.getHashCode(face)]);
 		}
 		return roles;
 	}
 	let index = 0;
 	for (const face of faces) {
-		roles.set(`${operationType}:face_${index}`, require_shapeFns.getHashCode(face));
+		roles.set(`${operationType}:face_${index}`, [require_shapeFns.getHashCode(face)]);
 		index++;
 	}
 	return roles;
@@ -109,31 +109,47 @@ function createRef(origin, role, face) {
 	};
 }
 /**
+* Advance a role's face hashes through one evolution: drop deleted faces,
+* replace a modified face with *all* its successors (a 1→many split keeps every
+* fragment), and keep unchanged faces. Deduped so a shared successor isn't
+* doubled.
+*/
+function nextHashes(hashes, evolution) {
+	const successors = [];
+	for (const hash of hashes) {
+		if (evolution.deleted.has(hash)) continue;
+		const modified = evolution.modified.get(hash);
+		const targets = modified && modified.length > 0 ? modified : [hash];
+		for (const h of targets) if (!successors.includes(h)) successors.push(h);
+	}
+	return successors;
+}
+/**
 * Propagate a role table through a ShapeEvolution record.
 * Returns a new RoleTable with hashes updated according to the evolution.
 *
-* - Deleted faces: role removed
-* - Modified faces: hash updated to first result hash
-* - Unchanged faces: hash preserved
+* - Deleted faces: hash dropped (role removed once all its hashes are gone).
+* - Modified faces: hash replaced by **all** successor hashes — so a 1→many
+*   split keeps every fragment, and `resolveRef` disambiguates among them.
+* - Unchanged faces: hash preserved.
 *
-* **Limitation:** When a face splits (1→many in `evolution.modified`), only the
-* first successor hash is tracked. The geometric fallback in `resolveRef` handles
-* cases where this picks the "wrong" successor. A future version may return
-* multi-hash mappings for split-aware resolution.
+* Note: `evolution.generated` is intentionally not consumed here — on the OCCT
+* kernels its hashes refer to an intermediate shape, not the final result, so
+* naming generated faces produces roles that never resolve (verified: 0 live
+* generated hashes across cut/fuse on occt-wasm). Stable names for generated
+* geometry (fillet rounds, boolean seams) need history-fidelity work tracked
+* separately.
 */
 function updateRoles(roles, origin, evolution) {
 	const originRoles = roles.get(origin);
 	if (!originRoles) return roles;
 	const updatedOriginRoles = /* @__PURE__ */ new Map();
-	for (const [role, hash] of originRoles) {
-		if (evolution.deleted.has(hash)) continue;
-		const modifiedHashes = evolution.modified.get(hash);
-		if (modifiedHashes && modifiedHashes.length > 0) updatedOriginRoles.set(role, require_vec3.wasmIndex(modifiedHashes, 0));
-		else updatedOriginRoles.set(role, hash);
+	for (const [role, hashes] of originRoles) {
+		const successors = nextHashes(hashes, evolution);
+		if (successors.length > 0) updatedOriginRoles.set(role, successors);
 	}
 	const newRoles = /* @__PURE__ */ new Map();
-	for (const [key, value] of roles) if (key === origin) newRoles.set(key, updatedOriginRoles);
-	else newRoles.set(key, value);
+	for (const [key, value] of roles) newRoles.set(key, key === origin ? updatedOriginRoles : value);
 	return newRoles;
 }
 /** Ambiguity threshold: if two scores are within this range, it's ambiguous. */
@@ -141,34 +157,19 @@ var AMBIGUITY_THRESHOLD = .1;
 /** Minimum score for geometric fallback to accept a match. */
 var MIN_SCORE = .5;
 /**
-* Resolve a ShapeRef to a face in the current shape.
-*
-* Resolution strategy:
-* 1. Exact lookup via role table hash match
-* 2. Geometric fallback using scorer against all faces
-* 3. Ambiguous if multiple faces score within threshold
-* 4. Not-found if no match above minimum score
+* Score `candidates` against `hint`, returning the best match, a tie within
+* {@link AMBIGUITY_THRESHOLD}, or nothing above {@link MIN_SCORE}. Scoping the
+* candidates to a role's tracked successors (rather than every face) is what
+* makes split-face disambiguation reliable — the fragments compete only with
+* each other, not with unrelated geometry.
 */
-function resolveRef(ref, roles, currentShape, scorer) {
-	const faces = require_topologyQueryFns.getFaces(currentShape);
-	const scoreFn = scorer ?? defaultScorer;
-	const targetHash = roles.get(ref.origin)?.get(ref.role);
-	if (targetHash !== void 0) {
-		for (const face of faces) if (require_shapeFns.getHashCode(face) === targetHash) return {
-			face,
-			confidence: "exact"
-		};
-		return {
-			ref,
-			reason: "deleted"
-		};
-	}
+function scoreFaces(hint, candidates, scoreFn) {
 	let bestScore = -Infinity;
 	let bestFace;
 	let secondBestScore = -Infinity;
 	const scored = [];
-	for (const face of faces) {
-		const score = scoreFn(ref.hint, face);
+	for (const face of candidates) {
+		const score = scoreFn(hint, face);
 		if (score > MIN_SCORE) scored.push([face, score]);
 		if (score > bestScore) {
 			secondBestScore = bestScore;
@@ -178,15 +179,66 @@ function resolveRef(ref, roles, currentShape, scorer) {
 	}
 	if (bestFace !== void 0 && bestScore > MIN_SCORE) {
 		if (bestScore - secondBestScore < AMBIGUITY_THRESHOLD && scored.length > 1) return {
-			ref,
-			reason: "ambiguous",
+			kind: "ambiguous",
 			candidates: scored.filter(([, s]) => s >= bestScore - AMBIGUITY_THRESHOLD).map(([f]) => f)
 		};
 		return {
-			face: bestFace,
-			confidence: "geometric-fallback"
+			kind: "match",
+			face: bestFace
+		};
+	}
+	return { kind: "none" };
+}
+/**
+* Resolve a ShapeRef to a face in the current shape.
+*
+* Resolution strategy:
+* 1. Exact: the role's tracked successor hashes. One survivor → exact match;
+*    several survivors (a face that split) → disambiguate among *only those*
+*    fragments; none survive → deleted.
+* 2. Geometric fallback over the whole shape when the role isn't tracked (or a
+*    scoped score turned up nothing): best-scoring face, else ambiguous /
+*    not-found.
+*/
+function resolveRef(ref, roles, currentShape, scorer) {
+	const faces = require_topologyQueryFns.getFaces(currentShape);
+	const scoreFn = scorer ?? defaultScorer;
+	const targetHashes = roles.get(ref.origin)?.get(ref.role);
+	if (targetHashes !== void 0 && targetHashes.length > 0) {
+		const survivors = faces.filter((f) => targetHashes.includes(require_shapeFns.getHashCode(f)));
+		if (survivors.length === 1) {
+			const [only] = survivors;
+			if (only !== void 0) return {
+				face: only,
+				confidence: "exact"
+			};
+		} else if (survivors.length === 0) return {
+			ref,
+			reason: "deleted"
 		};
+		else {
+			const outcome = scoreFaces(ref.hint, survivors, scoreFn);
+			if (outcome.kind === "match") return {
+				face: outcome.face,
+				confidence: "geometric-fallback"
+			};
+			if (outcome.kind === "ambiguous") return {
+				ref,
+				reason: "ambiguous",
+				candidates: outcome.candidates
+			};
+		}
 	}
+	const outcome = scoreFaces(ref.hint, faces, scoreFn);
+	if (outcome.kind === "match") return {
+		face: outcome.face,
+		confidence: "geometric-fallback"
+	};
+	if (outcome.kind === "ambiguous") return {
+		ref,
+		reason: "ambiguous",
+		candidates: outcome.candidates
+	};
 	return {
 		ref,
 		reason: "not-found"

package/dist/{shapeTypes-Bwgm5N6R.cjs → shapeTypes-BTTwjHy5.cjs}

@@ -1,4 +1,4 @@
-const require_occtWasmAdapter = require("./occtWasmAdapter-DDZELjlB.cjs");
+const require_occtWasmAdapter = require("./occtWasmAdapter-B2TEQOjs.cjs");
 const require_vec3 = require("./vec3-CFwOI0ZI.cjs");
 const require_errors = require("./errors-CXJtc4I7.cjs");
 //#region src/kernel/quality.ts
@@ -2215,6 +2215,20 @@ function transform$3(oc, shape, trsf) {
 	return result;
 }
 /**
+* Apply a rigid transform as a location re-tag. Passing copy=false makes
+* BRepBuilderAPI_Transform share the source TShape under a new location for a
+* rigid motion, instead of the deep topology copy {@link transform} (copy=true)
+* performs. Use only for rigid `trsf` (rotation + translation).
+*/
+function locate(oc, shape, trsf) {
+	const transformer = new oc.BRepBuilderAPI_Transform_2(shape, trsf, false, false);
+	try {
+		return transformer.ModifiedShape(shape);
+	} finally {
+		transformer.delete();
+	}
+}
+/**
 * Translates a shape by the given offset.
 */
 function translate$2(oc, shape, x, y, z) {
@@ -2322,6 +2336,7 @@ function simplify$2(oc, shape) {
 function makeTransformOps$2(oc) {
 	return {
 		transform: (shape, trsf) => transform$3(oc, shape, trsf),
+		locate: (shape, trsf) => locate(oc, shape, trsf),
 		translate: (shape, x, y, z) => translate$2(oc, shape, x, y, z),
 		rotate: (shape, angle, axis, center) => rotate$2(oc, shape, angle, axis, center),
 		mirror: (shape, origin, normal) => mirror$2(oc, shape, origin, normal),
@@ -6250,6 +6265,7 @@ function transformBatch$1(bk, entries) {
 function makeTransformOps$1(bk) {
 	return {
 		transform: (shape, trsf) => transform$2(bk, shape, trsf),
+		locate: (shape, trsf) => transform$2(bk, shape, trsf),
 		translate: (shape, x, y, z) => translate$1(bk, shape, x, y, z),
 		rotate: (shape, angle, axis, center) => rotate$1(bk, shape, angle, axis, center),
 		mirror: (shape, origin, normal) => mirror$1(bk, shape, origin, normal),
@@ -10492,6 +10508,7 @@ function makeTransformOps(module) {
 	return {
 		composeTransform,
 		transform: transform$1,
+		locate: transform$1,
 		translate,
 		rotate,
 		mirror,