fluidcad 0.0.35 → 0.0.37

package/lib/dist/oc/measure/measure-ops.js

@@ -0,0 +1,210 @@
+import { getOC } from "../init.js";
+import { classifyEdge, classifyFace } from "./classify.js";
+import { maxDistanceBetween, sampleEntityPoints } from "./sampling.js";
+import { acuteAngleDeg, add, areParallel, dist, dot, projectPointOnLine, scale, sub } from "./vec.js";
+// sin(angle) tolerance for treating two directions as exactly parallel; loose
+// enough to absorb numeric noise from booleans/imports, far below any
+// deliberately modeled angle.
+const PARALLEL_SIN_TOL = 1e-6;
+const PERP_ANGLE_TOL_DEG = 1e-3;
+const PRIMARY_LABELS = {
+    parallelDist: 'Parallel dist',
+    centerDist: 'Center dist',
+    axisDist: 'Axis dist',
+    minDist: 'Min dist',
+    totalArea: 'Area',
+    totalLength: 'Length',
+};
+function mkDist(from, to) {
+    return { value: dist(from, to), from, to };
+}
+function entityInfo(entity, ref) {
+    const info = { ref, geomType: entity.form };
+    if (entity.kind === 'face') {
+        info.area = entity.area;
+    }
+    else {
+        info.length = entity.length;
+    }
+    if (entity.radius !== undefined) {
+        info.radius = entity.radius;
+    }
+    return info;
+}
+/** Closest-pair distance between the two B-rep entities via BRepExtrema. */
+function minDistanceBetween(a, b) {
+    const oc = getOC();
+    const progress = new oc.Message_ProgressRange();
+    const calc = new oc.BRepExtrema_DistShapeShape(a.shape, b.shape, oc.Extrema_ExtFlag.Extrema_ExtFlag_MIN, oc.Extrema_ExtAlgo.Extrema_ExtAlgo_Grad, progress);
+    let result;
+    if (calc.IsDone() && calc.NbSolution() > 0) {
+        const p1 = calc.PointOnShape1(1);
+        const p2 = calc.PointOnShape2(1);
+        result = {
+            value: calc.Value(),
+            from: { x: p1.X(), y: p1.Y(), z: p1.Z() },
+            to: { x: p2.X(), y: p2.Y(), z: p2.Z() },
+        };
+        p1.delete();
+        p2.delete();
+    }
+    calc.delete();
+    progress.delete();
+    return result;
+}
+/** A point on the entity's carrier line: the anchor itself for edges, the anchor projected onto the axis for cylinders/cones. */
+function axisAnchor(entity) {
+    if (entity.form === 'line') {
+        return entity.anchor;
+    }
+    return projectPointOnLine(entity.anchor, entity.point, entity.dir);
+}
+/** Perpendicular distance from a parallel pair: plane↔plane, plane↔axis, axis↔axis. */
+function parallelDistanceBetween(a, b) {
+    const aPlane = a.form === 'plane';
+    const bPlane = b.form === 'plane';
+    const aAxis = a.dirKind === 'axis';
+    const bAxis = b.dirKind === 'axis';
+    if (aPlane && bPlane) {
+        if (!areParallel(a.dir, b.dir, PARALLEL_SIN_TOL)) {
+            return undefined;
+        }
+        const signed = dot(sub(b.anchor, a.anchor), a.dir);
+        return { value: Math.abs(signed), from: a.anchor, to: add(a.anchor, scale(a.dir, signed)) };
+    }
+    if ((aPlane && bAxis) || (aAxis && bPlane)) {
+        const [plane, axis] = aPlane ? [a, b] : [b, a];
+        if (Math.abs(dot(plane.dir, axis.dir)) >= PARALLEL_SIN_TOL) {
+            return undefined;
+        }
+        const onAxis = axisAnchor(axis);
+        const signed = dot(sub(onAxis, plane.anchor), plane.dir);
+        const onPlane = sub(onAxis, scale(plane.dir, signed));
+        return aPlane ? mkDist(onPlane, onAxis) : mkDist(onAxis, onPlane);
+    }
+    if (a.form === 'line' && b.form === 'line') {
+        if (!areParallel(a.dir, b.dir, PARALLEL_SIN_TOL)) {
+            return undefined;
+        }
+        return mkDist(a.anchor, projectPointOnLine(a.anchor, b.point, b.dir));
+    }
+    return undefined;
+}
+/** Distance between the carrier axes of two parallel axis-bearing entities (cylinder/cone/line), at least one a surface. */
+function axisDistanceBetween(a, b) {
+    if (a.dirKind !== 'axis' || b.dirKind !== 'axis') {
+        return undefined;
+    }
+    if (a.form === 'line' && b.form === 'line') {
+        return undefined;
+    }
+    if (!areParallel(a.dir, b.dir, PARALLEL_SIN_TOL)) {
+        return undefined;
+    }
+    const from = axisAnchor(a);
+    return mkDist(from, projectPointOnLine(from, b.point, b.dir));
+}
+/**
+ * Angle between two entities, normalized to [0, 90]°. Normal-vs-normal and
+ * axis-vs-axis compare directly; normal-vs-axis measures the axis against the
+ * plane (0° when the axis lies in the plane).
+ */
+function angleBetween(a, b) {
+    if (!a.dir || !b.dir || !a.dirKind || !b.dirKind) {
+        return undefined;
+    }
+    if (a.dirKind === b.dirKind) {
+        const deg = acuteAngleDeg(a.dir, b.dir);
+        if (a.form === 'plane' && b.form === 'plane') {
+            const label = Math.abs(deg - 90) < PERP_ANGLE_TOL_DEG ? 'Perp planes angle' : 'Planes angle';
+            return { deg, label };
+        }
+        if (a.form === 'line' && b.form === 'line') {
+            return { deg, label: 'Lines angle' };
+        }
+        return { deg, label: a.dirKind === 'axis' ? 'Axes angle' : 'Angle' };
+    }
+    const [normal, axis] = a.dirKind === 'normal' ? [a, b] : [b, a];
+    const deg = 90 - acuteAngleDeg(normal.dir, axis.dir);
+    if (normal.form === 'plane') {
+        return { deg, label: axis.form === 'line' ? 'Line-plane angle' : 'Axis-plane angle' };
+    }
+    return { deg, label: 'Angle' };
+}
+function isParallelPair(a, b) {
+    if (!a.dir || !b.dir || !a.dirKind || !b.dirKind) {
+        return false;
+    }
+    if (a.dirKind === b.dirKind) {
+        return areParallel(a.dir, b.dir, PARALLEL_SIN_TOL);
+    }
+    return Math.abs(dot(a.dir, b.dir)) < PARALLEL_SIN_TOL;
+}
+function pickPrimary(a, b, result) {
+    const parallel = isParallelPair(a, b);
+    const planeLike = (e) => e.form === 'plane' || e.form === 'line';
+    if (planeLike(a) && planeLike(b)) {
+        return parallel && result.parallelDist ? 'parallelDist' : 'angle';
+    }
+    if (result.centerDist) {
+        return 'centerDist';
+    }
+    if (result.axisDist) {
+        return 'axisDist';
+    }
+    return 'minDist';
+}
+export class MeasureOps {
+    static measure(inputs) {
+        const classified = inputs.map((input) => input.ref.kind === 'face' ? classifyFace(input.shape) : classifyEdge(input.shape));
+        const result = {
+            entities: classified.map((entity, i) => entityInfo(entity, inputs[i].ref)),
+            primary: 'minDist',
+            primaryLabel: PRIMARY_LABELS.minDist,
+        };
+        const faces = classified.filter((e) => e.kind === 'face');
+        const edges = classified.filter((e) => e.kind === 'edge');
+        if (faces.length > 0) {
+            result.totalArea = faces.reduce((sum, e) => sum + (e.area ?? 0), 0);
+        }
+        if (edges.length > 0) {
+            result.totalLength = edges.reduce((sum, e) => sum + (e.length ?? 0), 0);
+        }
+        if (classified.length === 2) {
+            const [a, b] = classified;
+            result.minDist = minDistanceBetween(a, b);
+            result.maxDist = maxDistanceBetween(sampleEntityPoints(a), sampleEntityPoints(b));
+            result.parallelDist = parallelDistanceBetween(a, b);
+            result.axisDist = axisDistanceBetween(a, b);
+            if (a.center && b.center) {
+                result.centerDist = mkDist(a.center, b.center);
+            }
+            if (!isParallelPair(a, b)) {
+                const angle = angleBetween(a, b);
+                if (angle) {
+                    result.angleDeg = angle.deg;
+                    result.angleLabel = angle.label;
+                }
+            }
+            let primary = pickPrimary(a, b, result);
+            if (primary === 'angle' && result.angleDeg === undefined) {
+                primary = 'minDist';
+            }
+            if (primary !== 'angle' && primary !== 'minDist' && !result[primary]) {
+                primary = 'minDist';
+            }
+            result.primary = primary;
+            result.primaryLabel = primary === 'angle' ? result.angleLabel : PRIMARY_LABELS[primary];
+            return result;
+        }
+        // Single entity or 3+ entities: aggregate values only.
+        if (result.totalArea !== undefined) {
+            result.primary = 'totalArea';
+        }
+        else if (result.totalLength !== undefined) {
+            result.primary = 'totalLength';
+        }
+        result.primaryLabel = PRIMARY_LABELS[result.primary];
+        return result;
+    }
+}

