brepjs 18.113.0 → 18.115.0

package/dist/shapeRef.cjs

@@ -1,8 +1,22 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_shapeRefFns = require("./shapeRefFns-CuepnFOm.cjs");
-exports.assignRoles = require_shapeRefFns.assignRoles;
-exports.captureHint = require_shapeRefFns.captureHint;
-exports.createRef = require_shapeRefFns.createRef;
-exports.defaultScorer = require_shapeRefFns.defaultScorer;
-exports.resolveRef = require_shapeRefFns.resolveRef;
-exports.updateRoles = require_shapeRefFns.updateRoles;
+const require_refResolveFns = require("./refResolveFns-pRVyjy35.cjs");
+exports.assignRoles = require_refResolveFns.assignRoles;
+exports.captureHint = require_refResolveFns.captureHint;
+exports.createDerivedFaceRef = require_refResolveFns.createDerivedFaceRef;
+exports.createEdgeRef = require_refResolveFns.createEdgeRef;
+exports.createRef = require_refResolveFns.createRef;
+exports.createVertexRef = require_refResolveFns.createVertexRef;
+exports.defaultScorer = require_refResolveFns.defaultScorer;
+exports.isDerivedFaceRef = require_refResolveFns.isDerivedFaceRef;
+exports.isEdgeRef = require_refResolveFns.isEdgeRef;
+exports.isFaceRef = require_refResolveFns.isFaceRef;
+exports.isLineageRef = require_refResolveFns.isLineageRef;
+exports.isVertexRef = require_refResolveFns.isVertexRef;
+exports.resolveDerivedFaceRef = require_refResolveFns.resolveDerivedFaceRef;
+exports.resolveEdgeRef = require_refResolveFns.resolveEdgeRef;
+exports.resolveLineageRef = require_refResolveFns.resolveLineageRef;
+exports.resolveRef = require_refResolveFns.resolveRef;
+exports.resolveRefIn = require_refResolveFns.resolveRefIn;
+exports.resolveRefParams = require_refResolveFns.resolveRefParams;
+exports.resolveVertexRef = require_refResolveFns.resolveVertexRef;
+exports.updateRoles = require_refResolveFns.updateRoles;

package/dist/shapeRef.d.ts

@@ -1,4 +1,12 @@
 /**
- * brepjs/shapeRef — Stable face references for parametric replay.
+ * brepjs/shapeRef — stable, lineage-based references for parametric replay.
+ *
+ * Name a topological entity by its stable adjacent-neighbor roles (not its
+ * kernel hash) so it survives edits that re-hash the model:
+ * - faces — role + geometric hint (`createRef`/`resolveRef`)
+ * - edges — the 2 adjacent face-roles (`createEdgeRef`/`resolveEdgeRef`)
+ * - vertices — the ≥3 adjacent face-roles (`createVertexRef`/`resolveVertexRef`)
+ * - generated faces (fillet/chamfer) — the 2 bridged face-roles
+ *   (`createDerivedFaceRef`/`resolveDerivedFaceRef`)
  */
-export { type GeometricHint, type ShapeRef, type RoleTable, type ResolvedRef, type BrokenRef, type FaceScorer, defaultScorer, captureHint, assignRoles, createRef, updateRoles, resolveRef, } from './topology/shapeRef/index.js';
+export { type GeometricHint, type ShapeRef, type RoleTable, type ResolvedRef, type BrokenRef, type FaceScorer, type EdgeHint, type EdgeRef, type ResolvedEdgeRef, type BrokenEdgeRef, type VertexHint, type VertexRef, type ResolvedVertexRef, type BrokenVertexRef, type DerivedFaceHint, type DerivedFaceRef, type ResolvedDerivedFaceRef, type BrokenDerivedFaceRef, defaultScorer, captureHint, assignRoles, createRef, updateRoles, resolveRef, createEdgeRef, resolveEdgeRef, createVertexRef, resolveVertexRef, createDerivedFaceRef, resolveDerivedFaceRef, type LineageRef, type ResolvedEntity, type BrokenReason, type LineageResolution, isLineageRef, isFaceRef, isEdgeRef, isVertexRef, isDerivedFaceRef, resolveLineageRef, resolveRefIn, resolveRefParams, } from './topology/shapeRef/index.js';

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-ChMnsOAF.js";
-export { assignRoles, captureHint, createRef, defaultScorer, resolveRef, updateRoles };
+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/index.d.ts

