brepjs 18.119.2 → 18.119.3

package/dist/{topologyQueryFns-DNqT88yx.js → topologyQueryFns-BkQ6Q7gN.js}

@@ -1,6 +1,97 @@
-import { W as DisposalScope, it as getKernel, n as castResultShape, nt as _usingCtx, r as castResultShapeWithKnownType, z as getOrQueryType } from "./shapeTypes-CnKFSfDT.js";
-import { O as ok, f as getSuggestionForCode, p as translateKernelError, v as err } from "./errors-B3CDG537.js";
+import { D as getOrQueryType, K as getKernel, M as DisposalScope, W as _usingCtx, n as castResultShape, r as castResultShapeWithKnownType } from "./shapeTypes-t49f64Dx.js";
+import { E as ok, g as err } from "./errors-MHLiNE-C.js";
 import { n as HASH_CODE_MAX } from "./constants-ITRzCnCp.js";
+//#region src/core/kernelErrorTranslation.ts
+/**
+* Kernel error translation — maps cryptic kernel messages to user-friendly explanations.
+*
+* Extracted from errors.ts to separate pure type/constructor definitions
+* from OCCT-specific regex matching logic.
+*/
+/**
+* Common kernel error patterns and their user-friendly translations.
+* Used by kernelCall to provide actionable error messages.
+*/
+var kernel_ERROR_PATTERNS = [
+	{
+		pattern: /invalid edge configuration|edges?.*(not|fail|invalid)/i,
+		translation: "The edges may not form a continuous loop. Check that edges connect end-to-end without gaps."
+	},
+	{
+		pattern: /BRepAlgoAPI.*failed|boolean.*operation.*failed/i,
+		translation: "Boolean operation failed. Common causes: overlapping faces, zero-thickness geometry, or degenerate shapes. Try healing input shapes first."
+	},
+	{
+		pattern: /fillet.*radius.*too.*large|fillet.*failed/i,
+		translation: "Fillet operation failed. The radius may be too large for the selected edges. Try reducing the radius or check that edges have enough room."
+	},
+	{
+		pattern: /chamfer.*failed|chamfer.*distance.*too.*large/i,
+		translation: "Chamfer operation failed. The distance may be too large for the selected edges. Try reducing the distance or check edge geometry."
+	},
+	{
+		pattern: /shell.*failed|offset.*failed/i,
+		translation: "Shell/offset operation failed. The thickness may be too large, or the shape may have complex geometry. Try reducing thickness."
+	},
+	{
+		pattern: /sweep.*failed|pipe.*failed/i,
+		translation: "Sweep operation failed. Check that the profile and spine are compatible, and that the spine has no sharp twists or self-intersections."
+	},
+	{
+		pattern: /loft.*failed/i,
+		translation: "Loft operation failed. Profiles may be incompatible or have different orientations. Ensure profiles are ordered consistently."
+	},
+	{
+		pattern: /extrude.*failed|prism.*failed/i,
+		translation: "Extrusion failed. The profile may be invalid or self-intersecting. Check that the profile forms a valid closed wire."
+	},
+	{
+		pattern: /revolve.*failed|revolution.*failed/i,
+		translation: "Revolution operation failed. The profile may intersect the axis of revolution, or the angle may be invalid."
+	},
+	{
+		pattern: /self.*intersect|self-intersect/i,
+		translation: "Shape has self-intersections. The operation resulted in overlapping geometry. Simplify the input or adjust parameters."
+	},
+	{
+		pattern: /degener|degenerat/i,
+		translation: "Degenerate geometry detected. The shape has edges or faces with zero length/area. Check input geometry for collapsed elements."
+	},
+	{
+		pattern: /BRepCheck.*fail|shape.*invalid|shape.*not.*valid/i,
+		translation: "Shape validation failed. The resulting shape has invalid topology. Try healing the shape or checking input geometry."
+	}
+];
+var ERROR_CODE_SUGGESTIONS = {
+	FUSE_FAILED: "Try autoHeal() on both operands before the boolean operation. Check for overlapping faces or zero-thickness geometry.",
+	CUT_FAILED: "Try autoHeal() on both operands before the boolean operation. Check for overlapping faces or zero-thickness geometry.",
+	FUSE_NOT_3D: "The boolean result was not a 3D solid. Ensure both input shapes are valid 3D solids, not shells or open surfaces.",
+	CUT_NOT_3D: "The boolean result was not a 3D solid. Ensure both input shapes are valid 3D solids, not shells or open surfaces.",
+	INTERSECT_NOT_3D: "The boolean result was not a 3D solid. Ensure both input shapes are valid 3D solids, not shells or open surfaces.",
+	SWEEP_FAILED: "Ensure the spine curve has no sharp corners or self-intersections. Try simplifying the profile or using a smoother path.",
+	LOFT_FAILED: "Check that all profiles have the same number of edges and consistent orientation. Try reordering profiles.",
+	FILLET_NOT_3D: "The fillet radius may be too large for the selected edges. Try a smaller radius or check that adjacent faces have enough room.",
+	CHAMFER_NOT_3D: "The chamfer distance may be too large. Try a smaller distance or check edge geometry.",
+	SHELL_NOT_3D: "The shell thickness may be too large for the shape. Try reducing thickness or removing problematic faces.",
+	OFFSET_NOT_3D: "The offset distance may be too large for the shape geometry. Try a smaller distance.",
+	DRAFT_FAILED: "The draft angle may be too large or the selected faces incompatible. Try a smaller angle or different faces."
+};
+/** Look up an actionable suggestion for a given error code. */
+function getSuggestionForCode(code) {
+	return ERROR_CODE_SUGGESTIONS[code];
+}
+/**
+* Translate an kernel error message into a user-friendly explanation.
+* If no pattern matches, returns the original message.
+*
+* @param kernelMessage - The raw error message from kernel
+* @returns User-friendly error message with actionable guidance
+*/
+function translateKernelError(kernelMessage) {
+	for (const { pattern, translation } of kernel_ERROR_PATTERNS) if (pattern.test(kernelMessage)) return `${translation} (kernel: ${kernelMessage})`;
+	return kernelMessage;
+}
+//#endregion
 //#region src/core/kernelCall.ts
 function buildError(kind, code, message, cause, suggestion) {
 	const base = {

package/dist/validityTypes-DiTgeCD9.js

@@ -0,0 +1,129 @@
+import { K as getKernel } from "./shapeTypes-t49f64Dx.js";
+import { E as ok, g as err } from "./errors-MHLiNE-C.js";
+//#region src/core/validityTypes.ts
+/**
+* Type guard — check if a wire is closed (forms a loop).
+* Uses the kernel's `curveIsClosed` to verify at runtime.
+*/
+function isClosedWire(wire) {
+	return getKernel().curveIsClosed(wire.wrapped);
+}
+/**
+* Type guard — check if a face is valid and thus safe to use in operations.
+*
+* Uses kernel validity (BRepCheck_Analyzer) which verifies geometric and
+* topological correctness. Faces produced by kernel operations (makeFace,
+* extrude, revolve, boolean ops) are oriented by construction. For faces
+* from STEP/IGES imports or external sources, validity does not guarantee
+* consistent normal orientation — use with caution or re-orient first.
+*/
+function isOrientedFace(face) {
+	return getKernel().isValid(face.wrapped);
+}
+/**
+* Type guard — check if a shell is manifold (watertight, no dangling faces).
+* Checks kernel validity, then attempts `solidFromShell` — if the shell
+* can form a valid solid, it is manifold by definition.
+*
+* The temporary solid created for the proof is disposed immediately to avoid
+* WASM memory leaks.
+*/
+function isManifoldShell(shell) {
+	const kernel = getKernel();
+	if (!kernel.isValid(shell.wrapped)) return false;
+	const validate = kernel.isValidStrict?.bind(kernel) ?? kernel.isValid.bind(kernel);
+	try {
+		const solid = kernel.solidFromShell(shell.wrapped);
+		const valid = validate(solid);
+		try {
+			kernel.dispose(solid);
+		} catch {}
+		return valid;
+	} catch {
+		return false;
+	}
+}
+/**
+* Type guard — check if a solid passes BRepCheck validation.
+*/
+function isValidSolid(solid) {
+	return getKernel().isValid(solid.wrapped);
+}
+/**
+* Prove that a wire is closed, returning a branded `ClosedWire` on success.
+* This is the primary smart constructor for `ClosedWire`.
+*
+* @example
+* ```ts
+* const w = wire([e1, e2, e3]);
+* const closed = closedWire(unwrap(w));
+* if (isOk(closed)) {
+*   const f = face(closed.value); // ClosedWire accepted
+* }
+* ```
+*/
+function closedWire(wire) {
+	if (isClosedWire(wire)) return ok(wire);
+	return err("Wire is not closed: start and end points do not coincide");
+}
+/**
+* Prove that a face is oriented, returning a branded `OrientedFace` on success.
+*/
+function orientedFace(face) {
+	if (isOrientedFace(face)) return ok(face);
+	return err("Face orientation is inconsistent or face is invalid");
+}
+/**
+* Prove that a shell is manifold, returning a branded `ManifoldShell` on success.
+*/
+function manifoldShell(shell) {
+	if (isManifoldShell(shell)) return ok(shell);
+	return err("Shell is not manifold: has free edges or is invalid");
+}
+/**
+* Prove that a solid is valid, returning a branded `ValidSolid` on success.
+*/
+function validSolid(solid) {
+	if (isValidSolid(solid)) return ok(solid);
+	return err("Solid failed BRepCheck validation");
+}
+/** Type guard — check if a face is planar (underlying surface is a plane). */
+function isPlanarFace(face) {
+	return getKernel().surfaceType(face.wrapped) === "plane";
+}
+/**
+* Type guard — check if a wire is planar (all edges lie in a common plane).
+* Strategy: try planar-only face construction first (fast path on OCCT — throws
+* for non-planar wires). If that succeeds, verify the surface type. If it
+* fails, fall back to general mode and check whether the resulting surface is
+* a plane. This handles kernel-specific differences in the planar flag.
+*/
+function isPlanarWire(wire) {
+	const kernel = getKernel();
+	const checkFace = (onlyPlane) => {
+		try {
+			const tempFace = kernel.makeFace(wire.wrapped, onlyPlane);
+			const stype = kernel.surfaceType(tempFace);
+			try {
+				kernel.dispose(tempFace);
+			} catch {}
+			return stype === "plane";
+		} catch {
+			return false;
+		}
+	};
+	if (checkFace(true)) return true;
+	return checkFace(false);
+}
+/** Prove that a face is planar, returning a branded `PlanarFace` on success. */
+function planarFace(face) {
+	if (isPlanarFace(face)) return ok(face);
+	return err("Face is not planar: underlying surface is not a geometric plane");
+}
+/** Prove that a wire is planar, returning a branded `PlanarWire` on success. */
+function planarWire(wire) {
+	if (isPlanarWire(wire)) return ok(wire);
+	return err("Wire is not planar: edges do not lie in a common plane");
+}
+//#endregion
+export { isPlanarFace as a, manifoldShell as c, planarWire as d, validSolid as f, isOrientedFace as i, orientedFace as l, isClosedWire as n, isPlanarWire as o, isManifoldShell as r, isValidSolid as s, closedWire as t, planarFace as u };

package/dist/validityTypes-ZGMVlv7b.cjs

@@ -0,0 +1,200 @@
+const require_shapeTypes = require("./shapeTypes-CkcIL7zv.cjs");
+const require_errors = require("./errors-RHkKO5bZ.cjs");
+//#region src/core/validityTypes.ts
+/**
+* Type guard — check if a wire is closed (forms a loop).
+* Uses the kernel's `curveIsClosed` to verify at runtime.
+*/
+function isClosedWire(wire) {
+	return require_shapeTypes.getKernel().curveIsClosed(wire.wrapped);
+}
+/**
+* Type guard — check if a face is valid and thus safe to use in operations.
+*
+* Uses kernel validity (BRepCheck_Analyzer) which verifies geometric and
+* topological correctness. Faces produced by kernel operations (makeFace,
+* extrude, revolve, boolean ops) are oriented by construction. For faces
+* from STEP/IGES imports or external sources, validity does not guarantee
+* consistent normal orientation — use with caution or re-orient first.
+*/
+function isOrientedFace(face) {
+	return require_shapeTypes.getKernel().isValid(face.wrapped);
+}
+/**
+* Type guard — check if a shell is manifold (watertight, no dangling faces).
+* Checks kernel validity, then attempts `solidFromShell` — if the shell
+* can form a valid solid, it is manifold by definition.
+*
+* The temporary solid created for the proof is disposed immediately to avoid
+* WASM memory leaks.
+*/
+function isManifoldShell(shell) {
+	const kernel = require_shapeTypes.getKernel();
+	if (!kernel.isValid(shell.wrapped)) return false;
+	const validate = kernel.isValidStrict?.bind(kernel) ?? kernel.isValid.bind(kernel);
+	try {
+		const solid = kernel.solidFromShell(shell.wrapped);
+		const valid = validate(solid);
+		try {
+			kernel.dispose(solid);
+		} catch {}
+		return valid;
+	} catch {
+		return false;
+	}
+}
+/**
+* Type guard — check if a solid passes BRepCheck validation.
+*/
+function isValidSolid(solid) {
+	return require_shapeTypes.getKernel().isValid(solid.wrapped);
+}
+/**
+* Prove that a wire is closed, returning a branded `ClosedWire` on success.
+* This is the primary smart constructor for `ClosedWire`.
+*
+* @example
+* ```ts
+* const w = wire([e1, e2, e3]);
+* const closed = closedWire(unwrap(w));
+* if (isOk(closed)) {
+*   const f = face(closed.value); // ClosedWire accepted
+* }
+* ```
+*/
+function closedWire(wire) {
+	if (isClosedWire(wire)) return require_errors.ok(wire);
+	return require_errors.err("Wire is not closed: start and end points do not coincide");
+}
+/**
+* Prove that a face is oriented, returning a branded `OrientedFace` on success.
+*/
+function orientedFace(face) {
+	if (isOrientedFace(face)) return require_errors.ok(face);
+	return require_errors.err("Face orientation is inconsistent or face is invalid");
+}
+/**
+* Prove that a shell is manifold, returning a branded `ManifoldShell` on success.
+*/
+function manifoldShell(shell) {
+	if (isManifoldShell(shell)) return require_errors.ok(shell);
+	return require_errors.err("Shell is not manifold: has free edges or is invalid");
+}
+/**
+* Prove that a solid is valid, returning a branded `ValidSolid` on success.
+*/
+function validSolid(solid) {
+	if (isValidSolid(solid)) return require_errors.ok(solid);
+	return require_errors.err("Solid failed BRepCheck validation");
+}
+/** Type guard — check if a face is planar (underlying surface is a plane). */
+function isPlanarFace(face) {
+	return require_shapeTypes.getKernel().surfaceType(face.wrapped) === "plane";
+}
+/**
+* Type guard — check if a wire is planar (all edges lie in a common plane).
+* Strategy: try planar-only face construction first (fast path on OCCT — throws
+* for non-planar wires). If that succeeds, verify the surface type. If it
+* fails, fall back to general mode and check whether the resulting surface is
+* a plane. This handles kernel-specific differences in the planar flag.
+*/
+function isPlanarWire(wire) {
+	const kernel = require_shapeTypes.getKernel();
+	const checkFace = (onlyPlane) => {
+		try {
+			const tempFace = kernel.makeFace(wire.wrapped, onlyPlane);
+			const stype = kernel.surfaceType(tempFace);
+			try {
+				kernel.dispose(tempFace);
+			} catch {}
+			return stype === "plane";
+		} catch {
+			return false;
+		}
+	};
+	if (checkFace(true)) return true;
+	return checkFace(false);
+}
+/** Prove that a face is planar, returning a branded `PlanarFace` on success. */
+function planarFace(face) {
+	if (isPlanarFace(face)) return require_errors.ok(face);
+	return require_errors.err("Face is not planar: underlying surface is not a geometric plane");
+}
+/** Prove that a wire is planar, returning a branded `PlanarWire` on success. */
+function planarWire(wire) {
+	if (isPlanarWire(wire)) return require_errors.ok(wire);
+	return require_errors.err("Wire is not planar: edges do not lie in a common plane");
+}
+//#endregion
+Object.defineProperty(exports, "closedWire", {
+	enumerable: true,
+	get: function() {
+		return closedWire;
+	}
+});
+Object.defineProperty(exports, "isClosedWire", {
+	enumerable: true,
+	get: function() {
+		return isClosedWire;
+	}
+});
+Object.defineProperty(exports, "isManifoldShell", {
+	enumerable: true,
+	get: function() {
+		return isManifoldShell;
+	}
+});
+Object.defineProperty(exports, "isOrientedFace", {
+	enumerable: true,
+	get: function() {
+		return isOrientedFace;
+	}
+});
+Object.defineProperty(exports, "isPlanarFace", {
+	enumerable: true,
+	get: function() {
+		return isPlanarFace;
+	}
+});
+Object.defineProperty(exports, "isPlanarWire", {
+	enumerable: true,
+	get: function() {
+		return isPlanarWire;
+	}
+});
+Object.defineProperty(exports, "isValidSolid", {
+	enumerable: true,
+	get: function() {
+		return isValidSolid;
+	}
+});
+Object.defineProperty(exports, "manifoldShell", {
+	enumerable: true,
+	get: function() {
+		return manifoldShell;
+	}
+});
+Object.defineProperty(exports, "orientedFace", {
+	enumerable: true,
+	get: function() {
+		return orientedFace;
+	}
+});
+Object.defineProperty(exports, "planarFace", {
+	enumerable: true,
+	get: function() {
+		return planarFace;
+	}
+});
+Object.defineProperty(exports, "planarWire", {
+	enumerable: true,
+	get: function() {
+		return planarWire;
+	}
+});
+Object.defineProperty(exports, "validSolid", {
+	enumerable: true,
+	get: function() {
+		return validSolid;
+	}
+});

package/dist/vectors.cjs

@@ -2,7 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_constants = require("./constants-BOVyEYGH.cjs");
 const require_types = require("./types-KjA8tY4Y.cjs");
 const require_vecOps = require("./vecOps-CCnJt-yH.cjs");
-const require_planeOps = require("./planeOps-Cr25KWWA.cjs");
+const require_planeOps = require("./planeOps-VlFxtvzY.cjs");
 exports.DEG2RAD = require_constants.DEG2RAD;
 exports.RAD2DEG = require_constants.RAD2DEG;
 exports.createNamedPlane = require_planeOps.createNamedPlane;

package/dist/vectors.js

@@ -1,5 +1,5 @@
 import { r as RAD2DEG, t as DEG2RAD } from "./constants-ITRzCnCp.js";
 import { n as toVec2, r as toVec3, t as resolveDirection } from "./types-D24Y27N0.js";
 import { a as vecDot, c as vecLength, d as vecNormalize, f as vecProjectToPlane, g as vecSub, h as vecScale, i as vecDistance, l as vecLengthSq, m as vecRotate, n as vecAngle, o as vecEquals, p as vecRepr, r as vecCross, s as vecIsZero, t as vecAdd, u as vecNegate } from "./vecOps-SKPRvPH-.js";
-import { i as pivotPlane, n as createPlane, o as resolvePlane, s as translatePlane, t as createNamedPlane } from "./planeOps-Cp6GQ23-.js";
+import { i as pivotPlane, n as createPlane, o as resolvePlane, s as translatePlane, t as createNamedPlane } from "./planeOps-CQahLrCx.js";
 export { DEG2RAD, RAD2DEG, createNamedPlane, createPlane, pivotPlane, resolveDirection, resolvePlane, toVec2, toVec3, translatePlane, vecAdd, vecAngle, vecCross, vecDistance, vecDot, vecEquals, vecIsZero, vecLength, vecLengthSq, vecNegate, vecNormalize, vecProjectToPlane, vecRepr, vecRotate, vecScale, vecSub };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brepjs",
-  "version": "18.119.2",
+  "version": "18.119.3",
   "description": "Web CAD library with pluggable geometry kernel",
   "keywords": [
     "cad",
@@ -265,23 +265,23 @@
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "@vitest/coverage-v8": "4.1.10",
     "brepjs-opencascade": "*",
-    "brepkit-wasm": "2.126.2",
+    "brepkit-wasm": "2.127.10",
     "eslint": "10.7.0",
     "fast-check": "4.9.0",
     "husky": "9.1.7",
-    "knip": "6.26.0",
-    "lint-staged": "17.0.8",
+    "knip": "6.27.0",
+    "lint-staged": "17.1.0",
     "lz-string": "1.5.0",
     "occt-wasm": "3.8.0",
-    "prettier": "3.9.5",
+    "prettier": "3.9.6",
     "puppeteer": "25.3.0",
     "size-limit": "12.1.0",
     "sucrase": "3.35.1",
-    "tsx": "4.23.0",
+    "tsx": "4.23.1",
     "typedoc": "0.28.20",
     "typescript": "6.0.3",
-    "typescript-eslint": "8.63.0",
-    "vite": "8.1.4",
+    "typescript-eslint": "8.65.0",
+    "vite": "8.1.5",
     "vite-plugin-dts": "5.0.3",
     "vitest": "4.1.10"
   },