package/lib/dist/oc/measure/measure-types.d.ts

@@ -0,0 +1,39 @@
+export interface MeasureVec {
+    x: number;
+    y: number;
+    z: number;
+}
+/** A distance value together with the two world-space endpoints that realize it. */
+export interface MeasureDistanceValue {
+    value: number;
+    from: MeasureVec;
+    to: MeasureVec;
+}
+export type MeasureEntityKind = 'face' | 'edge';
+export interface MeasureEntityRef {
+    shapeId: string;
+    kind: MeasureEntityKind;
+    index: number;
+}
+export interface MeasureEntityInfo {
+    ref: MeasureEntityRef;
+    geomType: string;
+    area?: number;
+    length?: number;
+    radius?: number;
+}
+export type MeasurePrimaryKey = 'parallelDist' | 'centerDist' | 'axisDist' | 'minDist' | 'angle' | 'totalArea' | 'totalLength';
+export interface MeasureResult {
+    entities: MeasureEntityInfo[];
+    primary: MeasurePrimaryKey;
+    primaryLabel: string;
+    minDist?: MeasureDistanceValue;
+    maxDist?: MeasureDistanceValue;
+    parallelDist?: MeasureDistanceValue;
+    centerDist?: MeasureDistanceValue;
+    axisDist?: MeasureDistanceValue;
+    angleDeg?: number;
+    angleLabel?: string;
+    totalArea?: number;
+    totalLength?: number;
+}

