brepjs 18.78.1 → 18.80.0

package/dist/brepjs.js

@@ -15,7 +15,7 @@ import { n as getAtOrThrow, r as lastOrThrow, t as firstOrThrow } from "./arrayA
 import { _ as makeThreePointArc, d as makeCircle, h as makeLine, l as makeBSplineInterpolation, n as fill, r as makeFace, s as assembleWire } from "./surfaceBuilders-hTXdNCYm.js";
 import { A as cutAll, C as threePointArc, D as wireLoop, E as wire, F as sectionToFace$1, I as slice$1, L as split$1, M as fuseAll, N as intersect$2, O as booleanPipeline, P as section$1, S as tangentArc, T as vertex, _ as polygon, a as circle, b as sphere$1, c as cylinder, d as ellipsoid, f as face, g as offsetFace, h as line, i as bsplineApprox, j as fuse$2, k as cut$2, 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$1, x as subFace, y as solid } from "./primitiveFns-BSKbI4Kl.js";
 import { A as edgesOfFace, C as shellWithEvolution, D as getNurbsCurveData, E as fuseAllBisect, F as chamferDistAngle, I as toBufferGeometryData, L as toGroupedBufferGeometryData, M as sharedEdges, N as verticesOfEdge, O as getNurbsSurfaceData, P as wiresOfFace, R as toLODGeometryData, S as intersectWithEvolution, T as cutAllBisect, _ as positionOnCurve, a as healFace, b as filletWithEvolution, c as isValid$1, d as draft$1, f as fillet$1, g as variableFillet, h as thicken$1, i as heal$1, j as facesOfEdge, k as adjacentFaces, l as solidFromShell, m as shell$1, n as fixSelfIntersection, o as healSolid, p as offset$1, r as fixShape, s as healWire, t as autoHeal, u as chamfer$1, v as chamferWithEvolution, w as checkBoolean, x as fuseWithEvolution, y as cutWithEvolution, z as toLineGeometryData } from "./healingFns-Bm-NdBj_.js";
-import { C as updateNode, D as linearPattern, O as exportAssemblySTEP, S as removeChild, T as circularPattern, _ as addChild, a as deserializeHistory, b as createAssemblyNode, c as modifyStep, d as replayFrom, f as replayHistory, g as undoLast, h as stepsFrom, i as createRegistry, k as createAssembly, l as registerOperation, m as stepCount, n as addStep, o as findStep, p as serializeHistory, r as createHistory, s as getShape, t as thread, u as registerShape, v as collectShapes, w as walkAssembly, x as findNode, y as countNodes } from "./threadFns-DGEyXFGP.js";
+import { A as quatRotate, C as prismaticJoint, D as sphericalJoint, E as setJointValues, F as findNode, H as exportAssemblySTEP, I as removeChild, L as updateNode, M as collectShapes, N as countNodes, O as quatFromAxisAngle, P as createAssemblyNode, R as walkAssembly, S as planarJoint, T as setJointValue, U as createAssembly, V as linearPattern, _ as addJoint, a as deserializeHistory, b as jointTransform, c as modifyStep, d as replayFrom, f as replayHistory, g as undoLast, h as stepsFrom, i as createRegistry, j as addChild, k as quatFromTo, l as registerOperation, m as stepCount, n as addStep, o as findStep, p as serializeHistory, r as createHistory, s as getShape, t as thread, u as registerShape, v as cylindricalJoint, w as revoluteJoint, x as mechanismDOF, y as forwardKinematics, z as circularPattern } from "./threadFns-Cra0yHSF.js";
 import { n as BaseSketcher2d, r as organiseBlueprints, t as BlueprintSketcher } from "./blueprintSketcher-EYqKWQh0.js";
 import { a as createTypedFinder, i as wireFinder, n as edgeFinder, r as faceFinder, t as getSingleFace } from "./helpers-CD8EMZ5l.js";
 import { A as sketchEllipse, D as makeBaseBox, E as deserializeDrawing, F as sketchRectangle, I as sketchRoundedRectangle, L as FaceSketcher, M as sketchHelix, N as sketchParametricFunction, O as polysideInnerRadius, P as sketchPolysides, R as Sketcher, S as drawText, _ as drawPolysides, a as drawingIntersect, b as drawSingleCircle, c as rotateDrawing, d as drawFaceOutline, f as drawProjection, g as drawPointsInterpolation, h as drawParametricFunction, i as drawingFuse, j as sketchFaceOffset, k as sketchCircle, l as scaleDrawing, m as drawEllipse, n as drawingCut, o as drawingToSketchOnPlane, p as drawCircle, r as drawingFillet, s as mirrorDrawing, t as drawingChamfer, u as translateDrawing, v as drawRectangle, w as draw, x as drawSingleEllipse, y as drawRoundedRectangle } from "./drawFns-D_LwehLr.js";
@@ -2143,94 +2143,6 @@ function roof(w, options) {
 	}
 }
 //#endregion
