brepjs 18.109.0 → 18.110.0

package/dist/brepjs.cjs

@@ -29,7 +29,7 @@ const require_importFns = require("./importFns-CgMQIi0z.cjs");
 const require_loftFns = require("./loftFns-fpTmrIdd.cjs");
 const require_cameraFns = require("./cameraFns-uo1sZbBT.cjs");
 const require_textMetrics = require("./textMetrics-IC_IoI7l.cjs");
-const require_shapeRefFns = require("./shapeRefFns--2FPCL7P.cjs");
+const require_shapeRefFns = require("./shapeRefFns-CuepnFOm.cjs");
 const require_workerPool = require("./workerPool-D30NsiIW.cjs");
 const require_primitiveFns = require("./primitiveFns-DLIWtQWA.cjs");
 //#region src/topology/shapeBooleans.ts

package/dist/brepjs.js

@@ -28,7 +28,7 @@ import { a as revolve$1, c as multiSectionSweep, d as twistExtrude, i as extrude
 import { a as Sketch, c as compoundSketchLoft, d as sketchFace, f as sketchLoft, h as sketchWires, i as Sketches, l as compoundSketchRevolve, m as sketchSweep, n as getFont, o as compoundSketchExtrude, p as sketchRevolve, r as loadFont, s as compoundSketchFace, t as textBlueprints, u as sketchExtrude, v as CompoundSketch } from "./textBlueprints-BnkWAqwS.js";
 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 updateRoles, i as resolveRef, n as captureHint, o as defaultScorer, r as createRef, t as assignRoles } from "./shapeRefFns-C1DefNzr.js";
+import { a as updateRoles, i as resolveRef, n as captureHint, o as defaultScorer, r as createRef, t as assignRoles } from "./shapeRefFns-ChMnsOAF.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

package/dist/shapeRef.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_shapeRefFns = require("./shapeRefFns--2FPCL7P.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-C1DefNzr.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-C1DefNzr.js → shapeRefFns-ChMnsOAF.js}

@@ -1,4 +1,3 @@
-import { n as wasmIndex } from "./vec3-Dpha8d5k.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";
@@ -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--2FPCL7P.cjs → shapeRefFns-CuepnFOm.cjs}

@@ -1,4 +1,3 @@
-const require_vec3 = require("./vec3-CFwOI0ZI.cjs");
 const require_topologyQueryFns = require("./topologyQueryFns-CoXVHuN7.cjs");
 const require_faceFns = require("./faceFns-BV0GnTlt.cjs");
 const require_shapeFns = require("./shapeFns-ybo0INGL.cjs");
@@ -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/topology/shapeRef/shapeRefFns.d.ts

@@ -15,32 +15,38 @@ export declare function captureHint(face: Face): GeometricHint;
  *
  * 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).
  */
-export declare function assignRoles(shape: Shape3D, operationType: string): Map<string, number>;
+export declare function assignRoles(shape: Shape3D, operationType: string): Map<string, number[]>;
 /** Create a ShapeRef from an origin ID, role name, and face. */
 export declare function createRef(origin: string, role: string, face: Face): ShapeRef;
 /**
  * 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.
  */
 export declare function updateRoles(roles: RoleTable, origin: string, evolution: ShapeEvolution): RoleTable;
 /**
  * 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
+ * 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.
  */
 export declare function resolveRef(ref: ShapeRef, roles: RoleTable, currentShape: Shape3D, scorer?: FaceScorer): ResolvedRef | BrokenRef;

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

@@ -22,10 +22,14 @@ export interface ShapeRef {
     readonly hint: GeometricHint;
 }
 /**
- * Immutable table mapping `origin -> role -> faceHash`.
+ * Immutable table mapping `origin -> role -> faceHashes`.
  * Updated through evolution records when the model is rebuilt.
+ *
+ * A role usually maps to a single hash, but maps to several after its face
+ * splits (a 1→many `modified` evolution); resolution then disambiguates among
+ * the surviving successors rather than competing against the whole shape.
  */
-export type RoleTable = ReadonlyMap<string, ReadonlyMap<string, number>>;
+export type RoleTable = ReadonlyMap<string, ReadonlyMap<string, readonly number[]>>;
 /** A successfully resolved face reference. */
 export interface ResolvedRef {
     readonly face: Face;

package/package.json

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