brepjs 18.112.0 → 18.114.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-BK5NSDFd.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-CayDQeug.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/derivedFaceRefFns.d.ts

@@ -0,0 +1,16 @@
+import { Edge, Shape3D } from '../../core/shapeTypes.js';
+import { DerivedFaceRef, ResolvedDerivedFaceRef, BrokenDerivedFaceRef, RoleTable } from './shapeRefTypes.js';
+/**
+ * Capture a reference to the face an `op` (fillet/chamfer) will generate across
+ * `edge`: the roles of the edge's two faces, their outward normals, and the edge
+ * midpoint. Call this on the PRE-op shape. Returns undefined when the edge
+ * doesn't bound two named faces.
+ */
+export declare function createDerivedFaceRef(origin: string, op: 'fillet' | 'chamfer', edge: Edge, preShape: Shape3D, roles: RoleTable): DerivedFaceRef | undefined;
+/**
+ * Resolve a DerivedFaceRef in the post-op `shape`: re-derive the two bridged
+ * faces (role table, else by captured normal), then return the face adjacent to
+ * both whose normal blends both. One survivor → resolved; several →
+ * nearest-to-edge-midpoint; none → broken.
+ */
+export declare function resolveDerivedFaceRef(ref: DerivedFaceRef, roles: RoleTable, shape: Shape3D): ResolvedDerivedFaceRef | BrokenDerivedFaceRef;

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

@@ -1,8 +1,10 @@
 /**
  * ShapeRef — stable, serializable face references for parametric replay.
  */
-export type { GeometricHint, ShapeRef, RoleTable, ResolvedRef, BrokenRef, EdgeHint, EdgeRef, ResolvedEdgeRef, BrokenEdgeRef, VertexHint, VertexRef, ResolvedVertexRef, BrokenVertexRef, } from './shapeRefTypes.js';
+export type { GeometricHint, ShapeRef, RoleTable, ResolvedRef, BrokenRef, EdgeHint, EdgeRef, ResolvedEdgeRef, BrokenEdgeRef, VertexHint, VertexRef, ResolvedVertexRef, BrokenVertexRef, DerivedFaceHint, DerivedFaceRef, ResolvedDerivedFaceRef, BrokenDerivedFaceRef, } from './shapeRefTypes.js';
 export { type FaceScorer, defaultScorer } from './scoring.js';
 export { captureHint, assignRoles, createRef, updateRoles, resolveRef } from './shapeRefFns.js';
 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/roleLookup.d.ts

@@ -1,8 +1,10 @@
-import { Face, Shape3D } from '../../core/shapeTypes.js';
+import { Face, Shape3D, Vertex } from '../../core/shapeTypes.js';
 import { Vec3 } from '../../core/types.js';
 import { RoleTable } from './shapeRefTypes.js';
 /** Euclidean distance between two points. */
 export declare function distance(a: Vec3, b: Vec3): number;
+/** Mean of a set of vertices' positions (e.g. an edge's endpoints). */
+export declare function vertexCentroid(verts: readonly Vertex[]): Vec3 | undefined;
 /** The role whose tracked hashes include this face (reverse lookup). */
 export declare function roleOfFace(face: Face, origin: string, roles: RoleTable): string | undefined;
 /** Current faces a role resolves to — its tracked successors present in `shape`. */

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

@@ -104,3 +104,45 @@ export interface BrokenVertexRef {
     readonly reason: 'ambiguous' | 'not-found';
     readonly candidates?: readonly Vertex[];
 }
+/**
+ * Snapshot for re-deriving a generated face. fillet/chamfer evolution is empty
+ * on the OCCT kernels, so the role table can't track the bridged faces — they
+ * are re-found by their captured outward normals; the edge midpoint breaks ties.
+ */
+export interface DerivedFaceHint {
+    readonly entityType: 'derived-face';
+    readonly normalA: Vec3;
+    readonly normalB: Vec3;
+    readonly edgeMidpoint?: Vec3 | undefined;
+}
+/**
+ * A reference to a *generated* face — a fillet round or chamfer bevel — named by
+ * the two faces it bridges. The generated face has no stable hash (it didn't
+ * exist at capture time, and fillet evolution is empty), so it's resolved as the
+ * face adjacent to both bridged faces whose normal blends both — the orthogonal
+ * flanking faces are rejected. Lineage-by-neighbors for geometry created by the
+ * very edit being referenced across.
+ */
+export interface DerivedFaceRef {
+    readonly origin: string;
+    /**
+     * Which op generated the face — descriptive metadata for consumers. Resolution
+     * is op-agnostic (the normal-blend isolates both a fillet round and a chamfer
+     * bevel), so the resolver doesn't consult it.
+     */
+    readonly op: 'fillet' | 'chamfer';
+    /** Roles of the two faces the generated face bridges. */
+    readonly betweenRoles: readonly [string, string];
+    readonly hint: DerivedFaceHint;
+}
+/** A successfully resolved derived-face reference (always geometric). */
+export interface ResolvedDerivedFaceRef {
+    readonly face: Face;
+    readonly confidence: 'geometric-fallback';
+}
+/** A derived-face reference that could not be resolved. */
+export interface BrokenDerivedFaceRef {
+    readonly ref: DerivedFaceRef;
+    readonly reason: 'ambiguous' | 'not-found';
+    readonly candidates?: readonly Face[];
+}

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.112.0",
+  "version": "18.114.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 };