-//#region src/utils/quaternion.ts
-function dot$1(a, b) {
-	return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-}
-function cross$1(a, b) {
-	return [
-		a[1] * b[2] - a[2] * b[1],
-		a[2] * b[0] - a[0] * b[2],
-		a[0] * b[1] - a[1] * b[0]
-	];
-}
-function normalize$1(a) {
-	const l = Math.hypot(a[0], a[1], a[2]) || 1;
-	return [
-		a[0] / l,
-		a[1] / l,
-		a[2] / l
-	];
-}
-/** A unit vector perpendicular to `v` (for the 180°/parallel degenerate cases). */
-function anyPerpendicular$1(v) {
-	return normalize$1(cross$1(v, Math.abs(v[0]) < .9 ? [
-		1,
-		0,
-		0
-	] : [
-		0,
-		1,
-		0
-	]));
-}
-/** Rotate vector `v` by quaternion `q`. */
-function quatRotate(q, v) {
-	const [w, x, y, z] = q;
-	const tx = 2 * (y * v[2] - z * v[1]);
-	const ty = 2 * (z * v[0] - x * v[2]);
-	const tz = 2 * (x * v[1] - y * v[0]);
-	return [
-		v[0] + w * tx + (y * tz - z * ty),
-		v[1] + w * ty + (z * tx - x * tz),
-		v[2] + w * tz + (x * ty - y * tx)
-	];
-}
-/** Quaternion for a rotation of `angle` radians about (unit-normalized) `axis`. */
-function quatFromAxisAngle(axis, angle) {
-	const h = angle / 2;
-	const s = Math.sin(h);
-	const u = normalize$1(axis);
-	return [
-		Math.cos(h),
-		u[0] * s,
-		u[1] * s,
-		u[2] * s
-	];
-}
-/** Shortest-arc quaternion rotating unit vector `from` onto unit vector `to`. */
-function quatFromTo(from, to) {
-	const a = normalize$1(from);
-	const b = normalize$1(to);
-	const d = dot$1(a, b);
-	if (d >= .999999999) return [
-		1,
-		0,
-		0,
-		0
-	];
-	if (d <= -.999999999) return quatFromAxisAngle(anyPerpendicular$1(a), Math.PI);
-	const c = cross$1(a, b);
-	const len = Math.hypot(1 + d, c[0], c[1], c[2]) || 1;
-	return [
-		(1 + d) / len,
-		c[0] / len,
-		c[1] / len,
-		c[2] / len
-	];
-}
-/** Hamilton product `a ⊗ b` — the rotation that applies `b` first, then `a`. */
-function quatMultiply(a, b) {
-	const [aw, ax, ay, az] = a;
-	const [bw, bx, by, bz] = b;
-	return [
-		aw * bw - ax * bx - ay * by - az * bz,
-		aw * bx + ax * bw + ay * bz - az * by,
-		aw * by - ax * bz + ay * bw + az * bx,
-		aw * bz + ax * by - ay * bx + az * bw
-	];
-}
-//#endregion
 //#region src/kernel/solverAdapter.ts
 /**
 * Constraint solver adapter — analytical solver for simple assembly mates.
@@ -2385,10 +2297,122 @@ function solveAngle(ref, dep, angleRad) {
 		rotation: quatFromAxisAngle(Math.hypot(c[0], c[1], c[2]) < 1e-9 ? anyPerpendicular(nDep) : c, phi - angleRad)
 	};
 }
-/** Entity types each positioning constraint requires of (entityA, entityB). */
+/**
+* Point-point coincident/distance: place the dependent point on the reference
+* point (`extra` = 0) or at `extra` along the original separation direction.
+* If the points already coincide the direction is arbitrary (+X).
+*/
+function solvePointPair(refOrigin, depOrigin, extra) {
+	const sep = sub(depOrigin, refOrigin);
+	const len = Math.hypot(sep[0], sep[1], sep[2]);
+	return {
+		position: sub(add$1(refOrigin, scale$2(len < 1e-9 ? [
+			1,
+			0,
+			0
+		] : scale$2(sep, 1 / len), extra)), depOrigin),
+		rotation: IDENTITY_ROTATION
+	};
+}
+/**
+* Move the dependent plane (normal `depNormal`, at the origin) so its signed
+* distance from the reference point equals `extra` (the mirror of `solvePlanePair`
+* for a point reference and a plane dependent).
+*/
+function solvePlaneToPoint(depNormal, refOrigin, depOrigin, extra) {
+	const n = normalize(depNormal);
+	return {
+		position: scale$2(n, dot(n, sub(refOrigin, depOrigin)) - extra),
+		rotation: IDENTITY_ROTATION
+	};
+}
+/**
+* Reference axis, dependent point: drop the point onto the axis line
+* (`extra` = 0) or place it at radial distance `extra` from the line, keeping
+* its along-axis position. A point already on the axis gets an arbitrary radial.
+*/
+function solveAxisToPoint(ref, depOrigin, extra) {
+	const d = normalize(ref.direction ?? [
+		0,
+		0,
+		1
+	]);
+	const foot = add$1(ref.origin, scale$2(d, dot(d, sub(depOrigin, ref.origin))));
+	if (extra === 0) return {
+		position: sub(foot, depOrigin),
+		rotation: IDENTITY_ROTATION
+	};
+	const radial = sub(depOrigin, foot);
+	const rlen = Math.hypot(radial[0], radial[1], radial[2]);
+	return {
+		position: sub(add$1(foot, scale$2(rlen < 1e-9 ? anyPerpendicular(d) : scale$2(radial, 1 / rlen), extra)), depOrigin),
+		rotation: IDENTITY_ROTATION
+	};
+}
+/**
+* Reference point, dependent axis: translate the axis line so it passes through
+* the point (`extra` = 0) or lies at perpendicular distance `extra` from it.
+* Translation is purely perpendicular to the axis, so the line's direction and
+* along-axis parameterization are preserved.
+*/
+function solvePointToAxis(refOrigin, dep, extra) {
+	const d = normalize(dep.direction ?? [
+		0,
+		0,
+		1
+	]);
+	const w = sub(dep.origin, refOrigin);
+	const perp = sub(w, scale$2(d, dot(d, w)));
+	const plen = Math.hypot(perp[0], perp[1], perp[2]);
+	if (extra === 0) return {
+		position: scale$2(perp, -1),
+		rotation: IDENTITY_ROTATION
+	};
+	return {
+		position: sub(scale$2(plen < 1e-9 ? anyPerpendicular(d) : scale$2(perp, 1 / plen), extra), perp),
+		rotation: IDENTITY_ROTATION
+	};
+}
+/**
+* Axis-axis distance: align the dependent axis parallel to the reference, then
+* offset it to perpendicular distance `extra` (parallel pin-and-spacer). With
+* `extra` = 0 the axes become collinear, matching `concentric`.
+*/
+function solveAxisAxisDistance(ref, dep, extra) {
+	const dRef = normalize(ref.direction ?? [
+		0,
+		0,
+		1
+	]);
+	const rotation = quatFromTo(normalize(dep.direction ?? [
+		0,
+		0,
+		1
+	]), dRef);
+	const w = sub(quatRotate(rotation, dep.origin), ref.origin);
+	const perp = sub(w, scale$2(dRef, dot(dRef, w)));
+	const plen = Math.hypot(perp[0], perp[1], perp[2]);
+	return {
+		position: sub(scale$2(plen < 1e-9 ? anyPerpendicular(dRef) : scale$2(perp, 1 / plen), extra), perp),
+		rotation
+	};
+}
+/**
+* Supported entity-type pairs for the translational mates (`coincident` /
+* `distance`), keyed `${entityA}-${entityB}`. Both orders are listed where the
+* solver handles them, so a user need not pre-order the entities.
+*/
+var TRANSLATIONAL_PAIRS = new Set([
+	"plane-plane",
+	"plane-point",
+	"point-plane",
+	"point-point",
+	"axis-axis",
+	"axis-point",
+	"point-axis"
+]);
+/** Entity types the orientation/axis mates require of (entityA, entityB). */
 var REQUIRED_ENTITIES = {
-	coincident: "plane",
-	distance: "plane",
 	angle: "plane",
 	concentric: "axis"
 };