@@ -7,3 +7,4 @@ export { captureHint, assignRoles, createRef, updateRoles, resolveRef } from './
 export { createEdgeRef, resolveEdgeRef } from './edgeRefFns.js';
 export { createVertexRef, resolveVertexRef } from './vertexRefFns.js';
 export { createDerivedFaceRef, resolveDerivedFaceRef } from './derivedFaceRefFns.js';
+export { type LineageRef, type ResolvedEntity, type BrokenReason, type LineageResolution, isLineageRef, isFaceRef, isEdgeRef, isVertexRef, isDerivedFaceRef, resolveLineageRef, resolveRefIn, resolveRefParams, } from './refResolveFns.js';

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

@@ -0,0 +1,53 @@
+import { Edge, Face, Shape3D, Vertex } from '../../core/shapeTypes.js';
+import { ShapeRef, EdgeRef, VertexRef, DerivedFaceRef, RoleTable } from './shapeRefTypes.js';
+/** Any of the four lineage reference kinds. */
+export type LineageRef = ShapeRef | EdgeRef | VertexRef | DerivedFaceRef;
+/** The live entity a lineage ref resolves to. */
+export type ResolvedEntity = Face | Edge | Vertex;
+/** Why a lineage ref failed to resolve (preserved from the underlying resolver). */
+export type BrokenReason = 'ambiguous' | 'not-found' | 'deleted';
+/**
+ * Outcome of resolving a lineage ref. Carries the failure `reason` (and any tied
+ * `candidates`) rather than collapsing to undefined, so a replay engine can tell
+ * "deleted by the edit" (expected — skip) from "ambiguous" (warn the author).
+ */
+export type LineageResolution = {
+    readonly ok: true;
+    readonly entity: ResolvedEntity;
+} | {
+    readonly ok: false;
+    readonly reason: BrokenReason;
+    readonly candidates?: readonly ResolvedEntity[];
+};
+/** A generated-face ref: carries the bridged roles + the op that made it. */
+export declare function isDerivedFaceRef(v: unknown): v is DerivedFaceRef;
+/** An edge ref: exactly two adjacent face-roles. */
+export declare function isEdgeRef(v: unknown): v is EdgeRef;
+/** A vertex ref: three or more adjacent face-roles. */
+export declare function isVertexRef(v: unknown): v is VertexRef;
+/** A face ref: a single role name. */
+export declare function isFaceRef(v: unknown): v is ShapeRef;
+/** True for any of the four lineage reference kinds. */
+export declare function isLineageRef(v: unknown): v is LineageRef;
+/**
+ * Resolve a lineage ref against `shape` using a prepared role table (the robust
+ * path — the table is maintained across edits via `updateRoles`). Returns the
+ * live entity on success, or the failure reason (and tied candidates) on failure.
+ */
+export declare function resolveLineageRef(ref: LineageRef, roles: RoleTable, shape: Shape3D): LineageResolution;
+/**
+ * Resolve a lineage ref against a freshly rebuilt `shape` with no maintained
+ * role table, re-deriving roles via `assignRoles(shape, ref.origin)`. The ref's
+ * `origin` must therefore be the role-assignment scheme (e.g. `'box'`), and
+ * stability is bounded by that scheme — `'box'` names faces semantically
+ * (rebuild-stable); other schemes fall back to positional `face_N`.
+ */
+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.
+ */
+export declare function resolveRefParams(params: Readonly<Record<string, unknown>>, shape: Shape3D): Record<string, unknown>;

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/dist/topology.cjs

@@ -5,10 +5,11 @@ const require_shapeFns = require("./shapeFns-ybo0INGL.cjs");
 const require_curveFns = require("./curveFns-DgUJpH4z.cjs");
 const require_meshFns = require("./meshFns-1hQSn1p2.cjs");
 const require_solidBuilders = require("./solidBuilders-DiUv_mD0.cjs");