package/lib/dist/oc/measure/measure-types.js

@@ -0,0 +1 @@
+export {};

package/lib/dist/oc/measure/sampling.d.ts

@@ -0,0 +1,9 @@
+import type { MeasureDistanceValue, MeasureVec } from "./measure-types.js";
+import type { ClassifiedEntity } from "./classify.js";
+export declare function sampleEntityPoints(entity: ClassifiedEntity): MeasureVec[];
+/**
+ * Approximate maximum distance between two entities as the farthest pair of
+ * sampled points (triangulation nodes / curve samples), so accuracy is bounded
+ * by the mesh deflection.
+ */
+export declare function maxDistanceBetween(samplesA: MeasureVec[], samplesB: MeasureVec[]): MeasureDistanceValue;

package/lib/dist/oc/measure/sampling.js

@@ -0,0 +1,77 @@
+import { getOC } from "../init.js";
+import { Mesh } from "../mesh.js";
+const MAX_FACE_SAMPLES = 400;
+const EDGE_SAMPLES = 64;
+function sampleFacePoints(shape) {
+    const oc = getOC();
+    const face = oc.TopoDS.Face(shape);
+    Mesh.ensureTriangulated(face);
+    const location = new oc.TopLoc_Location();
+    const triangulation = oc.BRep_Tool.Triangulation(face, location, 0);
+    if (triangulation.isNull()) {
+        location.delete();
+        return [];
+    }
+    const transform = location.Transformation();
+    const nbNodes = triangulation.NbNodes();
+    const stride = Math.max(1, Math.ceil(nbNodes / MAX_FACE_SAMPLES));
+    const points = [];
+    for (let i = 1; i <= nbNodes; i += stride) {
+        const node = triangulation.Node(i);
+        const p = node.Transformed(transform);
+        points.push({ x: p.X(), y: p.Y(), z: p.Z() });
+        node.delete();
+        p.delete();
+    }
+    transform.delete();
+    triangulation.delete();
+    location.delete();
+    return points;
+}
+function sampleEdgePoints(shape) {
+    const oc = getOC();
+    const edge = oc.TopoDS.Edge(shape);
+    const adaptor = new oc.BRepAdaptor_Curve(edge);
+    const first = adaptor.FirstParameter();
+    const last = adaptor.LastParameter();
+    const points = [];
+    for (let i = 0; i <= EDGE_SAMPLES; i++) {
+        const u = first + ((last - first) * i) / EDGE_SAMPLES;
+        const p = adaptor.Value(u);
+        points.push({ x: p.X(), y: p.Y(), z: p.Z() });
+        p.delete();
+    }
+    adaptor.delete();
+    return points;
+}
+export function sampleEntityPoints(entity) {
+    const points = entity.kind === 'face' ? sampleFacePoints(entity.shape) : sampleEdgePoints(entity.shape);
+    if (points.length === 0) {
+        points.push(entity.anchor);
+    }
+    return points;
+}
+/**
+ * Approximate maximum distance between two entities as the farthest pair of
+ * sampled points (triangulation nodes / curve samples), so accuracy is bounded
+ * by the mesh deflection.
+ */
+export function maxDistanceBetween(samplesA, samplesB) {
+    let best = -1;
+    let from = samplesA[0];
+    let to = samplesB[0];
+    for (const a of samplesA) {
+        for (const b of samplesB) {
+            const dx = a.x - b.x;
+            const dy = a.y - b.y;
+            const dz = a.z - b.z;
+            const d2 = dx * dx + dy * dy + dz * dz;
+            if (d2 > best) {
+                best = d2;
+                from = a;
+                to = b;
+            }
+        }
+    }
+    return { value: Math.sqrt(best), from, to };
+}