@@ -2398,21 +2422,51 @@ var POSITIONING_TYPES = new Set([
 	"angle",
 	"concentric"
 ]);
+/** Whether a positioning mate's entity pair is solvable. */
+function isSupportedPair(type, a, b) {
+	const required = REQUIRED_ENTITIES[type];
+	if (required) return a === required && b === required;
+	return TRANSLATIONAL_PAIRS.has(`${a}-${b}`);
+}
+/**
+* Solve a `coincident` (extra = 0) or `distance` (extra = value) mate for any
+* supported entity-type pair. `ref` is already in world space; the dependent is
+* at the origin. Returns null only for an unsupported pair (filtered out
+* upstream by `isSupportedPair`).
+*/
+function solveTranslational(ref, dep, extra) {
+	switch (`${ref.type}-${dep.type}`) {
+		case "plane-plane":
+		case "plane-point": return solvePlanePair(ref, dep, extra);
+		case "point-plane": return solvePlaneToPoint(dep.normal ?? [
+			0,
+			0,
+			1
+		], ref.origin, dep.origin, extra);
+		case "point-point": return solvePointPair(ref.origin, dep.origin, extra);
+		case "axis-axis": return extra === 0 ? solveConcentric(ref, dep) : solveAxisAxisDistance(ref, dep, extra);
+		case "axis-point": return solveAxisToPoint(ref, dep.origin, extra);
+		case "point-axis": return solvePointToAxis(ref.origin, dep, extra);
+		default: return null;
+	}
+}
 /** Dispatch a positioning mate to its solver. `ref` is already in world space. */
 function solveMate(c, ref, dep) {
 	switch (c.type) {
 		case "concentric": return solveConcentric(ref, dep);
 		case "angle": return solveAngle(ref, dep, (c.value ?? 0) * Math.PI / 180);
-		case "distance": return solvePlanePair(ref, dep, c.value ?? 0);
-		default: return solvePlanePair(ref, dep, 0);
+		case "distance": return solveTranslational(ref, dep, c.value ?? 0) ?? solvePlanePair(ref, dep, c.value ?? 0);
+		default: return solveTranslational(ref, dep, 0) ?? solvePlanePair(ref, dep, 0);
 	}
 }
 /**
 * Solve assembly constraints analytically.
 *
-* Handles: fixed, coincident/distance (plane-plane), concentric (axis-axis), and
-* angle (plane-plane orientation). For a positioning mate, entityA is the
-* reference and entityB the dependent. Chain roots (nodes never positioned by a
+* Handles: fixed, concentric (axis-axis), angle (plane-plane orientation), and
+* coincident/distance for any supported entity-type pair (plane-plane,
+* plane-point, point-point, axis-axis, axis-point, and both point orders — see
+* `TRANSLATIONAL_PAIRS`). For a positioning mate, entityA is the reference and
+* entityB the dependent. Chain roots (nodes never positioned by a
 * mate) and explicit `fixed` nodes anchor at the origin; constraints then resolve
 * in topological order — each places its dependent against the reference's solved
 * pose (rotation included), so multi-body chains compose. Returns
@@ -2439,9 +2493,10 @@ function solveConstraints(nodes, constraints) {
 	const pending = [];
 	for (const c of positioning) {
 		if (!c.entityA || !c.entityB) continue;
-		const required = REQUIRED_ENTITIES[c.type];
-		if (c.entityA.entity.type !== required || c.entityB.entity.type !== required) {
-			unsupported.push(`${c.type}(${c.entityA.entity.type}-${c.entityB.entity.type})`);
+		const a = c.entityA.entity.type;
+		const b = c.entityB.entity.type;
+		if (!isSupportedPair(c.type, a, b)) {
+			unsupported.push(`${c.type}(${a}-${b})`);
 			continue;
 		}
 		pending.push(c);
@@ -2630,191 +2685,6 @@ function solveAssembly(assembly) {
 	}
 }
 //#endregion
-//#region src/operations/jointFns.ts
-var DEG2RAD$1 = Math.PI / 180;
-function clamp(value, min, max) {
-	return Math.min(max, Math.max(min, value));
-}
-function unit(v) {
-	const l = Math.hypot(v[0], v[1], v[2]) || 1;
-	return [
-		v[0] / l,
-		v[1] / l,
-		v[2] / l
-	];
-}
-function makeJoint(type, parent, child, axis, opts, defMin, defMax) {
-	const a = opts.min ?? defMin;
-	const b = opts.max ?? defMax;
-	const min = Math.min(a, b);
-	const max = Math.max(a, b);
-	return {
-		type,
-		parent,
-		child,
-		axis: {
-			origin: axis.origin,
-			direction: unit(axis.direction)
-		},
-		min,
-		max,
-		value: clamp(opts.value ?? 0, min, max)
-	};
-}
-/** A revolute (hinge) joint — the child rotates about `axis` by `value` degrees. */
-function revoluteJoint(parent, child, axis, opts = {}) {
-	return makeJoint("revolute", parent, child, axis, opts, -180, 180);
-}
-/**
-* A prismatic (slider) joint — the child translates along `axis` by `value`
-* units. Only `axis.direction` is used; `axis.origin` is ignored (a pure
-* translation has no anchor point), unlike a revolute joint which rotates about
-* the axis line through `origin`.
-*/
-function prismaticJoint(parent, child, axis, opts = {}) {
-	return makeJoint("prismatic", parent, child, axis, opts, 0, 100);
-}
-/** Return a copy of `joint` with its drivable parameter set (clamped to range). */
-function setJointValue(joint, value) {
-	return {
-		...joint,
-		value: clamp(value, joint.min, joint.max)
-	};
-}
-/**
-* The child's local rigid transform (relative to the parent) for a joint value.
-* Defaults to the joint's stored value; an explicit value is clamped to range.
-*
-* - **revolute**: rotation of `value` degrees about the axis line. Rotating
-*   about a line through `origin` is `p ↦ R·p + (origin − R·origin)`.
-* - **prismatic**: translation of `value` units along the axis direction.
-*/
-function jointTransform(joint, value = joint.value) {
-	const v = clamp(value, joint.min, joint.max);
-	const dir = unit(joint.axis.direction);
-	if (joint.type === "prismatic") return {
-		position: [
-			dir[0] * v,
-			dir[1] * v,
-			dir[2] * v
-		],
-		rotation: [
-			1,
-			0,
-			0,
-			0
-		]
-	};
-	const rotation = quatFromAxisAngle(dir, v * DEG2RAD$1);
-	const o = joint.axis.origin;
-	const ro = quatRotate(rotation, o);
-	return {
-		position: [
-			o[0] - ro[0],
-			o[1] - ro[1],
-			o[2] - ro[2]
-		],
-		rotation
-	};
-}
-/** Attach a joint to an assembly node. Returns a new node (immutable). */
-function addJoint(assembly, joint) {
-	const existing = assembly.joints ?? [];
-	return {
-		...assembly,
-		joints: [...existing, joint]
-	};
-}
-var IDENTITY_POSE = {
-	position: [
-		0,
-		0,
-		0
-	],
-	rotation: [
-		1,
-		0,
-		0,
-		0
-	]
-};
-/** Compose two poses: the result applies `b` in `a`'s frame (`a ∘ b`). */
-function composePose(a, b) {
-	const rb = quatRotate(a.rotation, b.position);
-	return {
-		position: [
-			a.position[0] + rb[0],
-			a.position[1] + rb[1],
-			a.position[2] + rb[2]
-		],
-		rotation: quatMultiply(a.rotation, b.rotation)
-	};
-}
-/** Collect every joint attached anywhere in the assembly tree. */
-function collectJoints(assembly) {
-	const joints = [];
-	walkAssembly(assembly, (node) => {
-		if (node.joints) joints.push(...node.joints);
-	});
-	return joints;
-}
-/**
-* Forward kinematics: set joint values and propagate world poses down the
-* kinematic chain. Each joint's axis is interpreted in its **parent's** frame,
-* so a child's world pose is `parentWorld ∘ jointTransform(joint, value)`.
-*
-* Bodies not driven by a joint (chain roots) start at the origin. `jointValues`
-* overrides a joint's stored value, keyed by the **child** node name; omitted
-* joints use `joint.value`. Resolution is topological (reuses the Phase-0
-* ordering), so chains of any depth compose. Returns a world pose for every node.
-*/
-function forwardKinematics(assembly, jointValues = {}) {
-	const joints = [];
-	const names = /* @__PURE__ */ new Set();
-	walkAssembly(assembly, (node) => {
-		names.add(node.name);
-		if (node.joints) joints.push(...node.joints);
-	});
-	const byChild = /* @__PURE__ */ new Map();
-	for (const j of joints) {
-		byChild.set(j.child, j);
-		names.add(j.parent);
-		names.add(j.child);
-	}
-	const poses = /* @__PURE__ */ new Map();
-	for (const name of names) if (!byChild.has(name)) poses.set(name, IDENTITY_POSE);
-	const pending = [...joints];
-	let progress = true;
-	while (progress && pending.length > 0) {
-		progress = false;
-		for (let i = pending.length - 1; i >= 0; i--) {
-			const j = pending[i];
-			if (!j) continue;
-			const parentPose = poses.get(j.parent);
-			if (!parentPose) continue;
-			pending.splice(i, 1);
-			progress = true;
-			if (poses.has(j.child)) continue;
-			const value = jointValues[j.child] ?? j.value;
-			poses.set(j.child, composePose(parentPose, jointTransform(j, value)));
-		}
-	}
-	for (const j of pending) if (!poses.has(j.child)) poses.set(j.child, IDENTITY_POSE);
-	return poses;
-}
-var JOINT_FREEDOM = {
-	revolute: 1,
-	prismatic: 1
-};
-/**
-* Open-chain mobility — the number of independent degrees of freedom. Each
-* revolute/prismatic joint contributes 1, so for a serial chain this equals the
-* joint count. (Closed-loop Grübler/Kutzbach analysis is future work.)
-*/
-function mechanismDOF(assembly) {
-	return collectJoints(assembly).reduce((sum, j) => sum + JOINT_FREEDOM[j.type], 0);
-}
-//#endregion
 //#region src/measurement/interferenceFns.ts
 /**
 * Interference detection between shapes.
@@ -6584,4 +6454,4 @@ var csg_exports = /* @__PURE__ */ __exportAll({
 	withEvaluator: () => withEvaluator
 });
 //#endregion