-const require_healingFns = require("./healingFns-x1sHV-HO.cjs");
+const require_healingFns = require("./healingFns-xLJ6Cp_O.cjs");
+const require_adjacencyFns = require("./adjacencyFns-d8ZabkvX.cjs");
 const require_primitiveFns = require("./primitiveFns-DLIWtQWA.cjs");
 exports.addHoles = require_primitiveFns.addHoles;
-exports.adjacentFaces = require_healingFns.adjacentFaces;
+exports.adjacentFaces = require_adjacencyFns.adjacentFaces;
 exports.approximateCurve = require_curveFns.approximateCurve;
 exports.asTopo = require_faceFns.asTopo;
 exports.autoHeal = require_healingFns.autoHeal;
@@ -40,7 +41,7 @@ exports.cutWithEvolution = require_healingFns.cutWithEvolution;
 exports.cylinder = require_primitiveFns.cylinder;
 exports.deserializeShape = require_faceFns.fromBREP;
 exports.downcast = require_faceFns.downcast;
-exports.edgesOfFace = require_healingFns.edgesOfFace;
+exports.edgesOfFace = require_adjacencyFns.edgesOfFace;
 exports.ellipse = require_primitiveFns.ellipse;
 exports.ellipseArc = require_primitiveFns.ellipseArc;
 exports.ellipsoid = require_primitiveFns.ellipsoid;
@@ -52,7 +53,7 @@ exports.faceAxis = require_faceFns.faceAxis;
 exports.faceCenter = require_faceFns.faceCenter;
 exports.faceGeomType = require_faceFns.faceGeomType;
 exports.faceOrientation = require_faceFns.faceOrientation;
-exports.facesOfEdge = require_healingFns.facesOfEdge;
+exports.facesOfEdge = require_adjacencyFns.facesOfEdge;
 exports.filledFace = require_primitiveFns.filledFace;
 exports.filletWithEvolution = require_healingFns.filletWithEvolution;
 exports.fixSelfIntersection = require_healingFns.fixSelfIntersection;
@@ -100,7 +101,7 @@ exports.positionOnCurve = require_healingFns.positionOnCurve;
 exports.projectPointOnFace = require_faceFns.projectPointOnFace;
 exports.sewShells = require_primitiveFns.sewShells;
 exports.shapeType = require_faceFns.shapeType;
-exports.sharedEdges = require_healingFns.sharedEdges;
+exports.sharedEdges = require_adjacencyFns.sharedEdges;
 exports.shellWithEvolution = require_healingFns.shellWithEvolution;
 exports.solid = require_primitiveFns.solid;
 exports.solidFromShell = require_healingFns.solidFromShell;
@@ -117,7 +118,7 @@ exports.uvCoordinates = require_faceFns.uvCoordinates;
 exports.variableFillet = require_healingFns.variableFillet;
 exports.vertex = require_primitiveFns.vertex;
 exports.vertexPosition = require_topologyQueryFns.vertexPosition;
-exports.verticesOfEdge = require_healingFns.verticesOfEdge;
+exports.verticesOfEdge = require_adjacencyFns.verticesOfEdge;
 exports.wire = require_primitiveFns.wire;
 exports.wireLoop = require_primitiveFns.wireLoop;
-exports.wiresOfFace = require_healingFns.wiresOfFace;
+exports.wiresOfFace = require_adjacencyFns.wiresOfFace;

package/dist/topology.js

@@ -4,6 +4,7 @@ import { a as isSameShape, i as isEqualShape, n as getHashCode } from "./shapeFn
 import { a as curveIsPeriodic, c as curvePointAt, d as flipOrientation, f as getCurveType, h as offsetWire2D, i as curveIsClosed, l as curveStartPoint, m as interpolateCurve, n as curveAxis, o as curveLength, p as getOrientation, r as curveEndPoint, s as curvePeriod, t as approximateCurve, u as curveTangentAt } from "./curveFns-CcSn4-Rf.js";
 import { d as createMeshCache, n as exportSTEP, r as exportSTL, t as exportIGES, u as clearMeshCache } from "./meshFns-DbmidUzH.js";
 import { h as fuseAll, p as cutAll } from "./solidBuilders-C32wXQWG.js";