package/lib/dist/oc/measure/vec.d.ts

@@ -0,0 +1,13 @@
+import type { MeasureVec } from "./measure-types.js";
+export declare const sub: (a: MeasureVec, b: MeasureVec) => MeasureVec;
+export declare const add: (a: MeasureVec, b: MeasureVec) => MeasureVec;
+export declare const scale: (a: MeasureVec, s: number) => MeasureVec;
+export declare const dot: (a: MeasureVec, b: MeasureVec) => number;
+export declare const cross: (a: MeasureVec, b: MeasureVec) => MeasureVec;
+export declare const len: (a: MeasureVec) => number;
+export declare const dist: (a: MeasureVec, b: MeasureVec) => number;
+export declare function projectPointOnLine(p: MeasureVec, linePoint: MeasureVec, lineDir: MeasureVec): MeasureVec;
+/** Acute angle between two unit directions, in degrees ([0, 90], orientation-insensitive). */
+export declare function acuteAngleDeg(a: MeasureVec, b: MeasureVec): number;
+/** True when two unit directions are parallel (or anti-parallel) within `sinTol`. */
+export declare function areParallel(a: MeasureVec, b: MeasureVec, sinTol: number): boolean;

package/lib/dist/oc/measure/vec.js

@@ -0,0 +1,23 @@
+export const sub = (a, b) => ({ x: a.x - b.x, y: a.y - b.y, z: a.z - b.z });
+export const add = (a, b) => ({ x: a.x + b.x, y: a.y + b.y, z: a.z + b.z });
+export const scale = (a, s) => ({ x: a.x * s, y: a.y * s, z: a.z * s });
+export const dot = (a, b) => a.x * b.x + a.y * b.y + a.z * b.z;
+export const cross = (a, b) => ({
+    x: a.y * b.z - a.z * b.y,
+    y: a.z * b.x - a.x * b.z,
+    z: a.x * b.y - a.y * b.x,
+});
+export const len = (a) => Math.sqrt(dot(a, a));
+export const dist = (a, b) => len(sub(a, b));
+export function projectPointOnLine(p, linePoint, lineDir) {
+    return add(linePoint, scale(lineDir, dot(sub(p, linePoint), lineDir)));
+}
+/** Acute angle between two unit directions, in degrees ([0, 90], orientation-insensitive). */
+export function acuteAngleDeg(a, b) {
+    const c = Math.min(1, Math.abs(dot(a, b)));
+    return Math.acos(c) * (180 / Math.PI);
+}
+/** True when two unit directions are parallel (or anti-parallel) within `sinTol`. */
+export function areParallel(a, b, sinTol) {
+    return len(cross(a, b)) < sinTol;
+}