-export { BaseSketcher2d, BlueprintSketcher, BrepBugError, BrepErrorCode, BrepWrapperError, BrepkitAdapter, CompoundSketch, DEFAULT_CAPABILITIES, DEG2RAD, DisposalScope, EXACT_BREP_CAPABILITIES, FaceSketcher, HASH_CODE_MAX, OK, OcctWasmAdapter, RAD2DEG, Sketch, Sketcher, Sketches, addChild, addHoles, addJoint, addMate, addStep, adjacentFaces, all, andThen, applyGlue, applyMatrix, approximateCurve, as2D, as3D, asTopo, assignRoles, autoHeal, bezier, blueprintToDXF, booleanPipeline, booleans_exports as booleans, boss, box, bsplineApprox, bug, cameraFromPlane, cameraLookAt, captureHint, cast, castShape, castShape3D, chamfer, chamferDistAngle as chamferDistAngleShape, chamferWithEvolution, checkAllInterferences, checkBoolean, checkInterference, circle, circularPattern, classifyPointOnFace, clearMeshCache, clone, closedWire, collect, collectShapes, colorFaces, colorShape, complexExtrude, composeTransforms, compound, compoundSketchExtrude, compoundSketchFace, compoundSketchLoft, compoundSketchRevolve, computationError, computeStraightSkeleton, cone, construction_exports as construction, convexHull, cornerFinder, countNodes, createAssembly, createAssemblyNode, createBlueprint, createCamera, createCompound, createCompoundBlueprint, createDistanceQuery, createEdge, createFace, createHandle, createHistory, createKernelHandle, createMeshCache, createNamedPlane, createOperationRegistry, createPlane, createRef, createRegistry, createShell, createSolid, createTaskQueue, createVertex, createWire, createWorkerClient, createWorkerHandler, csg_exports as csg, currentQuality, curve2dBoundingBox, curve2dDistanceFrom, curve2dFirstPoint, curve2dIsOnCurve, curve2dLastPoint, curve2dParameter, curve2dSplitAt, curve2dTangentAt, curveAxis, curveEndPoint, curveIsClosed, curveIsPeriodic, curveLength, curvePeriod, curvePointAt, curveStartPoint, curveTangentAt, cut, cut2D, cutAll, cutAllBisect, cutBlueprints, cutWithEvolution, cylinder, defaultScorer, dequeueTask, describe, deserializeDrawing, deserializeHistory, fromBREP as deserializeShape, downcast, draft, draw, drawCircle, drawEllipse, drawFaceOutline, drawParametricFunction, drawPointsInterpolation, drawPolysides, drawProjection, drawRectangle, drawRoundedRectangle, drawSingleCircle, drawSingleEllipse, drawText, drawingChamfer, drawingCut, drawingFillet, drawingFuse, drawingIntersect, drawingToSketchOnPlane, drill, edgeFinder, edgesOfFace, ellipse, ellipseArc, ellipsoid, enqueueTask, err, exportAssemblySTEP, exportDXF, exportGlb, exportGltf, exportIGES, exportOBJ, exportSTEP, exportSTEPConfigured, exportSTL, exportThreeMF, extrude, extrudeAll, face, faceAxis, faceCenter, faceFinder, faceGeomType, faceOrientation, facesOfEdge, fieldBoolean, fieldContour, fieldOffset, fieldReinit, fieldShell, fill, filledFace, fillet, filletWithEvolution, findFacesByTag, findNode, findStep, fixSelfIntersection, fixShape, flatMap, flatten, flipFaceOrientation, flipOrientation, fontMetrics, forwardKinematics, fromBREP$1 as fromBREP, fromKernelDir, fromKernelPnt, fromKernelVec, fromNullable, fuse, fuse2D, fuseAll, fuseAllBisect, fuseBlueprints, fuseWithEvolution, gearGeometry, getActiveVoxelId, getBounds, getBounds2D, getCompSolids, getCurveType, getDisposalStats, getEdges, getFaceColor, getFaceOrigins, getFaceTags, getFaces, getFont, getHashCode, getShape as getHistoryShape, getKernel, getKernelCapabilities, getKernelTier, getNurbsCurveData, getNurbsSurfaceData, getOrientation, getOrientation2D, getPerformanceStats, getShapeColor, getShapeKind, getShells, getSingleFace, getSolids, getSurfaceType, getTagMetadata, getVertices, getVoxel, getWires, guidedSweep, heal, healFace, healSolid, healWire, helix, hull, importDXF, importGLB, importIGES, importOBJ, importSTEP, importSTL, importSVG, importSVGPathD, importThreeMF, init, initFromManifold, initFromOC, initVoxel, innerWires, interpolateCurve, intersect, intersect2D, intersectBlueprints, intersectWithEvolution, invalidateShapeCache, ioNs_exports as io, ioError, is2D, is3D, isChamferRadius, isClosedWire, isCompSolid, isCompound, isDisposeRequest, isEdge, isEmpty, isEqualShape, isErr, isErrorResponse, isFace, isFilletRadius, isInitRequest, isInside2D, isLive, isManifoldShell, isNumber, isOk, isOperationRequest, isOrientedFace, isPlanarFace, isPlanarWire, isProjectionPlane, isEmpty$1 as isQueueEmpty, isSameShape, isShape1D, isShape3D, isShell, isSolid, isSuccessResponse, isValid, isValidSolid, isVertex, isWire, iterCompSolids, iterEdges, iterFaces, iterShells, iterSolids, iterTopo, iterVertices, iterWires, jointTransform, kernelCall, kernelCallRaw, kernelCallScoped, kernelError, latticeInfill, latticeInfillShape, line, linearPattern, loadFont, loft, loftAll, makeBaseBox, makeExternalGear, makeInternalGear, makePlane, makePlanetaryGear, makeProjectedEdges, manifoldShell, map, mapBoth, mapErr, match, measureArea, measureCurvatureAt, measureCurvatureAtMid, measureDistance, measureDistanceProps, measureLength, measureLinearProps, measureSurfaceProps, measureVolume, measureVolumeProps, measurement_exports as measurement, mechanismDOF, mesh, meshEdges, meshMultiLOD, minkowski, mirror, mirror2D, mirrorDrawing, mirrorJoin, modifiers_exports as modifiers, modifyStep, moduleInitError, multiSectionSweep, normalAt, offset, offsetFace, offsetMesh, offsetShape, offsetWire2D, ok, or, orElse, organiseBlueprints, orientedFace, outerWire, patterns_exports as patterns, pendingCount, pipeline, pivotPlane, planarFace, planarWire, planetPlacements, pocket, pointOnSurface, pointsInside, polygon, polyhedron, polysideInnerRadius, polysidesBlueprint, positionOnCurve, prewarm, primitives_exports as primitives, prismaticJoint, projectEdges, projectPointOnFace, query_exports as query, queryError, rectangularPattern, registerHandler, registerKernel, registerKernelTier, registerOperation, registerShape, registerVoxel, rejectAll, removeChild, removeHolesFromFace, repairMesh, replayFrom, replayHistory, resetDisposalStats, resetPerformanceStats, resize, resolve, resolve3D, resolveDirection, resolvePlane, resolveRef, reverseCurve, revoluteJoint, revolve, roof, rotate, rotate2D, rotateDrawing, roundedRectangleBlueprint, scale, scale2D, scaleDrawing, box$1 as sdfBox, capsule as sdfCapsule, cone$1 as sdfCone, cylinder$1 as sdfCylinder, fieldAxialRamp as sdfFieldAxialRamp, fieldClamp as sdfFieldClamp, fieldConst as sdfFieldConst, fieldFromSdf as sdfFieldFromSdf, fieldRadialRamp as sdfFieldRadialRamp, lattice as sdfLattice, plane as sdfPlane, roundedBox as sdfRoundedBox, sphere as sdfSphere, strutLattice as sdfStrutLattice, sweep as sdfSweep, torus as sdfTorus, section, sectionToFace, serializeHistory, setJointValue, setShapeOrigin, setTagMetadata, sewShells, shape, shapeToMeshInput, shapeType, sharedEdges, shell, shellMesh, shellShape, shellWithEvolution, simplify, sketchCircle, sketchEllipse, sketchExtrude, sketchFace, sketchFaceOffset, sketchHelix, sketchLoft, sketchOnFace2D, sketchOnPlane2D, sketchParametricFunction, sketchPolysides, sketchRectangle, sketchRevolve, sketchRoundedRectangle, sketchSweep, sketchText, sketchWires, sketcherStateError, slice, solid, solidFromShell, solveAssembly, sphere$1 as sphere, split, stepCount, stepsFrom, stretch2D, subFace, supportExtrude, supportsConstraintSketch, supportsProjection, surfaceFromGrid, surfaceFromImage, sweep$1 as sweep, tagFaces, tangentArc, tap, tapErr, textBlueprints, textMetrics, thicken, thread, threePointArc, toBREP, toBufferGeometryData, toGroupedBufferGeometryData, toKernelVec, toLODGeometryData, toLineGeometryData, toSVGPathD, toVec2, toVec3, torus$1 as torus, tpmsLattice, transformCopy, transforms_exports as transforms, translate, translate2D, translateDrawing, translatePlane, tryCatch, tryCatchAsync, twistExtrude, typeCastError, undoLast, unsupportedError, unwrap, unwrapErr, unwrapOr, unwrapOrElse, updateNode, updateRoles, uvBounds, uvCoordinates, validSolid, validatePlanetary, validationError, variableFillet, vecAdd, vecAngle, vecCross, vecDistance, vecDot, vecEquals, vecIsZero, vecLength, vecLengthSq, vecNegate, vecNormalize, vecProjectToPlane, vecRepr, vecRotate, vecScale, vecSub, vertex, vertexFinder, vertexPosition, verticesOfEdge, voxelBoolean, voxelBooleanField, voxelBooleanFieldShapes, voxelBooleanShapes, voxelField, voxelFieldFromShape, walkAssembly, windingNumbers, wire, wireFinder, wireLoop, wiresOfFace, withKernel, withKernelDir, withKernelPnt, withKernelVec, withQuality, withScope, withScopeResult, withScopeResultAsync, withTier, zip as zipResults };
+export { BaseSketcher2d, BlueprintSketcher, BrepBugError, BrepErrorCode, BrepWrapperError, BrepkitAdapter, CompoundSketch, DEFAULT_CAPABILITIES, DEG2RAD, DisposalScope, EXACT_BREP_CAPABILITIES, FaceSketcher, HASH_CODE_MAX, OK, OcctWasmAdapter, RAD2DEG, Sketch, Sketcher, Sketches, addChild, addHoles, addJoint, addMate, addStep, adjacentFaces, all, andThen, applyGlue, applyMatrix, approximateCurve, as2D, as3D, asTopo, assignRoles, autoHeal, bezier, blueprintToDXF, booleanPipeline, booleans_exports as booleans, boss, box, bsplineApprox, bug, cameraFromPlane, cameraLookAt, captureHint, cast, castShape, castShape3D, chamfer, chamferDistAngle as chamferDistAngleShape, chamferWithEvolution, checkAllInterferences, checkBoolean, checkInterference, circle, circularPattern, classifyPointOnFace, clearMeshCache, clone, closedWire, collect, collectShapes, colorFaces, colorShape, complexExtrude, composeTransforms, compound, compoundSketchExtrude, compoundSketchFace, compoundSketchLoft, compoundSketchRevolve, computationError, computeStraightSkeleton, cone, construction_exports as construction, convexHull, cornerFinder, countNodes, createAssembly, createAssemblyNode, createBlueprint, createCamera, createCompound, createCompoundBlueprint, createDistanceQuery, createEdge, createFace, createHandle, createHistory, createKernelHandle, createMeshCache, createNamedPlane, createOperationRegistry, createPlane, createRef, createRegistry, createShell, createSolid, createTaskQueue, createVertex, createWire, createWorkerClient, createWorkerHandler, csg_exports as csg, currentQuality, curve2dBoundingBox, curve2dDistanceFrom, curve2dFirstPoint, curve2dIsOnCurve, curve2dLastPoint, curve2dParameter, curve2dSplitAt, curve2dTangentAt, curveAxis, curveEndPoint, curveIsClosed, curveIsPeriodic, curveLength, curvePeriod, curvePointAt, curveStartPoint, curveTangentAt, cut, cut2D, cutAll, cutAllBisect, cutBlueprints, cutWithEvolution, cylinder, cylindricalJoint, defaultScorer, dequeueTask, describe, deserializeDrawing, deserializeHistory, fromBREP as deserializeShape, downcast, draft, draw, drawCircle, drawEllipse, drawFaceOutline, drawParametricFunction, drawPointsInterpolation, drawPolysides, drawProjection, drawRectangle, drawRoundedRectangle, drawSingleCircle, drawSingleEllipse, drawText, drawingChamfer, drawingCut, drawingFillet, drawingFuse, drawingIntersect, drawingToSketchOnPlane, drill, edgeFinder, edgesOfFace, ellipse, ellipseArc, ellipsoid, enqueueTask, err, exportAssemblySTEP, exportDXF, exportGlb, exportGltf, exportIGES, exportOBJ, exportSTEP, exportSTEPConfigured, exportSTL, exportThreeMF, extrude, extrudeAll, face, faceAxis, faceCenter, faceFinder, faceGeomType, faceOrientation, facesOfEdge, fieldBoolean, fieldContour, fieldOffset, fieldReinit, fieldShell, fill, filledFace, fillet, filletWithEvolution, findFacesByTag, findNode, findStep, fixSelfIntersection, fixShape, flatMap, flatten, flipFaceOrientation, flipOrientation, fontMetrics, forwardKinematics, fromBREP$1 as fromBREP, fromKernelDir, fromKernelPnt, fromKernelVec, fromNullable, fuse, fuse2D, fuseAll, fuseAllBisect, fuseBlueprints, fuseWithEvolution, gearGeometry, getActiveVoxelId, getBounds, getBounds2D, getCompSolids, getCurveType, getDisposalStats, getEdges, getFaceColor, getFaceOrigins, getFaceTags, getFaces, getFont, getHashCode, getShape as getHistoryShape, getKernel, getKernelCapabilities, getKernelTier, getNurbsCurveData, getNurbsSurfaceData, getOrientation, getOrientation2D, getPerformanceStats, getShapeColor, getShapeKind, getShells, getSingleFace, getSolids, getSurfaceType, getTagMetadata, getVertices, getVoxel, getWires, guidedSweep, heal, healFace, healSolid, healWire, helix, hull, importDXF, importGLB, importIGES, importOBJ, importSTEP, importSTL, importSVG, importSVGPathD, importThreeMF, init, initFromManifold, initFromOC, initVoxel, innerWires, interpolateCurve, intersect, intersect2D, intersectBlueprints, intersectWithEvolution, invalidateShapeCache, ioNs_exports as io, ioError, is2D, is3D, isChamferRadius, isClosedWire, isCompSolid, isCompound, isDisposeRequest, isEdge, isEmpty, isEqualShape, isErr, isErrorResponse, isFace, isFilletRadius, isInitRequest, isInside2D, isLive, isManifoldShell, isNumber, isOk, isOperationRequest, isOrientedFace, isPlanarFace, isPlanarWire, isProjectionPlane, isEmpty$1 as isQueueEmpty, isSameShape, isShape1D, isShape3D, isShell, isSolid, isSuccessResponse, isValid, isValidSolid, isVertex, isWire, iterCompSolids, iterEdges, iterFaces, iterShells, iterSolids, iterTopo, iterVertices, iterWires, jointTransform, kernelCall, kernelCallRaw, kernelCallScoped, kernelError, latticeInfill, latticeInfillShape, line, linearPattern, loadFont, loft, loftAll, makeBaseBox, makeExternalGear, makeInternalGear, makePlane, makePlanetaryGear, makeProjectedEdges, manifoldShell, map, mapBoth, mapErr, match, measureArea, measureCurvatureAt, measureCurvatureAtMid, measureDistance, measureDistanceProps, measureLength, measureLinearProps, measureSurfaceProps, measureVolume, measureVolumeProps, measurement_exports as measurement, mechanismDOF, mesh, meshEdges, meshMultiLOD, minkowski, mirror, mirror2D, mirrorDrawing, mirrorJoin, modifiers_exports as modifiers, modifyStep, moduleInitError, multiSectionSweep, normalAt, offset, offsetFace, offsetMesh, offsetShape, offsetWire2D, ok, or, orElse, organiseBlueprints, orientedFace, outerWire, patterns_exports as patterns, pendingCount, pipeline, pivotPlane, planarFace, planarJoint, planarWire, planetPlacements, pocket, pointOnSurface, pointsInside, polygon, polyhedron, polysideInnerRadius, polysidesBlueprint, positionOnCurve, prewarm, primitives_exports as primitives, prismaticJoint, projectEdges, projectPointOnFace, query_exports as query, queryError, rectangularPattern, registerHandler, registerKernel, registerKernelTier, registerOperation, registerShape, registerVoxel, rejectAll, removeChild, removeHolesFromFace, repairMesh, replayFrom, replayHistory, resetDisposalStats, resetPerformanceStats, resize, resolve, resolve3D, resolveDirection, resolvePlane, resolveRef, reverseCurve, revoluteJoint, revolve, roof, rotate, rotate2D, rotateDrawing, roundedRectangleBlueprint, scale, scale2D, scaleDrawing, box$1 as sdfBox, capsule as sdfCapsule, cone$1 as sdfCone, cylinder$1 as sdfCylinder, fieldAxialRamp as sdfFieldAxialRamp, fieldClamp as sdfFieldClamp, fieldConst as sdfFieldConst, fieldFromSdf as sdfFieldFromSdf, fieldRadialRamp as sdfFieldRadialRamp, lattice as sdfLattice, plane as sdfPlane, roundedBox as sdfRoundedBox, sphere as sdfSphere, strutLattice as sdfStrutLattice, sweep as sdfSweep, torus as sdfTorus, section, sectionToFace, serializeHistory, setJointValue, setJointValues, setShapeOrigin, setTagMetadata, sewShells, shape, shapeToMeshInput, shapeType, sharedEdges, shell, shellMesh, shellShape, shellWithEvolution, simplify, sketchCircle, sketchEllipse, sketchExtrude, sketchFace, sketchFaceOffset, sketchHelix, sketchLoft, sketchOnFace2D, sketchOnPlane2D, sketchParametricFunction, sketchPolysides, sketchRectangle, sketchRevolve, sketchRoundedRectangle, sketchSweep, sketchText, sketchWires, sketcherStateError, slice, solid, solidFromShell, solveAssembly, sphere$1 as sphere, sphericalJoint, split, stepCount, stepsFrom, stretch2D, subFace, supportExtrude, supportsConstraintSketch, supportsProjection, surfaceFromGrid, surfaceFromImage, sweep$1 as sweep, tagFaces, tangentArc, tap, tapErr, textBlueprints, textMetrics, thicken, thread, threePointArc, toBREP, toBufferGeometryData, toGroupedBufferGeometryData, toKernelVec, toLODGeometryData, toLineGeometryData, toSVGPathD, toVec2, toVec3, torus$1 as torus, tpmsLattice, transformCopy, transforms_exports as transforms, translate, translate2D, translateDrawing, translatePlane, tryCatch, tryCatchAsync, twistExtrude, typeCastError, undoLast, unsupportedError, unwrap, unwrapErr, unwrapOr, unwrapOrElse, updateNode, updateRoles, uvBounds, uvCoordinates, validSolid, validatePlanetary, validationError, variableFillet, vecAdd, vecAngle, vecCross, vecDistance, vecDot, vecEquals, vecIsZero, vecLength, vecLengthSq, vecNegate, vecNormalize, vecProjectToPlane, vecRepr, vecRotate, vecScale, vecSub, vertex, vertexFinder, vertexPosition, verticesOfEdge, voxelBoolean, voxelBooleanField, voxelBooleanFieldShapes, voxelBooleanShapes, voxelField, voxelFieldFromShape, walkAssembly, windingNumbers, wire, wireFinder, wireLoop, wiresOfFace, withKernel, withKernelDir, withKernelPnt, withKernelVec, withQuality, withScope, withScopeResult, withScopeResultAsync, withTier, zip as zipResults };