-import { A as edgesOfFace, C as shellWithEvolution, D as getNurbsCurveData, E as fuseAllBisect, H as toLineGeometryData, I as wiresOfFace, L as chamferDistAngle, N as sharedEdges, O as getNurbsSurfaceData, P as verticesOfEdge, R as toBufferGeometryData, S as intersectWithEvolution, T as cutAllBisect, _ as positionOnCurve, a as healFace, b as filletWithEvolution, g as variableFillet, j as facesOfEdge, k as adjacentFaces, l as solidFromShell, n as fixSelfIntersection, o as healSolid, r as fixShape, s as healWire, t as autoHeal, v as chamferWithEvolution, w as checkBoolean, x as fuseWithEvolution, y as cutWithEvolution, z as toGroupedBufferGeometryData } from "./healingFns-D00TPE9p.js";
+import { A as toBufferGeometryData, C as shellWithEvolution, D as getNurbsCurveData, E as fuseAllBisect, O as getNurbsSurfaceData, P as toLineGeometryData, S as intersectWithEvolution, T as cutAllBisect, _ as positionOnCurve, a as healFace, b as filletWithEvolution, g as variableFillet, j as toGroupedBufferGeometryData, k as chamferDistAngle, l as solidFromShell, n as fixSelfIntersection, o as healSolid, r as fixShape, s as healWire, t as autoHeal, v as chamferWithEvolution, w as checkBoolean, x as fuseWithEvolution, y as cutWithEvolution } from "./healingFns-2TJHHDg5.js";
+import { a as sharedEdges, c as wiresOfFace, n as edgesOfFace, o as verticesOfEdge, r as facesOfEdge, t as adjacentFaces } from "./adjacencyFns-BYnyXXqt.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, 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, x as subFace, y as solid } from "./primitiveFns-CBrOyk5S.js";
 export { addHoles, adjacentFaces, approximateCurve, asTopo, autoHeal, bezier, box, bsplineApprox, cast, chamferDistAngle as chamferDistAngleShape, chamferWithEvolution, checkBoolean, circle, classifyPointOnFace, clearMeshCache, compound, cone, createMeshCache, curveAxis, curveEndPoint, curveIsClosed, curveIsPeriodic, curveLength, curvePeriod, curvePointAt, curveStartPoint, curveTangentAt, cutAll, cutAllBisect, cutWithEvolution, cylinder, fromBREP as deserializeShape, downcast, edgesOfFace, ellipse, ellipseArc, ellipsoid, exportIGES, exportSTEP, exportSTL, face, faceAxis, faceCenter, faceGeomType, faceOrientation, facesOfEdge, filledFace, filletWithEvolution, fixSelfIntersection, fixShape, flipFaceOrientation, flipOrientation, fuseAll, fuseAllBisect, fuseWithEvolution, getBounds, getCurveType, getEdges, getFaces, getHashCode, getNurbsCurveData, getNurbsSurfaceData, getOrientation, getSurfaceType, getVertices, getWires, healFace, healSolid, healWire, helix, innerWires, interpolateCurve, intersectWithEvolution, invalidateShapeCache, isCompSolid, isEqualShape, isSameShape, iterEdges, iterFaces, iterTopo, iterVertices, iterWires, line, normalAt, offsetFace, offsetWire2D, outerWire, pointOnSurface, polygon, positionOnCurve, projectPointOnFace, sewShells, shapeType, sharedEdges, shellWithEvolution, solid, solidFromShell, sphere, subFace, tangentArc, threePointArc, toBufferGeometryData, toGroupedBufferGeometryData, toLineGeometryData, torus, uvBounds, uvCoordinates, variableFillet, vertex, vertexPosition, verticesOfEdge, wire, wireLoop, wiresOfFace };

package/package.json

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

package/dist/shapeRefFns-ChMnsOAF.js