package/lib/dist/oc/mesh.d.ts

@@ -1,4 +1,4 @@
-import type { TopoDS_Edge, TopoDS_Face, TopoDS_Shape } from "occjs-wrapper";
+import type { TopoDS_Edge, TopoDS_Face, TopoDS_Shape } from "ocjs-fluidcad";
 import { Face } from "../common/face.js";
 import { Shape } from "../common/shape.js";
 export interface MeshData {

package/lib/dist/oc/mesh.js

@@ -48,13 +48,12 @@ export class Mesh {
         const normals = [];
         const indices = [];
         const aLocation = new oc.TopLoc_Location();
-        const faceTriangulation = oc.BRep_Tool.Triangulation(face, aLocation, 0);
-        if (faceTriangulation.IsNull()) {
+        const triangulation = oc.BRep_Tool.Triangulation(face, aLocation, 0);
+        if (triangulation.isNull()) {
             aLocation.delete();
             return null;
         }
-        const pc = new oc.Poly_Connect(faceTriangulation);
-        const triangulation = faceTriangulation.get();
+        const pc = new oc.Poly_Connect(triangulation);
         const nbNodes = triangulation.NbNodes();
         for (let i = 1; i <= nbNodes; i++) {
             const t1 = aLocation.Transformation();
@@ -65,34 +64,50 @@ export class Mesh {
             p1.delete();
             t1.delete();
         }
-        const faceNormals = new oc.TColgp_Array1OfDir(1, nbNodes);
-        oc.StdPrs_ToolTriangulatedShape.Normal(face, pc, faceNormals);
+        // OCCT 8.0: StdPrs_ToolTriangulatedShape (TKV3d) is gone; the surface-normals
+        // utility moved to BRepLib_ToolTriangulatedShape (TKTopAlgo). It computes nodal
+        // normals into the triangulation itself (no-op if it already has them), which we
+        // then read back via Poly_Triangulation.Normal(i).
+        oc.BRepLib_ToolTriangulatedShape.ComputeNormals(face, triangulation, pc);
+        // A triangulation stores normals in the natural orientation of the
+        // underlying surface, NOT the face's topological orientation. For a
+        // TopAbs_REVERSED face the outward normal is the opposite of the surface
+        // normal, so we must flip the nodal normals here. (Pre-OCCT-8 this was done
+        // internally by StdPrs_ToolTriangulatedShape::Normal; BRepLib_ToolTriangulatedShape
+        // ::ComputeNormals does not, which left reversed faces shaded as if lit from
+        // inside the solid — they rendered dark.) The triangle winding below is
+        // swapped under the same condition so winding and shading normals agree.
+        const orient = face.Orientation();
+        const reversed = orient !== oc.TopAbs_Orientation.TopAbs_FORWARD;
         for (let i = 1; i <= nbNodes; i++) {
             const t1 = aLocation.Transformation();
-            const d1 = faceNormals.Value(i);
+            const d1 = triangulation.Normal(i);
             const d = d1.Transformed(t1);
-            normals.push(d.X(), d.Y(), d.Z());
+            if (reversed) {
+                normals.push(-d.X(), -d.Y(), -d.Z());
+            }
+            else {
+                normals.push(d.X(), d.Y(), d.Z());
+            }
             d1.delete();
             d.delete();
             t1.delete();
         }
-        const orient = face.Orientation();
         const triangles = triangulation.Triangles();
         for (let nt = 1; nt <= triangulation.NbTriangles(); nt++) {
             const t = triangles.Value(nt);
             let n1 = t.Value(1) - 1;
             let n2 = t.Value(2) - 1;
             let n3 = t.Value(3) - 1;
-            if (orient !== oc.TopAbs_Orientation.TopAbs_FORWARD) {
+            if (reversed) {
                 [n1, n2] = [n2, n1];
             }
             indices.push(vertexOffset + n1, vertexOffset + n2, vertexOffset + n3);
             t.delete();
         }
         pc.delete();
-        faceNormals.delete();
         triangles.delete();
-        faceTriangulation.delete();
+        triangulation.delete();
         aLocation.delete();
         return { vertices, normals, indices, count: nbNodes };
     }
@@ -107,21 +122,19 @@ export class Mesh {
             return null;
         }
         const loc = new oc.TopLoc_Location();
-        const triHandle = oc.BRep_Tool.Triangulation(face, loc, 0);
-        if (triHandle.IsNull()) {
-            triHandle.delete();
+        const tri = oc.BRep_Tool.Triangulation(face, loc, 0);
+        if (tri.isNull()) {
+            tri.delete();
             loc.delete();
             return null;
         }
-        const polyHandle = oc.BRep_Tool.PolygonOnTriangulation(edge, triHandle, loc);
-        if (polyHandle.IsNull()) {
-            polyHandle.delete();
-            triHandle.delete();
+        const poly = oc.BRep_Tool.PolygonOnTriangulation(edge, tri, loc);
+        if (poly.isNull()) {
+            poly.delete();
+            tri.delete();
             loc.delete();
             return null;
         }
-        const tri = triHandle.get();
-        const poly = polyHandle.get();
         const nbNodes = poly.NbNodes();
         const tx = loc.Transformation();
         const vertices = new Array(nbNodes * 3);
@@ -142,8 +155,8 @@ export class Mesh {
             indices[i * 2 + 1] = i + 1;
         }
         tx.delete();
-        polyHandle.delete();
-        triHandle.delete();
+        poly.delete();
+        tri.delete();
         loc.delete();
         return { vertices, normals: [], indices };
     }
@@ -161,15 +174,14 @@ export class Mesh {
         }
         Mesh.ensureTriangulated(edge, opts);
         const loc = new oc.TopLoc_Location();
-        const polyHandle = oc.BRep_Tool.Polygon3D(ocEdge, loc);
-        if (polyHandle.IsNull()) {
-            polyHandle.delete();
+        const poly = oc.BRep_Tool.Polygon3D(ocEdge, loc);
+        if (poly.isNull()) {
+            poly.delete();
             loc.delete();
             ocEdge.delete();
             console.warn("Edge has no stored Polygon3D after meshing; returning empty polyline.");
             return { vertices: [], normals: [], indices: [] };
         }
-        const poly = polyHandle.get();
         const nbNodes = poly.NbNodes();
         const nodes = poly.Nodes();
         const tx = loc.Transformation();
@@ -190,7 +202,7 @@ export class Mesh {
             indices[i * 2 + 1] = i + 1;
         }
         tx.delete();
-        polyHandle.delete();
+        poly.delete();
         loc.delete();
         ocEdge.delete();
         return { vertices, normals: [], indices };

package/lib/dist/oc/path-sampler.d.ts

@@ -0,0 +1,29 @@
+import { Wire } from "../common/wire.js";
+import { Point } from "../math/point.js";
+import { Vector3d } from "../math/vector3d.js";
+export interface PathFrame {
+    point: Point;
+    /** Unit tangent in the direction of increasing arc length. */
+    tangent: Vector3d;
+}
+/**
+ * Arc-length parameterization of a wire. Wraps `BRepAdaptor_CompCurve` +
+ * `GCPnts_AbscissaPoint` so callers can evaluate a point and unit tangent at a
+ * distance measured along the path, independent of how the underlying curves
+ * are parameterized (exact on Béziers/B-splines, not just lines and arcs).
+ *
+ * Out-of-range distances wrap around on a closed wire and extrapolate
+ * linearly along the end tangents on an open one.
+ */
+export declare class PathSampler {
+    private adaptor;
+    private firstParam;
+    readonly length: number;
+    readonly closed: boolean;
+    constructor(wire: Wire);
+    evalAt(s: number): PathFrame;
+    /** `count + 1` points evenly spaced by arc length, including both ends. */
+    sample(count: number): Point[];
+    private evalOn;
+    dispose(): void;
+}

package/lib/dist/oc/path-sampler.js

@@ -0,0 +1,63 @@
+import { getOC } from "./init.js";
+import { Convert } from "./convert.js";
+/**
+ * Arc-length parameterization of a wire. Wraps `BRepAdaptor_CompCurve` +
+ * `GCPnts_AbscissaPoint` so callers can evaluate a point and unit tangent at a
+ * distance measured along the path, independent of how the underlying curves
+ * are parameterized (exact on Béziers/B-splines, not just lines and arcs).
+ *
+ * Out-of-range distances wrap around on a closed wire and extrapolate
+ * linearly along the end tangents on an open one.
+ */
+export class PathSampler {
+    adaptor;
+    firstParam;
+    length;
+    closed;
+    constructor(wire) {
+        const oc = getOC();
+        this.adaptor = new oc.BRepAdaptor_CompCurve(wire.getShape(), false);
+        this.firstParam = this.adaptor.FirstParameter();
+        this.length = oc.GCPnts_AbscissaPoint.Length(this.adaptor);
+        this.closed = this.adaptor.IsClosed();
+    }
+    evalAt(s) {
+        if (this.closed) {
+            s = ((s % this.length) + this.length) % this.length;
+        }
+        else if (s < 0) {
+            const start = this.evalOn(0);
+            return { point: start.point.add(start.tangent.multiply(s)), tangent: start.tangent };
+        }
+        else if (s > this.length) {
+            const end = this.evalOn(this.length);
+            return { point: end.point.add(end.tangent.multiply(s - this.length)), tangent: end.tangent };
+        }
+        return this.evalOn(s);
+    }
+    /** `count + 1` points evenly spaced by arc length, including both ends. */
+    sample(count) {
+        const points = [];
+        for (let i = 0; i <= count; i++) {
+            points.push(this.evalOn((this.length * i) / count).point);
+        }
+        return points;
+    }
+    evalOn(s) {
+        const oc = getOC();
+        const abscissa = new oc.GCPnts_AbscissaPoint(this.adaptor, s, this.firstParam);
+        if (!abscissa.IsDone()) {
+            abscissa.delete();
+            throw new Error(`Failed to locate arc-length ${s} on path (length ${this.length}).`);
+        }
+        const u = abscissa.Parameter();
+        abscissa.delete();
+        const res = this.adaptor.EvalD1(u);
+        const point = Convert.toPoint(res.Point, true);
+        const tangent = Convert.toVector3d(res.D1, true).normalize();
+        return { point, tangent };
+    }
+    dispose() {
+        this.adaptor.delete();
+    }
+}

package/lib/dist/oc/props.d.ts

@@ -1,4 +1,4 @@
-import type { TopoDS_Shape } from "occjs-wrapper";
+import type { TopoDS_Shape } from "ocjs-fluidcad";
 export interface ShapeProperties {
     volumeMm3: number;
     surfaceAreaMm2: number;

package/lib/dist/oc/props.js

@@ -3,7 +3,10 @@ export class ShapeProps {
     static getProperties(shape) {
         const oc = getOC();
         const volumeProps = new oc.GProp_GProps();
-        oc.BRepGProp.VolumeProperties(shape, volumeProps, false, false, false);
+        // Eps-driven adaptive integration: the default fixed-order quadrature
+        // under-integrates faces trimmed by fitted B-spline pcurves (seen with
+        // wrap() pads — ~7% volume error) while this overload stays exact.
+        oc.BRepGProp.VolumeProperties(shape, volumeProps, 1e-6, false, false);
         const volumeMm3 = volumeProps.Mass();
         const cog = volumeProps.CentreOfMass();
         const centroid = { x: cog.X(), y: cog.Y(), z: cog.Z() };

package/lib/dist/oc/shape-hash.d.ts

@@ -0,0 +1,26 @@
+import type { TopoDS_Shape } from "ocjs-fluidcad";
+/**
+ * Produces stable, `IsSame`-consistent integer keys for TopoDS shapes so they can
+ * be used as JS `Map`/`Set` keys.
+ *
+ * OCCT 8.0 removed `TopoDS_Shape::HashCode`. This interns shapes in a
+ * `TopTools_IndexedMapOfShape` — whose hasher compares keys with `IsSame` — and
+ * returns each shape's stable 1-based index. That gives the same bucketing the old
+ * `HashCode` + `IsSame` check provided, but collision-free (the same `IsSame`
+ * sub-shape always maps to the same key, distinct sub-shapes never collide).
+ *
+ * Wraps an OCCT map, so it owns native memory: scope one per operation and
+ * `delete()` it when done. Follows the same indexed-map convention as
+ * {@link TopologyIndex}.
+ */
+export declare class ShapeHasher {
+    private readonly map;
+    constructor();
+    /**
+     * Stable, `IsSame`-consistent key for `shape`. Interns the shape on first use; an
+     * as-yet-unseen shape gets a fresh key, so a `Map` lookup against keys from other
+     * shapes correctly misses.
+     */
+    key(shape: TopoDS_Shape): number;
+    delete(): void;
+}