package/dist/index.d.ts

@@ -121,7 +121,7 @@ export { exportAssemblySTEP, type ShapeOptions, type SupportedUnit, } from './op
 export { linearPattern, circularPattern } from './operations/patternFns.js';
 export { createAssemblyNode, addChild, removeChild, updateNode, findNode, walkAssembly, countNodes, collectShapes, type AssemblyNode, type AssemblyNodeOptions, } from './operations/assemblyFns.js';
 export { addMate, solveAssembly, type MateConstraint, type MateEntity, type AssemblySolveResult, } from './operations/mateFns.js';
-export { revoluteJoint, prismaticJoint, setJointValue, jointTransform, addJoint, forwardKinematics, mechanismDOF, type Joint, type JointAxis, type JointType, type JointPose, type JointOptions, } from './operations/jointFns.js';
+export { revoluteJoint, prismaticJoint, cylindricalJoint, planarJoint, sphericalJoint, setJointValue, setJointValues, jointTransform, addJoint, forwardKinematics, mechanismDOF, type Joint, type JointDOF, type JointAxis, type JointType, type JointPose, type JointOptions, type CylindricalOptions, type PlanarOptions, type SphericalOptions, } from './operations/jointFns.js';
 export { createHistory, addStep, undoLast, findStep, getShape as getHistoryShape, stepCount, stepsFrom, registerShape, createRegistry, registerOperation, replayHistory, replayFrom, modifyStep, serializeHistory, deserializeHistory, type OperationStep, type ModelHistory, type SerializedHistory, type OperationFn, type OperationRegistry as HistoryOperationRegistry, } from './operations/historyFns.js';
 export { measureVolume, measureArea, measureLength, measureDistance, measureDistanceProps, createDistanceQuery, measureVolumeProps, measureSurfaceProps, measureLinearProps, type PhysicalProps, type VolumeProps, type SurfaceProps, type LinearProps, type DistanceProps, measureCurvatureAt, measureCurvatureAtMid, type CurvatureResult, } from './measurement/measureFns.js';
 export { checkInterference, checkAllInterferences, type InterferenceResult, type InterferencePair, } from './measurement/interferenceFns.js';

package/dist/kernel/solverAdapter.d.ts

@@ -34,9 +34,11 @@ export interface SolverResult {
 /**
  * Solve assembly constraints analytically.
  *
- * Handles: fixed, coincident/distance (plane-plane), concentric (axis-axis), and
- * angle (plane-plane orientation). For a positioning mate, entityA is the
- * reference and entityB the dependent. Chain roots (nodes never positioned by a
+ * Handles: fixed, concentric (axis-axis), angle (plane-plane orientation), and
+ * coincident/distance for any supported entity-type pair (plane-plane,
+ * plane-point, point-point, axis-axis, axis-point, and both point orders — see
+ * `TRANSLATIONAL_PAIRS`). For a positioning mate, entityA is the reference and
+ * entityB the dependent. Chain roots (nodes never positioned by a
  * mate) and explicit `fixed` nodes anchor at the origin; constraints then resolve
  * in topological order — each places its dependent against the reference's solved
  * pose (rotation included), so multi-body chains compose. Returns