@@ -1,248 +0,0 @@
-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,
-* and area similarity.
-*
-* Scoring breakdown:
-* - Surface type match: +1.0 (mismatch when both defined: -Infinity)
-* - Normal dot product: weighted contribution (rejected if < 0.707)
-* - Centroid distance: quadratic penalty (rejected if distSq > 100)
-* - Area ratio: penalized if |log(hintArea / faceArea)| > 1.0
-*/
-function defaultScorer(hint, face) {
-	let score = 0;
-	const faceType = faceGeomType(face);
-	if (hint.surfaceType !== void 0) if (faceType === hint.surfaceType) score += 1;
-	else return -Infinity;
-	if (hint.normal !== void 0) {
-		const faceNormal = normalAt(face);
-		const dot = hint.normal[0] * faceNormal[0] + hint.normal[1] * faceNormal[1] + hint.normal[2] * faceNormal[2];
-		if (dot < .707) return -Infinity;
-		score += dot;
-	}
-	if (hint.centroid !== void 0) {
-		const faceCentroid = faceCenter(face);
-		const dx = hint.centroid[0] - faceCentroid[0];
-		const dy = hint.centroid[1] - faceCentroid[1];
-		const dz = hint.centroid[2] - faceCentroid[2];
-		const distSq = dx * dx + dy * dy + dz * dz;
-		if (distSq > 100) return -Infinity;
-		score -= distSq / 100;
-	}
-	if (hint.area !== void 0 && hint.area > 0) {
-		const areaResult = measureArea(face);
-		if (areaResult.ok && areaResult.value > 0) {
-			const logRatio = Math.abs(Math.log(hint.area / areaResult.value));
-			if (logRatio > 1) score -= logRatio;
-		}
-	}
-	return score;
-}
-//#endregion
-//#region src/topology/shapeRef/shapeRefFns.ts
-/** Snapshot the geometric properties of a face for later matching. */
-function captureHint(face) {
-	const surfaceType = faceGeomType(face);
-	const normal = normalAt(face);
-	const centroid = faceCenter(face);
-	const areaResult = measureArea(face);
-	return {
-		entityType: "face",
-		surfaceType,
-		normal,
-		centroid,
-		area: areaResult.ok ? areaResult.value : void 0
-	};
-}
-/** Threshold for dominant-axis detection (abs(component) > 0.9). */
-var AXIS_THRESHOLD = .9;
-/** Determine the cardinal role name for a box face from its outward normal. */
-function boxRoleFromNormal(n) {
-	if (n[2] > AXIS_THRESHOLD) return "box:top";
-	if (n[2] < -.9) return "box:bottom";
-	if (n[1] > AXIS_THRESHOLD) return "box:back";
-	if (n[1] < -.9) return "box:front";
-	if (n[0] > AXIS_THRESHOLD) return "box:right";
-	if (n[0] < -.9) return "box:left";
-}
-/**
-* Auto-assign role names to the faces of a shape based on 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.
-*
-* For other types: sequential naming ('opType:face_0', 'opType:face_1', ...).
-*
-* @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;
-	}
-	let index = 0;
-	for (const face of faces) {
-		roles.set(`${operationType}:face_${index}`, [getHashCode(face)]);
-		index++;
-	}
-	return roles;
-}
-/** Create a ShapeRef from an origin ID, role name, and face. */
-function createRef(origin, role, face) {
-	return {
-		origin,
-		role,
-		hint: captureHint(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: 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.
-*
-* 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, 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) newRoles.set(key, key === origin ? updatedOriginRoles : value);
-	return newRoles;
-}
-/** Ambiguity threshold: if two scores are within this range, it's ambiguous. */
-var AMBIGUITY_THRESHOLD = .1;
-/** Minimum score for geometric fallback to accept a match. */
-var MIN_SCORE = .5;
-/**
-* 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 scoreFaces(hint, candidates, scoreFn) {
-	let bestScore = -Infinity;
-	let bestFace;
-	let secondBestScore = -Infinity;
-	const scored = [];
-	for (const face of candidates) {
-		const score = scoreFn(hint, face);
-		if (score > MIN_SCORE) scored.push([face, score]);
-		if (score > bestScore) {
-			secondBestScore = bestScore;
-			bestScore = score;
-			bestFace = face;
-		} else if (score > secondBestScore) secondBestScore = score;
-	}
-	if (bestFace !== void 0 && bestScore > MIN_SCORE) {
-		if (bestScore - secondBestScore < AMBIGUITY_THRESHOLD && scored.length > 1) return {
-			kind: "ambiguous",
-			candidates: scored.filter(([, s]) => s >= bestScore - AMBIGUITY_THRESHOLD).map(([f]) => f)
-		};
-		return {
-			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"
-	};
-}
-//#endregion
-export { updateRoles as a, resolveRef as i, captureHint as n, defaultScorer as o, createRef as r, assignRoles as t };