brepjs 20.12.14 → 20.13.0

package/dist/kernel/interfaces/modifierOps.d.ts

@@ -1,20 +1,29 @@
 import { KernelShape } from '../types.js';
+/** One edge of a distance-angle chamfer that gives each edge its own values. */
+export interface ChamferDistAngleEdge {
+    readonly edge: KernelShape;
+    /** Setback on the reference face. */
+    readonly distance: number;
+    /** Angle from the reference face, in degrees. */
+    readonly angleDeg: number;
+    /**
+     * The reference face, one of the two faces the edge joins. Omitted, the
+     * kernel picks it as {@link KernelModifierOps.chamferDistAngle} does.
+     */
+    readonly face?: KernelShape | undefined;
+}
 export interface KernelModifierOps {
     fillet(shape: KernelShape, edges: KernelShape[], radius: number | [number, number] | ((edge: KernelShape) => number | [number, number])): KernelShape;
     chamfer(shape: KernelShape, edges: KernelShape[], distance: number | [number, number] | ((edge: KernelShape) => number | [number, number])): KernelShape;
     chamferDistAngle(shape: KernelShape, edges: KernelShape[], distance: number, angleDeg: number): KernelShape;
     /**
      * Distance-angle chamfer with its own values on each edge, in one operation:
-     * `distance` is set back on the edge's reference face (as {@link chamferDistAngle}
-     * picks it) and `angleDeg` is measured from that face.
+     * `distance` is set back on the edge's reference face (its `face`, or as
+     * {@link chamferDistAngle} picks it) and `angleDeg` is measured from that face.
      * Optional: kernels without it can chamfer by distance and angle only with
-     * one value for every edge.
+     * one value for every edge and no reference faces.
      */
-    chamferDistAngles?(shape: KernelShape, edges: ReadonlyArray<{
-        edge: KernelShape;
-        distance: number;
-        angleDeg: number;
-    }>): KernelShape;
+    chamferDistAngles?(shape: KernelShape, edges: ReadonlyArray<ChamferDistAngleEdge>): KernelShape;
     shell(shape: KernelShape, faces: KernelShape[], thickness: number, tolerance?: number): KernelShape;
     thicken(shape: KernelShape, thickness: number): KernelShape;
     offset(shape: KernelShape, distance: number, tolerance?: number): KernelShape;

package/dist/kernel/interfaces/transformOps.d.ts

@@ -9,6 +9,7 @@ export type TransformEntry = {
 } | {
     readonly type: 'rotate';
     readonly shape: KernelShape;
+    /** Degrees, unlike {@link KernelTransformOps.rotate}, which takes radians. */
     readonly angle: number;
     readonly axis: readonly [number, number, number];
     readonly center: readonly [number, number, number];
@@ -24,7 +25,10 @@ export type TransformEntry = {
     readonly normal: readonly [number, number, number];
 };
 export interface KernelTransformOps {
-    /** Create a composed transform from a sequence of translate/rotate operations. Returns an opaque handle. */
+    /**
+     * Create a composed transform from a sequence of translate/rotate operations. Returns an
+     * opaque handle. Rotate angles here are in degrees.
+     */
     composeTransform(ops: Array<{
         type: 'translate';
         x: number;
@@ -51,6 +55,7 @@ export interface KernelTransformOps {
      */
     locate(shape: KernelShape, trsf: KernelType): KernelShape;
     translate(shape: KernelShape, x: number, y: number, z: number): KernelShape;
+    /** Rotate by `angle` radians about `axis` (default +Z) through `center` (default origin). */
     rotate(shape: KernelShape, angle: number, axis?: readonly [number, number, number], center?: readonly [number, number, number]): KernelShape;
     mirror(shape: KernelShape, origin: readonly [number, number, number], normal: readonly [number, number, number]): KernelShape;
     scale(shape: KernelShape, center: readonly [number, number, number], factor: number): KernelShape;
@@ -61,7 +66,7 @@ export interface KernelTransformOps {
     positionOnCurve(shape: KernelShape, spine: KernelShape, param: number): KernelShape;
     /** Generate a linear pattern of shapes with pooled transforms for performance. */
     linearPattern(shape: KernelShape, direction: [number, number, number], spacing: number, count: number): KernelShape[];
-    /** Generate a circular pattern of shapes. */
+    /** Generate a circular pattern of shapes, `angleStep` degrees apart. */
     circularPattern(shape: KernelShape, center: [number, number, number], axis: [number, number, number], angleStep: number, count: number): KernelShape[];
     /** Generate a 2D grid pattern (brepkit-native). Returns a compound. */
     gridPattern?(shape: KernelShape, directionX: [number, number, number], directionY: [number, number, number], spacingX: number, spacingY: number, countX: number, countY: number): KernelShape;

package/dist/kernel/occt/transformOps.d.ts

@@ -24,7 +24,7 @@ export declare function locate(oc: KernelInstance, shape: KernelShape, trsf: Ker
  */
 export declare function translate(oc: KernelInstance, shape: KernelShape, x: number, y: number, z: number): KernelShape;
 /**
- * Rotates a shape around an axis.
+ * Rotates a shape by `angle` radians around an axis.
  */
 export declare function rotate(oc: KernelInstance, shape: KernelShape, angle: number, axis?: readonly [number, number, number], center?: readonly [number, number, number]): KernelShape;
 /**

package/dist/kernel/occtWasm/evolutionOps.d.ts

@@ -1,4 +1,5 @@
 import { BooleanOptions, DiagnosticOperationResult, KernelShape, KernelType, OperationResult } from '../types.js';
+import { ChamferDistAngleEdge } from '../interfaces/modifierOps.js';
 import { OcctKernelWasm, OcctWasmModule } from './occtWasmTypes.js';
 import { EdgeValueSpec } from './helpers.js';
 /**
@@ -19,6 +20,7 @@ export declare function fuseAllWithHistory(k: OcctKernelWasm, Module: OcctWasmMo
 export declare function cutAllWithHistory(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, tools: KernelShape[], inputFaceHashes: number[], hashUpperBound: number, options?: BooleanOptions): DiagnosticOperationResult;
 export declare function filletWithHistory(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, edges: KernelShape[], radius: EdgeValueSpec, inputFaceHashes: number[], hashUpperBound: number): OperationResult;
 export declare function chamferWithHistory(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, edges: KernelShape[], distance: EdgeValueSpec, inputFaceHashes: number[], hashUpperBound: number): OperationResult;
+export declare function chamferDistAnglesWithHistory(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, entries: ReadonlyArray<ChamferDistAngleEdge>, inputFaceHashes: number[], hashUpperBound: number): OperationResult;
 export declare function shellWithHistory(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, faces: KernelShape[], thickness: number, inputFaceHashes: number[], hashUpperBound: number, tolerance?: number): OperationResult;
 export declare function thickenWithHistory(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, thickness: number, inputFaceHashes: number[], hashUpperBound: number): OperationResult;
 export declare function offsetWithHistory(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, distance: number, inputFaceHashes: number[], hashUpperBound: number, tolerance?: number): OperationResult;

package/dist/kernel/occtWasm/helpers.d.ts

@@ -35,11 +35,17 @@ export type EdgeValueSpec = EdgeValue | ((edge: KernelShape) => EdgeValue);
  * and `second`.
  */
 export declare function runEdgeTreatment<T>(Module: OcctWasmModule, edges: KernelShape[], value: EdgeValueSpec, uniform: (edgeVec: EmVectorUint32, value: number) => T, perEdge: (edgeVec: EmVectorUint32, first: EmVectorDouble, second: EmVectorDouble) => T): T;
+/**
+ * A per-edge chamfer's `referenceFaceIds`: empty when no edge names its
+ * reference face, else one id per edge, 0 where the facade picks the face.
+ */
+export declare function referenceFaceIds(faces: ReadonlyArray<KernelShape | undefined>): number[];
 /** Each face's draft angle, in radians. */
 export declare function draftAnglesRad(faces: readonly KernelShape[], angleDeg: number | ((face: KernelShape) => number)): number[];
 /** The peer range still admits older builds, which lack the per-edge and unit entry points. */
 export declare function needsOcctWasm59(what: string): UnsupportedKernelOperationError;
 export declare function needsOcctWasm510(what: string): UnsupportedKernelOperationError;
+export declare function needsOcctWasm511(what: string): UnsupportedKernelOperationError;
 /**
  * Rotate a shape from the kernel's default Z-axis to an arbitrary direction.
  * Used by primitives whose creation API only takes a Z-aligned form.

package/dist/kernel/occtWasm/modifierOps.d.ts

@@ -1,16 +1,11 @@
 import { KernelShape } from '../types.js';
+import { ChamferDistAngleEdge } from '../interfaces/modifierOps.js';
 import { OcctKernelWasm, OcctWasmModule } from './occtWasmTypes.js';
 import { EdgeValueSpec } from './helpers.js';
 export declare function fillet(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, edges: KernelShape[], radius: EdgeValueSpec): KernelShape;
 export declare function chamfer(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, edges: KernelShape[], distance: EdgeValueSpec): KernelShape;
-interface DistAngle {
-    readonly distance: number;
-    readonly angleDeg: number;
-}
 export declare function chamferDistAngle(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, edges: KernelShape[], distance: number, angleDeg: number): KernelShape;
-export declare function chamferDistAngles(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, entries: ReadonlyArray<{
-    edge: KernelShape;
-} & DistAngle>): KernelShape;
+export declare function chamferDistAngles(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, entries: ReadonlyArray<ChamferDistAngleEdge>): KernelShape;
 export declare function shell(k: OcctKernelWasm, Module: OcctWasmModule, shape: KernelShape, faces: KernelShape[], thickness: number, tolerance?: number): KernelShape;
 export declare function thicken(k: OcctKernelWasm, shape: KernelShape, thickness: number): KernelShape;
 export declare function offset(k: OcctKernelWasm, shape: KernelShape, distance: number, tolerance?: number): KernelShape;
@@ -21,4 +16,3 @@ export declare function defeature(k: OcctKernelWasm, Module: OcctWasmModule, sha
 export declare function offsetWire2D(k: OcctKernelWasm, wire: KernelShape, offset: number, joinType?: number | 'arc' | 'intersection' | 'tangent'): KernelShape;
 export declare function simplify(k: OcctKernelWasm, shape: KernelShape): KernelShape;
 export declare function reverseShape(k: OcctKernelWasm, shape: KernelShape): KernelShape;
-export {};

package/dist/kernel/occtWasm/occtWasmAdapter.cjs

@@ -1,3 +1,3 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_occtWasmAdapter = require("../../occtWasmAdapter-TX9M5rkb.cjs");
+const require_occtWasmAdapter = require("../../occtWasmAdapter-BNOuP9DA.cjs");
 exports.OcctWasmAdapter = require_occtWasmAdapter.OcctWasmAdapter;

package/dist/kernel/occtWasm/occtWasmAdapter.d.ts

@@ -2,6 +2,7 @@ import { KernelCapabilities } from '../capabilities.js';
 import { BooleanOpType, BooleanOptions, CheckBooleanResult, DiagnosticOperationResult, DistanceResult, KernelAdapter, KernelEdgeMeshResult, KernelInstance, KernelMeshResult, KernelShape, KernelType, MeshOptions, NurbsCurveData, OperationResult, ShapeOrientation, ShapeType, StepAssemblyPart, SurfaceType } from '../types.js';
 import { BulkMeasurement, Matrix3 } from '../interfaces/measureOps.js';
 import { TransformEntry } from '../interfaces/transformOps.js';
+import { ChamferDistAngleEdge } from '../interfaces/modifierOps.js';
 import { Curve2dHandle, BBox2dHandle } from '../kernel2dTypes.js';
 import { OcctWasmModule, OcctKernelWasm } from './occtWasmTypes.js';
 /**
@@ -166,11 +167,7 @@ export declare class OcctWasmAdapter implements KernelAdapter {
     fillet(shape: KernelShape, edges: KernelShape[], radius: number | [number, number] | ((edge: KernelShape) => number | [number, number])): KernelShape;
     chamfer(shape: KernelShape, edges: KernelShape[], distance: number | [number, number] | ((edge: KernelShape) => number | [number, number])): KernelShape;
     chamferDistAngle(shape: KernelShape, edges: KernelShape[], distance: number, angleDeg: number): KernelShape;
-    chamferDistAngles(shape: KernelShape, edges: ReadonlyArray<{
-        edge: KernelShape;
-        distance: number;
-        angleDeg: number;
-    }>): KernelShape;
+    chamferDistAngles(shape: KernelShape, edges: ReadonlyArray<ChamferDistAngleEdge>): KernelShape;
     shell(shape: KernelShape, faces: KernelShape[], thickness: number, tolerance?: number): KernelShape;
     thicken(shape: KernelShape, thickness: number): KernelShape;
     offset(shape: KernelShape, distance: number, tolerance?: number): KernelShape;
@@ -216,6 +213,7 @@ export declare class OcctWasmAdapter implements KernelAdapter {
     intersectWithHistory(shape: KernelShape, tool: KernelShape, inputFaceHashes: number[], hashUpperBound: number, options?: BooleanOptions): DiagnosticOperationResult;
     filletWithHistory(shape: KernelShape, edges: KernelShape[], radius: number | [number, number] | ((edge: KernelShape) => number | [number, number]), inputFaceHashes: number[], hashUpperBound: number): OperationResult;
     chamferWithHistory(shape: KernelShape, edges: KernelShape[], distance: number | [number, number] | ((edge: KernelShape) => number | [number, number]), inputFaceHashes: number[], hashUpperBound: number): OperationResult;
+    chamferDistAnglesWithHistory(shape: KernelShape, edges: ReadonlyArray<ChamferDistAngleEdge>, inputFaceHashes: number[], hashUpperBound: number): OperationResult;
     shellWithHistory(shape: KernelShape, faces: KernelShape[], thickness: number, inputFaceHashes: number[], hashUpperBound: number, tolerance?: number): OperationResult;
     thickenWithHistory(shape: KernelShape, thickness: number, inputFaceHashes: number[], hashUpperBound: number): OperationResult;
     offsetWithHistory(shape: KernelShape, distance: number, inputFaceHashes: number[], hashUpperBound: number, tolerance?: number): OperationResult;

package/dist/kernel/occtWasm/occtWasmAdapter.js

@@ -1 +1 @@
-export { t as OcctWasmAdapter } from "../../occtWasmAdapter-Be-xZvbQ.js";
+export { t as OcctWasmAdapter } from "../../occtWasmAdapter-1k4udeb3.js";

package/dist/kernel/occtWasm/occtWasmTypes.d.ts

@@ -333,6 +333,8 @@ export interface OcctKernelWasm {
     filletRadiiWithHistory?(solidId: number, edgeIds: EmVectorUint32, startRadii: EmVectorDouble, endRadii: EmVectorDouble, inputFaceHashes: EmVectorInt, hashUpperBound: number): EmEvolutionData;
     /** occt-wasm >= 5.9.0: {@link chamferDistances} with face evolution. */
     chamferDistancesWithHistory?(solidId: number, edgeIds: EmVectorUint32, distances1: EmVectorDouble, distances2: EmVectorDouble, referenceFaceIds: EmVectorUint32, inputFaceHashes: EmVectorInt, hashUpperBound: number): EmEvolutionData;
+    /** occt-wasm >= 5.11.0: {@link chamferDistAngles} with face evolution. */
+    chamferDistAnglesWithHistory?(solidId: number, edgeIds: EmVectorUint32, distances: EmVectorDouble, anglesDeg: EmVectorDouble, referenceFaceIds: EmVectorUint32, inputFaceHashes: EmVectorInt, hashUpperBound: number): EmEvolutionData;
     /** occt-wasm >= 5.9.0 (npm build): {@link draftFaces} with face evolution. */
     draftFacesWithHistory?(shapeId: number, faceIds: EmVectorUint32, anglesRad: EmVectorDouble, dx: number, dy: number, dz: number, px: number, py: number, pz: number, nx: number, ny: number, nz: number, inputFaceHashes: EmVectorInt, hashUpperBound: number): EmEvolutionData;
     shellWithHistory(solidId: number, faceIds: EmVectorUint32, thickness: number, tolerance: number, inputFaceHashes: EmVectorInt, hashUpperBound: number): EmEvolutionData;

package/dist/{loftFns-BqA5gWFR.cjs → loftFns-C9k9UAKh.cjs}

@@ -1,4 +1,4 @@
-const require_shapeTypes = require("./shapeTypes-6tBG0xrR.cjs");
+const require_shapeTypes = require("./shapeTypes-BjitsJRQ.cjs");
 const require_errors = require("./errors-O_blYTWT.cjs");
 const require_types = require("./types-CjF9Rofr.cjs");
 const require_vecOps = require("./vecOps-CrGEPPQM.cjs");
@@ -81,18 +81,6 @@ function castSweepShellTuple(result) {
 		endWire
 	]);
 }
-/**
-* Sweep a wire profile along a spine wire to create a 3D shape.
-*
-* Supports Frenet framing, auxiliary spine twist, scaling laws, contact
-* detection, and configurable corner transition modes.
-*
-* @param wire - The profile wire to sweep (must be closed for solid output).
-* @param spine - The path wire to sweep along.
-* @param config - Sweep configuration (frenet, transition mode, scaling law, etc.).
-* @param shellMode - When `true`, return `[shell, startWire, endWire]` instead of a solid.
-* @returns `Result` containing either a solid or a `[Shape3D, Wire, Wire]` tuple in shell mode.
-*/
 function sweep(wire, spine, config = {}, shellMode = false) {
 	if (config.mode === "simple" && !shellMode) {
 		const kernel = require_shapeTypes.getKernel();
@@ -149,29 +137,23 @@ function sweep(wire, spine, config = {}, shellMode = false) {
 * @returns `Result` containing the swept 3D shape.
 */
 function supportExtrude(wire, center, normal, support) {
-	return sweep(wire, makeSpineWire(center, require_vecOps.vecAdd(center, normal)), { support });
+	try {
+		var _usingCtx$1 = require_shapeTypes._usingCtx();
+		const endPoint = require_vecOps.vecAdd(center, normal);
+		return sweep(wire, _usingCtx$1.u(makeSpineWire(center, endPoint)), { support });
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		_usingCtx$1.d();
+	}
 }
-/**
-* Extrude a wire along a normal with optional profile scaling.
-*
-* Builds a linear spine from `center` to `center + normal` and sweeps the
-* profile wire. When `profileShape` is provided, a scaling law (s-curve or
-* linear) modulates the cross-section size along the path.
-*
-* @param wire - The profile wire to sweep (must be closed).
-* @param center - Start point of the extrusion spine.
-* @param normal - Direction and length of the extrusion. Must be non-zero.
-* @param profileShape - Optional scaling profile applied along the extrusion.
-* @param shellMode - When `true`, return `[shell, startWire, endWire]` instead of a solid.
-* @returns `Result` containing the extruded shape or a shell tuple.
-*/
 function complexExtrude(wire, center, normal, profileShape, shellMode = false) {
 	try {
-		var _usingCtx$1 = require_shapeTypes._usingCtx();
+		var _usingCtx3 = require_shapeTypes._usingCtx();
 		const extrusionLength = require_vecOps.vecLength(normal);
 		if (extrusionLength < 1e-10) return require_errors.err(require_errors.validationError("ZERO_LENGTH_EXTRUSION", "Extrusion vector cannot have zero length"));
 		const endPoint = require_vecOps.vecAdd(center, normal);
-		const spine = _usingCtx$1.u(makeSpineWire(center, endPoint));
+		const spine = _usingCtx3.u(makeSpineWire(center, endPoint));
 		let law = null;
 		if (profileShape) {
 			const lawResult = buildLawFromProfile(extrusionLength, profileShape);
@@ -180,37 +162,22 @@ function complexExtrude(wire, center, normal, profileShape, shellMode = false) {
 		}
 		return sweep(wire, spine, { law }, shellMode);
 	} catch (_) {
-		_usingCtx$1.e = _;
+		_usingCtx3.e = _;
 	} finally {
-		_usingCtx$1.d();
+		_usingCtx3.d();
 	}
 }
-/**
-* Extrude a wire along a normal with helical twist and optional profile scaling.
-*
-* Constructs a helical auxiliary spine that rotates the profile by
-* `angleDegrees` over the extrusion length. Combines twist with optional
-* s-curve or linear scaling when `profileShape` is provided.
-*
-* @param wire - The profile wire to sweep (must be closed).
-* @param angleDegrees - Total twist rotation in degrees. Must be non-zero.
-* @param center - Start point of the extrusion spine.
-* @param normal - Direction and length of the extrusion. Must be non-zero.
-* @param profileShape - Optional scaling profile applied along the extrusion.
-* @param shellMode - When `true`, return `[shell, startWire, endWire]` instead of a solid.
-* @returns `Result` containing the twisted extruded shape or a shell tuple.
-*/
 function twistExtrude(wire, angleDegrees, center, normal, profileShape, shellMode = false) {
 	try {
-		var _usingCtx3 = require_shapeTypes._usingCtx();
+		var _usingCtx4 = require_shapeTypes._usingCtx();
 		if (Math.abs(angleDegrees) < 1e-10) return require_errors.err(require_errors.validationError("ZERO_TWIST_ANGLE", "Twist angle cannot be zero"));
 		const extrusionLength = require_vecOps.vecLength(normal);
 		if (extrusionLength < 1e-10) return require_errors.err(require_errors.validationError("ZERO_LENGTH_EXTRUSION", "Extrusion vector cannot have zero length"));
 		const endPoint = require_vecOps.vecAdd(center, normal);
-		const spine = _usingCtx3.u(makeSpineWire(center, endPoint));
+		const spine = _usingCtx4.u(makeSpineWire(center, endPoint));
 		const leftHanded = angleDegrees < 0;
 		const pitch = 360 / Math.abs(angleDegrees) * extrusionLength;
-		const auxiliarySpine = _usingCtx3.u(makeHelixWire(pitch, extrusionLength, 1, center, normal, leftHanded));
+		const auxiliarySpine = _usingCtx4.u(makeHelixWire(pitch, extrusionLength, 1, center, normal, leftHanded));
 		let law = null;
 		if (profileShape) {
 			const lawResult = buildLawFromProfile(extrusionLength, profileShape);
@@ -222,9 +189,9 @@ function twistExtrude(wire, angleDegrees, center, normal, profileShape, shellMod
 			law
 		}, shellMode);
 	} catch (_) {
-		_usingCtx3.e = _;
+		_usingCtx4.e = _;
 	} finally {
-		_usingCtx3.d();
+		_usingCtx4.d();
 	}
 }
 /** Validate that explicit section locations are in [0,1] and strictly increasing. */

package/dist/{loftFns-DbXEtPKz.js → loftFns-Cbnrz3p8.js}

@@ -1,4 +1,4 @@
-import { G as _usingCtx, T as isWire, h as disposeResultShape, n as castResultShape, q as getKernel, x as isShape3D } from "./shapeTypes-DZGS7hgn.js";
+import { G as _usingCtx, T as isWire, h as disposeResultShape, n as castResultShape, q as getKernel, x as isShape3D } from "./shapeTypes-DbPghQD3.js";
 import { E as ok, b as isErr, d as validationError, g as err, i as kernelError, l as typeCastError, t as BrepErrorCode } from "./errors-BTccWbtE.js";
 import { r as toVec3 } from "./types-CKXsIm9-.js";
 import { c as vecLength, t as vecAdd } from "./vecOps-S-m9H_fe.js";
@@ -81,18 +81,6 @@ function castSweepShellTuple(result) {
 		endWire
 	]);
 }
-/**
-* Sweep a wire profile along a spine wire to create a 3D shape.
-*
-* Supports Frenet framing, auxiliary spine twist, scaling laws, contact
-* detection, and configurable corner transition modes.
-*
-* @param wire - The profile wire to sweep (must be closed for solid output).
-* @param spine - The path wire to sweep along.
-* @param config - Sweep configuration (frenet, transition mode, scaling law, etc.).
-* @param shellMode - When `true`, return `[shell, startWire, endWire]` instead of a solid.
-* @returns `Result` containing either a solid or a `[Shape3D, Wire, Wire]` tuple in shell mode.
-*/
 function sweep(wire, spine, config = {}, shellMode = false) {
 	if (config.mode === "simple" && !shellMode) {
 		const kernel = getKernel();
@@ -149,29 +137,23 @@ function sweep(wire, spine, config = {}, shellMode = false) {
 * @returns `Result` containing the swept 3D shape.
 */
 function supportExtrude(wire, center, normal, support) {
-	return sweep(wire, makeSpineWire(center, vecAdd(center, normal)), { support });
+	try {
+		var _usingCtx$1 = _usingCtx();
+		const endPoint = vecAdd(center, normal);
+		return sweep(wire, _usingCtx$1.u(makeSpineWire(center, endPoint)), { support });
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		_usingCtx$1.d();
+	}
 }
-/**
-* Extrude a wire along a normal with optional profile scaling.
-*
-* Builds a linear spine from `center` to `center + normal` and sweeps the
-* profile wire. When `profileShape` is provided, a scaling law (s-curve or
-* linear) modulates the cross-section size along the path.
-*
-* @param wire - The profile wire to sweep (must be closed).
-* @param center - Start point of the extrusion spine.
-* @param normal - Direction and length of the extrusion. Must be non-zero.
-* @param profileShape - Optional scaling profile applied along the extrusion.
-* @param shellMode - When `true`, return `[shell, startWire, endWire]` instead of a solid.
-* @returns `Result` containing the extruded shape or a shell tuple.
-*/
 function complexExtrude(wire, center, normal, profileShape, shellMode = false) {
 	try {
-		var _usingCtx$1 = _usingCtx();
+		var _usingCtx3 = _usingCtx();
 		const extrusionLength = vecLength(normal);
 		if (extrusionLength < 1e-10) return err(validationError("ZERO_LENGTH_EXTRUSION", "Extrusion vector cannot have zero length"));
 		const endPoint = vecAdd(center, normal);
-		const spine = _usingCtx$1.u(makeSpineWire(center, endPoint));
+		const spine = _usingCtx3.u(makeSpineWire(center, endPoint));
 		let law = null;
 		if (profileShape) {
 			const lawResult = buildLawFromProfile(extrusionLength, profileShape);
@@ -180,37 +162,22 @@ function complexExtrude(wire, center, normal, profileShape, shellMode = false) {
 		}
 		return sweep(wire, spine, { law }, shellMode);
 	} catch (_) {
-		_usingCtx$1.e = _;
+		_usingCtx3.e = _;
 	} finally {
-		_usingCtx$1.d();
+		_usingCtx3.d();
 	}
 }
-/**
-* Extrude a wire along a normal with helical twist and optional profile scaling.
-*
-* Constructs a helical auxiliary spine that rotates the profile by
-* `angleDegrees` over the extrusion length. Combines twist with optional
-* s-curve or linear scaling when `profileShape` is provided.
-*
-* @param wire - The profile wire to sweep (must be closed).
-* @param angleDegrees - Total twist rotation in degrees. Must be non-zero.
-* @param center - Start point of the extrusion spine.
-* @param normal - Direction and length of the extrusion. Must be non-zero.
-* @param profileShape - Optional scaling profile applied along the extrusion.
-* @param shellMode - When `true`, return `[shell, startWire, endWire]` instead of a solid.
-* @returns `Result` containing the twisted extruded shape or a shell tuple.
-*/
 function twistExtrude(wire, angleDegrees, center, normal, profileShape, shellMode = false) {
 	try {
-		var _usingCtx3 = _usingCtx();
+		var _usingCtx4 = _usingCtx();
 		if (Math.abs(angleDegrees) < 1e-10) return err(validationError("ZERO_TWIST_ANGLE", "Twist angle cannot be zero"));
 		const extrusionLength = vecLength(normal);
 		if (extrusionLength < 1e-10) return err(validationError("ZERO_LENGTH_EXTRUSION", "Extrusion vector cannot have zero length"));
 		const endPoint = vecAdd(center, normal);
-		const spine = _usingCtx3.u(makeSpineWire(center, endPoint));
+		const spine = _usingCtx4.u(makeSpineWire(center, endPoint));
 		const leftHanded = angleDegrees < 0;
 		const pitch = 360 / Math.abs(angleDegrees) * extrusionLength;
-		const auxiliarySpine = _usingCtx3.u(makeHelixWire(pitch, extrusionLength, 1, center, normal, leftHanded));
+		const auxiliarySpine = _usingCtx4.u(makeHelixWire(pitch, extrusionLength, 1, center, normal, leftHanded));
 		let law = null;
 		if (profileShape) {
 			const lawResult = buildLawFromProfile(extrusionLength, profileShape);
@@ -222,9 +189,9 @@ function twistExtrude(wire, angleDegrees, center, normal, profileShape, shellMod
 			law
 		}, shellMode);
 	} catch (_) {
-		_usingCtx3.e = _;
+		_usingCtx4.e = _;
 	} finally {
-		_usingCtx3.d();
+		_usingCtx4.d();
 	}
 }
 /** Validate that explicit section locations are in [0,1] and strictly increasing. */

package/dist/{measureFns-_Q-bggOu.cjs → measureFns-Bi62maOJ.cjs}

@@ -1,7 +1,7 @@
-const require_shapeTypes = require("./shapeTypes-6tBG0xrR.cjs");
+const require_shapeTypes = require("./shapeTypes-BjitsJRQ.cjs");
 const require_errors = require("./errors-O_blYTWT.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-t8CbgIAS.cjs");
-const require_faceFns = require("./faceFns-ClpZLuHU.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-s0LddGkF.cjs");
+const require_faceFns = require("./faceFns-C7wBHMPv.cjs");
 // src/measurement/measureCache.ts
 var cache = /* @__PURE__ */ new WeakMap();
 function getCachedMeasurement(shape, key) {

package/dist/{measureFns-NLCrquKi.js → measureFns-DivR02Xb.js}

@@ -1,7 +1,7 @@
-import { q as getKernel } from "./shapeTypes-DZGS7hgn.js";
+import { q as getKernel } from "./shapeTypes-DbPghQD3.js";
 import { E as ok, d as validationError, g as err, t as BrepErrorCode } from "./errors-BTccWbtE.js";
-import { E as kernelCallRaw } from "./topologyQueryFns-BRXpZFCi.js";
-import { m as uvBounds } from "./faceFns-Ek2vnYA8.js";
+import { E as kernelCallRaw } from "./topologyQueryFns-J2ae_Gvc.js";
+import { m as uvBounds } from "./faceFns-DaPoCzd-.js";
 // src/measurement/measureCache.ts
 var cache = /* @__PURE__ */ new WeakMap();
 function getCachedMeasurement(shape, key) {

package/dist/measurement.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_measureFns = require("./measureFns-_Q-bggOu.cjs");
-const require_principalBoxFns = require("./principalBoxFns-Cs3z4CmX.cjs");
+const require_measureFns = require("./measureFns-Bi62maOJ.cjs");
+const require_principalBoxFns = require("./principalBoxFns-DjxE8Rym.cjs");
 exports.createDistanceQuery = require_measureFns.createDistanceQuery;
 exports.measureArea = require_measureFns.measureArea;
 exports.measureDistance = require_measureFns.measureDistance;

package/dist/measurement.js

@@ -1,3 +1,3 @@
-import { a as measureDistance, c as measureLinearProps, d as measureVolumeProps, l as measureSurfaceProps, n as measureArea, o as measureDistanceProps, s as measureLength, t as createDistanceQuery, u as measureVolume } from "./measureFns-NLCrquKi.js";
-import { t as principalBoundingBox } from "./principalBoxFns-B3NAkStp.js";
+import { a as measureDistance, c as measureLinearProps, d as measureVolumeProps, l as measureSurfaceProps, n as measureArea, o as measureDistanceProps, s as measureLength, t as createDistanceQuery, u as measureVolume } from "./measureFns-DivR02Xb.js";
+import { t as principalBoundingBox } from "./principalBoxFns-ez0xXLyK.js";
 export { createDistanceQuery, measureArea, measureDistance, measureDistanceProps, measureLength, measureLinearProps, measureSurfaceProps, measureVolume, measureVolumeProps, principalBoundingBox };

package/dist/{meshFns-DmKYxmT_.cjs → meshFns-8MTf0Lo_.cjs}

@@ -1,8 +1,8 @@
-const require_shapeTypes = require("./shapeTypes-6tBG0xrR.cjs");
-const require_occtWasmAdapter = require("./occtWasmAdapter-TX9M5rkb.cjs");
+const require_shapeTypes = require("./shapeTypes-BjitsJRQ.cjs");
+const require_occtWasmAdapter = require("./occtWasmAdapter-BNOuP9DA.cjs");
 const require_errors = require("./errors-O_blYTWT.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-t8CbgIAS.cjs");
-const require_solidBuilders = require("./solidBuilders-Dl6d8fGZ.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-s0LddGkF.cjs");
+const require_solidBuilders = require("./solidBuilders-Bs2NA3xl.cjs");
 // src/topology/meshCache.ts
 /**
 * Build a parameter key for the inner cache map (excludes shape identity).

package/dist/{meshFns-DBN_h_7v.js → meshFns-CcuY52tt.js}

@@ -1,8 +1,8 @@
-import { q as getKernel, ut as qualityDeflection } from "./shapeTypes-DZGS7hgn.js";
-import { j as isUnsupportedKernelOperationError } from "./occtWasmAdapter-Be-xZvbQ.js";
+import { q as getKernel, ut as qualityDeflection } from "./shapeTypes-DbPghQD3.js";
+import { j as isUnsupportedKernelOperationError } from "./occtWasmAdapter-1k4udeb3.js";
 import { E as ok, g as err, r as ioError, t as BrepErrorCode, u as unsupportedError } from "./errors-BTccWbtE.js";
-import { d as getSolids, n as getBounds } from "./topologyQueryFns-BRXpZFCi.js";
-import { d as getFaceOrigins } from "./solidBuilders-BHGa-BWa.js";
+import { d as getSolids, n as getBounds } from "./topologyQueryFns-J2ae_Gvc.js";
+import { d as getFaceOrigins } from "./solidBuilders-BUI_fGzR.js";
 // src/topology/meshCache.ts
 /**
 * Build a parameter key for the inner cache map (excludes shape identity).

package/dist/{occtWasmAdapter-Be-xZvbQ.js → occtWasmAdapter-1k4udeb3.js}

@@ -2343,6 +2343,14 @@ function runEdgeTreatment(Module, edges, value, uniform, perEdge) {
 		edgeVec.delete();
 	}
 }
+/**
+* A per-edge chamfer's `referenceFaceIds`: empty when no edge names its
+* reference face, else one id per edge, 0 where the facade picks the face.
+*/
+function referenceFaceIds(faces) {
+	if (faces.every((face) => face === void 0)) return [];
+	return faces.map((face) => face === void 0 ? 0 : unwrap(face));
+}
 /** Each face's draft angle, in radians. */
 function draftAnglesRad(faces, angleDeg) {
 	return faces.map((face) => (typeof angleDeg === "function" ? angleDeg(face) : angleDeg) * Math.PI / 180);
@@ -2354,6 +2362,9 @@ function needsOcctWasm59(what) {
 function needsOcctWasm510(what) {
 	return new UnsupportedKernelOperationError(`occt-wasm: ${what} requires occt-wasm >= 5.10.0`);
 }
+function needsOcctWasm511(what) {
+	return new UnsupportedKernelOperationError(`occt-wasm: ${what} requires occt-wasm >= 5.11.0`);
+}
 /**
 * Rotate a shape from the kernel's default Z-axis to an arbitrary direction.
 * Used by primitives whose creation API only takes a Z-aligned form.
@@ -3817,21 +3828,23 @@ function chamfer(k, Module, shape, edges, distance) {
 	}
 }
 /**
-* Chamfer edge i by `distances[i]` and `anglesDeg[i]`. Builds without the
-* per-edge entry point take only `shared`, the one value every edge has.
+* Chamfer edge i by `distances[i]` and `anglesDeg[i]` from reference face
+* `faceIds[i]` (see {@link referenceFaceIds}). Builds without the per-edge
+* entry point take only `shared`, the one value every edge has, and no faces.
 */
-function runChamferDistAngles(k, Module, shape, edges, distances, anglesDeg, shared) {
+function runChamferDistAngles(k, Module, shape, edges, distances, anglesDeg, faceIds, shared) {
 	const id = unwrap(shape);
 	const edgeVec = makeVecU32(Module, edges.map(unwrap));
 	try {
 		if (!k.chamferDistAngles) {
+			if (faceIds.length > 0) throw needsOcctWasm59("distance-angle chamfers measured from a given face");
 			if (!shared) throw needsOcctWasm59("per-edge distance-angle chamfers");
 			return wrapResult(k, k.chamferDistAngle(id, edgeVec, shared.distance, shared.angleDeg));
 		}
 		const chamferDistAngles = k.chamferDistAngles.bind(k);
 		const distanceVec = makeVecDouble(Module, distances);
 		const angleVec = makeVecDouble(Module, anglesDeg);
-		const faceVec = makeVecU32(Module, []);
+		const faceVec = makeVecU32(Module, faceIds);
 		try {
 			return wrapResult(k, reportingFaultyEdges(edges, () => chamferDistAngles(id, edgeVec, distanceVec, angleVec, faceVec)));
 		} finally {
@@ -3844,7 +3857,7 @@ function runChamferDistAngles(k, Module, shape, edges, distances, anglesDeg, sha
 	}
 }
 function chamferDistAngle(k, Module, shape, edges, distance, angleDeg) {
-	return runChamferDistAngles(k, Module, shape, edges, Array(edges.length).fill(distance), Array(edges.length).fill(angleDeg), {
+	return runChamferDistAngles(k, Module, shape, edges, Array(edges.length).fill(distance), Array(edges.length).fill(angleDeg), [], {
 		distance,
 		angleDeg
 	});
@@ -3856,7 +3869,7 @@ function sharedDistAngle(entries) {
 	return entries.every((e) => e.distance === first.distance && e.angleDeg === first.angleDeg) ? first : void 0;
 }
 function chamferDistAngles(k, Module, shape, entries) {
-	return runChamferDistAngles(k, Module, shape, entries.map((e) => e.edge), entries.map((e) => e.distance), entries.map((e) => e.angleDeg), sharedDistAngle(entries));
+	return runChamferDistAngles(k, Module, shape, entries.map((e) => e.edge), entries.map((e) => e.distance), entries.map((e) => e.angleDeg), referenceFaceIds(entries.map((e) => e.face)), sharedDistAngle(entries));
 }
 function shell(k, Module, shape, faces, thickness, tolerance) {
 	const vec = makeVecU32(Module, faces.map(unwrap));
@@ -4466,7 +4479,7 @@ function transformBatch(k, entries) {
 	return entries.map((entry) => {
 		switch (entry.type) {
 			case "translate": return translate(k, entry.shape, entry.x, entry.y, entry.z);
-			case "rotate": return rotate(k, entry.shape, entry.angle, entry.axis, entry.center);
+			case "rotate": return rotate(k, entry.shape, entry.angle * Math.PI / 180, entry.axis, entry.center);
 			case "scale": return scale(k, entry.shape, entry.center, entry.factor);
 			case "mirror": return mirror(k, entry.shape, entry.origin, entry.normal);
 			default: throw new Error("occt-wasm: transformBatch unknown type");
@@ -6204,6 +6217,34 @@ function chamferWithHistory(k, Module, shape, edges, distance, inputFaceHashes,
 		hashVec.delete();
 	}
 }
+function chamferDistAnglesWithHistory(k, Module, shape, entries, inputFaceHashes, hashUpperBound) {
+	if (!k.chamferDistAnglesWithHistory) throw needsOcctWasm511("a distance-angle chamfer with face history");
+	const withHistory = k.chamferDistAnglesWithHistory.bind(k);
+	const shapeId = unwrap(shape);
+	const edges = entries.map((e) => e.edge);
+	const edgeIds = edges.map(unwrap);
+	const distances = entries.map((e) => e.distance);
+	const anglesDeg = entries.map((e) => e.angleDeg);
+	const faceIds = referenceFaceIds(entries.map((e) => e.face));
+	const edgeVec = makeVecU32(Module, edgeIds);
+	const distanceVec = makeVecDouble(Module, distances);
+	const angleVec = makeVecDouble(Module, anglesDeg);
+	const faceVec = makeVecU32(Module, faceIds);
+	const hashVec = makeVecInt(Module, inputFaceHashes);
+	try {
+		const { id, evolution } = parseEvolution(reportingFaultyEdges(edges, () => withHistory(shapeId, edgeVec, distanceVec, angleVec, faceVec, hashVec, hashUpperBound)));
+		return {
+			shape: wrapResult(k, id),
+			evolution
+		};
+	} finally {
+		edgeVec.delete();
+		distanceVec.delete();
+		angleVec.delete();
+		faceVec.delete();
+		hashVec.delete();
+	}
+}
 function shellWithHistory(k, Module, shape, faces, thickness, inputFaceHashes, hashUpperBound, tolerance) {
 	const faceVec = makeVecU32(Module, faces.map(unwrap));
 	const hashVec = makeVecInt(Module, inputFaceHashes);
@@ -6713,6 +6754,9 @@ var OcctWasmAdapter = class OcctWasmAdapter {
 	chamferWithHistory(shape, edges, distance, inputFaceHashes, hashUpperBound) {
 		return chamferWithHistory(this.k, this.Module, shape, edges, distance, inputFaceHashes, hashUpperBound);
 	}
+	chamferDistAnglesWithHistory(shape, edges, inputFaceHashes, hashUpperBound) {
+		return chamferDistAnglesWithHistory(this.k, this.Module, shape, edges, inputFaceHashes, hashUpperBound);
+	}
 	shellWithHistory(shape, faces, thickness, inputFaceHashes, hashUpperBound, tolerance) {
 		return shellWithHistory(this.k, this.Module, shape, faces, thickness, inputFaceHashes, hashUpperBound, tolerance);
 	}