brepjs 18.79.0 → 18.81.0

package/dist/brepjs.cjs

@@ -17,7 +17,7 @@ const require_arrayAccess = require("./arrayAccess-e4H9cBfh.cjs");
 const require_surfaceBuilders = require("./surfaceBuilders-B8aVZamB.cjs");
 const require_primitiveFns = require("./primitiveFns-DEBQdEkG.cjs");
 const require_healingFns = require("./healingFns--PtL9j2K.cjs");
-const require_threadFns = require("./threadFns-B7a1EVpS.cjs");
+const require_threadFns = require("./threadFns-ubwexS-v.cjs");
 const require_blueprintSketcher = require("./blueprintSketcher-BJPBKhF3.cjs");
 const require_helpers = require("./helpers-B8mE35Fm.cjs");
 const require_drawFns = require("./drawFns-DTpCthM5.cjs");
@@ -2286,10 +2286,122 @@ function solveAngle(ref, dep, angleRad) {
 		rotation: require_threadFns.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 = require_threadFns.quatFromTo(normalize(dep.direction ?? [
+		0,
+		0,
+		1
+	]), dRef);
+	const w = sub(require_threadFns.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"
 };
@@ -2299,21 +2411,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
@@ -2340,9 +2482,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);
@@ -6599,6 +6742,7 @@ exports.intersect2D = require_boolean2D.intersect2D;
 exports.intersectBlueprints = require_boolean2D.intersectBlueprints;
 exports.intersectWithEvolution = require_healingFns.intersectWithEvolution;
 exports.invalidateShapeCache = require_topologyQueryFns.invalidateShapeCache;
+exports.inverseKinematics = require_threadFns.inverseKinematics;
 Object.defineProperty(exports, "io", {
 	enumerable: true,
 	get: function() {
@@ -6650,6 +6794,7 @@ exports.iterSolids = require_topologyQueryFns.iterSolids;
 exports.iterTopo = require_faceFns.iterTopo;
 exports.iterVertices = require_topologyQueryFns.iterVertices;
 exports.iterWires = require_topologyQueryFns.iterWires;
+exports.jointTrajectory = require_threadFns.jointTrajectory;
 exports.jointTransform = require_threadFns.jointTransform;
 exports.kernelCall = require_topologyQueryFns.kernelCall;
 exports.kernelCallRaw = require_topologyQueryFns.kernelCallRaw;

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 { 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 { A as quatFromAxisAngle, B as walkAssembly, C as mechanismDOF, D as setJointValue, E as revoluteJoint, F as countNodes, G as createAssembly, I as createAssemblyNode, L as findNode, M as quatRotate, N as addChild, O as setJointValues, P as collectShapes, R as removeChild, S as jointTransform, T as prismaticJoint, U as linearPattern, V as circularPattern, W as exportAssemblySTEP, _ as inverseKinematics, a as deserializeHistory, b as cylindricalJoint, c as modifyStep, d as replayFrom, f as replayHistory, g as undoLast, h as stepsFrom, i as createRegistry, j as quatFromTo, k as sphericalJoint, 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 jointTrajectory, w as planarJoint, x as forwardKinematics, y as addJoint, z as updateNode } from "./threadFns-D_CxgFXg.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";
@@ -2297,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"
 };
@@ -2310,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
@@ -2351,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);
@@ -6311,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, 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 };
+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, inverseKinematics, 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, jointTrajectory, 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

@@ -122,6 +122,7 @@ 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, 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 { inverseKinematics, jointTrajectory, type IKTarget, type IKOptions, type IKResult, type TrajectorySample, } from './operations/ikFns.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

package/dist/operations/ikFns.d.ts

@@ -0,0 +1,58 @@
+import { Vec3 } from '../core/types.js';
+import { AssemblyNode } from './assemblyFns.js';
+import { JointPose } from './jointFns.js';
+type Quat = readonly [number, number, number, number];
+/** A target for the end-effector: a world position, optionally an orientation. */
+export interface IKTarget {
+    readonly position: Vec3;
+    /** Target orientation `[w, x, y, z]`. Omit for position-only IK. */
+    readonly rotation?: Quat;
+}
+export interface IKOptions {
+    /** Maximum solver iterations. Default 200. */
+    maxIterations?: number;
+    /** Convergence threshold on the residual norm. Default 1e-5. */
+    tolerance?: number;
+    /** Damping factor λ for the least-squares step. Default 0.05. */
+    damping?: number;
+    /** Initial joint values, keyed by child node (number or per-DOF array). */
+    seed?: Readonly<Record<string, number | readonly number[]>>;
+    /** Local point on the end-effector node to drive to the target. Default origin. */
+    tip?: Vec3;
+}
+export interface IKResult {
+    /** Solved joint values, keyed by child node, one entry per DOF. */
+    readonly values: Record<string, number[]>;
+    readonly converged: boolean;
+    readonly iterations: number;
+    /** Final residual norm (position, plus orientation when targeted). */
+    readonly error: number;
+}
+/**
+ * Solve for the joint values that place `endEffector` (offset by `tip`) at
+ * `target`, by damped-least-squares descent on a numerical Jacobian. Joint
+ * ranges are honored: every iterate is clamped to each DOF's `[min, max]`.
+ *
+ * Returns the solved per-DOF values keyed by child node (ready to pass to
+ * `forwardKinematics`), whether it converged, the iteration count, and the final
+ * residual norm. An end-effector with no driving joints, or an unreachable
+ * target, returns `converged: false` with the best configuration found.
+ */
+export declare function inverseKinematics(assembly: AssemblyNode, endEffector: string, target: IKTarget, options?: IKOptions): IKResult;
+export interface TrajectorySample {
+    /** Normalized path parameter in `[0, 1]`. */
+    readonly t: number;
+    /** Interpolated joint values at this step, keyed by child node. */
+    readonly values: Record<string, number[]>;
+    /** Forward-kinematics world poses for every node at this step. */
+    readonly poses: Map<string, JointPose>;
+}
+/**
+ * Sample a straight-line path in joint space from `from` to `to` over `steps`
+ * segments, yielding `steps + 1` samples (inclusive of both endpoints). Each
+ * sample carries the interpolated per-DOF values (clamped to range) and the
+ * forward-kinematics poses of every node. Joints absent from `from`/`to` hold
+ * their stored value at both ends.
+ */
+export declare function jointTrajectory(assembly: AssemblyNode, from: Readonly<Record<string, number | readonly number[]>>, to: Readonly<Record<string, number | readonly number[]>>, steps: number): TrajectorySample[];
+export {};

package/dist/operations.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_threadFns = require("./threadFns-B7a1EVpS.cjs");
+const require_threadFns = require("./threadFns-ubwexS-v.cjs");
 const require_loftFns = require("./loftFns-DiSsI2PM.cjs");
 exports.addChild = require_threadFns.addChild;
 exports.addJoint = require_threadFns.addJoint;
@@ -19,6 +19,8 @@ exports.findStep = require_threadFns.findStep;
 exports.forwardKinematics = require_threadFns.forwardKinematics;
 exports.getHistoryShape = require_threadFns.getShape;
 exports.gridPattern = require_threadFns.gridPattern;
+exports.inverseKinematics = require_threadFns.inverseKinematics;
+exports.jointTrajectory = require_threadFns.jointTrajectory;
 exports.jointTransform = require_threadFns.jointTransform;
 exports.linearPattern = require_threadFns.linearPattern;
 exports.mechanismDOF = require_threadFns.mechanismDOF;

package/dist/operations.d.ts

@@ -11,6 +11,7 @@ export { thread, type ThreadOptions } from './operations/threadFns.js';
 export { linearPattern, circularPattern, gridPattern } from './operations/patternFns.js';
 export { createAssemblyNode, addChild, removeChild, updateNode, findNode, walkAssembly, countNodes, collectShapes, type AssemblyNode, type AssemblyNodeOptions, } from './operations/assemblyFns.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 { inverseKinematics, jointTrajectory, type IKTarget, type IKOptions, type IKResult, type TrajectorySample, } from './operations/ikFns.js';
 export { exportAssemblySTEP, type ShapeOptions, type SupportedUnit, } from './operations/exporterFns.js';
 export { createHistory, addStep, undoLast, findStep, getShape as getHistoryShape, stepCount, stepsFrom, registerShape, createRegistry, registerOperation, replayHistory, replayFrom, modifyStep, type OperationStep, type ModelHistory, type OperationFn, type OperationRegistry as HistoryOperationRegistry, } from './operations/historyFns.js';
 export { type AssemblyExporter, createAssembly } from './operations/exporters.js';

package/dist/operations.js

@@ -1,3 +1,3 @@
-import { B as gridPattern, 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, P as createAssemblyNode, R as walkAssembly, S as planarJoint, T as setJointValue, U as createAssembly, V as linearPattern, _ as addJoint, b as jointTransform, c as modifyStep, d as replayFrom, f as replayHistory, g as undoLast, h as stepsFrom, i as createRegistry, j as addChild, l as registerOperation, m as stepCount, n as addStep, o as findStep, 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 { B as walkAssembly, C as mechanismDOF, D as setJointValue, E as revoluteJoint, F as countNodes, G as createAssembly, H as gridPattern, I as createAssemblyNode, L as findNode, N as addChild, O as setJointValues, P as collectShapes, R as removeChild, S as jointTransform, T as prismaticJoint, U as linearPattern, V as circularPattern, W as exportAssemblySTEP, _ as inverseKinematics, b as cylindricalJoint, c as modifyStep, d as replayFrom, f as replayHistory, g as undoLast, h as stepsFrom, i as createRegistry, k as sphericalJoint, l as registerOperation, m as stepCount, n as addStep, o as findStep, r as createHistory, s as getShape, t as thread, u as registerShape, v as jointTrajectory, w as planarJoint, x as forwardKinematics, y as addJoint, z as updateNode } from "./threadFns-D_CxgFXg.js";
 import { d as twistExtrude, l as supportExtrude, o as complexExtrude, u as sweep } from "./loftFns-CsHOwded.js";
-export { addChild, addJoint, addStep, circularPattern, collectShapes, complexExtrude, countNodes, createAssembly, createAssemblyNode, createHistory, createRegistry, cylindricalJoint, exportAssemblySTEP, findNode, findStep, forwardKinematics, getShape as getHistoryShape, gridPattern, jointTransform, linearPattern, mechanismDOF, modifyStep, planarJoint, prismaticJoint, registerOperation, registerShape, removeChild, replayFrom, replayHistory, revoluteJoint, setJointValue, setJointValues, sphericalJoint, stepCount, stepsFrom, supportExtrude, sweep, thread, twistExtrude, undoLast, updateNode, walkAssembly };
+export { addChild, addJoint, addStep, circularPattern, collectShapes, complexExtrude, countNodes, createAssembly, createAssemblyNode, createHistory, createRegistry, cylindricalJoint, exportAssemblySTEP, findNode, findStep, forwardKinematics, getShape as getHistoryShape, gridPattern, inverseKinematics, jointTrajectory, jointTransform, linearPattern, mechanismDOF, modifyStep, planarJoint, prismaticJoint, registerOperation, registerShape, removeChild, replayFrom, replayHistory, revoluteJoint, setJointValue, setJointValues, sphericalJoint, stepCount, stepsFrom, supportExtrude, sweep, thread, twistExtrude, undoLast, updateNode, walkAssembly };

package/dist/{threadFns-Cra0yHSF.js → threadFns-D_CxgFXg.js}

@@ -565,7 +565,7 @@ function jointTransform(joint, value = joint.value) {
 	const overrides = Array.isArray(value) ? value : void 0;
 	const primary = overrides ? void 0 : value;
 	const origin = joint.axis.origin;
-	let pose = IDENTITY_POSE;
+	let pose = IDENTITY_POSE$1;
 	for (let i = 0; i < joint.dofs.length; i++) {
 		const dof = joint.dofs[i];
 		if (!dof) continue;
@@ -582,7 +582,7 @@ function addJoint(assembly, joint) {
 		joints: [...existing, joint]
 	};
 }
-var IDENTITY_POSE = {
+var IDENTITY_POSE$1 = {
 	position: [
 		0,
 		0,
@@ -639,7 +639,7 @@ function forwardKinematics(assembly, jointValues = {}) {
 		names.add(j.child);
 	}
 	const poses = /* @__PURE__ */ new Map();
-	for (const name of names) if (!byChild.has(name)) poses.set(name, IDENTITY_POSE);
+	for (const name of names) if (!byChild.has(name)) poses.set(name, IDENTITY_POSE$1);
 	const pending = [...joints];
 	let progress = true;
 	while (progress && pending.length > 0) {
@@ -656,7 +656,7 @@ function forwardKinematics(assembly, jointValues = {}) {
 			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);
+	for (const j of pending) if (!poses.has(j.child)) poses.set(j.child, IDENTITY_POSE$1);
 	return poses;
 }
 /**
@@ -669,6 +669,299 @@ function mechanismDOF(assembly) {
 	return collectJoints(assembly).reduce((sum, j) => sum + j.dofs.length, 0);
 }
 //#endregion
+//#region src/operations/ikFns.ts
+var IDENTITY_POSE = {
+	position: [
+		0,
+		0,
+		0
+	],
+	rotation: [
+		1,
+		0,
+		0,
+		0
+	]
+};
+function applyPose(pose, p) {
+	const r = quatRotate(pose.rotation, p);
+	return [
+		r[0] + pose.position[0],
+		r[1] + pose.position[1],
+		r[2] + pose.position[2]
+	];
+}
+function quatConjugate(q) {
+	return [
+		q[0],
+		-q[1],
+		-q[2],
+		-q[3]
+	];
+}
+/**
+* The rotation vector (axis · angle) taking orientation `from` to `to`, i.e. the
+* angular error that drives `from` toward `to`. Returns the zero vector when the
+* orientations coincide.
+*/
+function rotationError(from, to) {
+	let [w, x, y, z] = quatMultiply(to, quatConjugate(from));
+	const norm = Math.hypot(w, x, y, z) || 1;
+	w /= norm;
+	x /= norm;
+	y /= norm;
+	z /= norm;
+	if (w < 0) {
+		w = -w;
+		x = -x;
+		y = -y;
+		z = -z;
+	}
+	const s = Math.hypot(x, y, z);
+	if (s < 1e-12) return [
+		0,
+		0,
+		0
+	];
+	const k = 2 * Math.atan2(s, w) / s;
+	return [
+		x * k,
+		y * k,
+		z * k
+	];
+}
+/** Joints from the root down to `endEffector`, in root→leaf order. */
+function chainTo(assembly, endEffector) {
+	const joints = [];
+	walkAssembly(assembly, (n) => {
+		if (n.joints) joints.push(...n.joints);
+	});
+	const byChild = /* @__PURE__ */ new Map();
+	for (const j of joints) byChild.set(j.child, j);
+	const chain = [];
+	const seen = /* @__PURE__ */ new Set();
+	let cur = endEffector;
+	while (cur && byChild.has(cur) && !seen.has(cur)) {
+		seen.add(cur);
+		const j = byChild.get(cur);
+		if (!j) break;
+		chain.push(j);
+		cur = j.parent;
+	}
+	return chain.reverse();
+}
+/** Read a Float64Array element as a definite number (dense matrices are full). */
+function el(a, i) {
+	return a[i] ?? 0;
+}
+/** Solve `A x = b` for an `n×n` system by Gauss-Jordan with partial pivoting. */
+function solveLinear(A, b, n) {
+	const w = n + 1;
+	const M = new Float64Array(n * w);
+	for (let r = 0; r < n; r++) {
+		for (let c = 0; c < n; c++) M[r * w + c] = el(A, r * n + c);
+		M[r * w + n] = el(b, r);
+	}
+	for (let col = 0; col < n; col++) {
+		let piv = col;
+		for (let r = col + 1; r < n; r++) if (Math.abs(el(M, r * w + col)) > Math.abs(el(M, piv * w + col))) piv = r;
+		if (Math.abs(el(M, piv * w + col)) < 1e-12) return null;
+		if (piv !== col) for (let k = col; k < w; k++) {
+			const tmp = el(M, col * w + k);
+			M[col * w + k] = el(M, piv * w + k);
+			M[piv * w + k] = tmp;
+		}
+		const d = el(M, col * w + col);
+		for (let k = col; k < w; k++) M[col * w + k] = el(M, col * w + k) / d;
+		for (let r = 0; r < n; r++) {
+			if (r === col) continue;
+			const f = el(M, r * w + col);
+			if (f === 0) continue;
+			for (let k = col; k < w; k++) M[r * w + k] = el(M, r * w + k) - f * el(M, col * w + k);
+		}
+	}
+	const x = new Float64Array(n);
+	for (let r = 0; r < n; r++) x[r] = el(M, r * w + n);
+	return x;
+}
+/** Flatten a chain's DOFs into a parameter vector with bounds, applying the seed. */
+function flattenChain(chain, seed) {
+	const segments = [];
+	const q = [];
+	const lo = [];
+	const hi = [];
+	for (const j of chain) {
+		const s = seed?.[j.child];
+		segments.push({
+			child: j.child,
+			count: j.dofs.length
+		});
+		j.dofs.forEach((dof, i) => {
+			const v = (Array.isArray(s) ? s[i] : i === 0 ? s : void 0) ?? dof.value;
+			q.push(Math.min(dof.max, Math.max(dof.min, v)));
+			lo.push(dof.min);
+			hi.push(dof.max);
+		});
+	}
+	return {
+		segments,
+		q: Float64Array.from(q),
+		lo: Float64Array.from(lo),
+		hi: Float64Array.from(hi)
+	};
+}
+/** Slice a parameter vector back into per-joint value arrays keyed by child. */
+function overridesOf(segments, q) {
+	const out = {};
+	let i = 0;
+	for (const seg of segments) {
+		const vals = [];
+		for (let k = 0; k < seg.count; k++) vals.push(el(q, i++));
+		out[seg.child] = vals;
+	}
+	return out;
+}
+/** Residual twist `e` (target − current) for a pose; returns its norm. */
+function residualTwist(out, pose, target, tip, m) {
+	const pos = applyPose(pose, tip);
+	out[0] = target.position[0] - pos[0];
+	out[1] = target.position[1] - pos[1];
+	out[2] = target.position[2] - pos[2];
+	if (m === 6 && target.rotation) {
+		const r = rotationError(pose.rotation, target.rotation);
+		out[3] = r[0];
+		out[4] = r[1];
+		out[5] = r[2];
+	}
+	let s = 0;
+	for (let i = 0; i < m; i++) s += el(out, i) ** 2;
+	return Math.sqrt(s);
+}
+/** Finite-difference Jacobian: column `j` is the end-effector twist from δq[j]. */
+function fillJacobian(J, q, n, m, base, tip, eps, tipPose) {
+	const basePos = applyPose(base, tip);
+	for (let j = 0; j < n; j++) {
+		const saved = el(q, j);
+		q[j] = saved + eps;
+		const p2 = tipPose(q);
+		q[j] = saved;
+		const pos2 = applyPose(p2, tip);
+		J[j] = (pos2[0] - basePos[0]) / eps;
+		J[n + j] = (pos2[1] - basePos[1]) / eps;
+		J[2 * n + j] = (pos2[2] - basePos[2]) / eps;
+		if (m === 6) {
+			const dr = rotationError(base.rotation, p2.rotation);
+			J[3 * n + j] = dr[0] / eps;
+			J[4 * n + j] = dr[1] / eps;
+			J[5 * n + j] = dr[2] / eps;
+		}
+	}
+}
+/** One damped-least-squares step: `Δq = Jᵀ(JJᵀ + λ²I)⁻¹ e`. */
+function dlsStep(J, e, n, m, lambda) {
+	const A = new Float64Array(m * m);
+	const lam2 = lambda * lambda;
+	for (let r = 0; r < m; r++) for (let c = 0; c < m; c++) {
+		let s = 0;
+		for (let k = 0; k < n; k++) s += el(J, r * n + k) * el(J, c * n + k);
+		A[r * m + c] = s + (r === c ? lam2 : 0);
+	}
+	const y = solveLinear(A, e, m);
+	if (!y) return null;
+	const dq = new Float64Array(n);
+	for (let j = 0; j < n; j++) {
+		let v = 0;
+		for (let r = 0; r < m; r++) v += el(J, r * n + j) * el(y, r);
+		dq[j] = v;
+	}
+	return dq;
+}
+/**
+* Solve for the joint values that place `endEffector` (offset by `tip`) at
+* `target`, by damped-least-squares descent on a numerical Jacobian. Joint
+* ranges are honored: every iterate is clamped to each DOF's `[min, max]`.
+*
+* Returns the solved per-DOF values keyed by child node (ready to pass to
+* `forwardKinematics`), whether it converged, the iteration count, and the final
+* residual norm. An end-effector with no driving joints, or an unreachable
+* target, returns `converged: false` with the best configuration found.
+*/
+function inverseKinematics(assembly, endEffector, target, options = {}) {
+	const maxIterations = options.maxIterations ?? 200;
+	const tolerance = options.tolerance ?? 1e-5;
+	const lambda = options.damping ?? .05;
+	const tip = options.tip ?? [
+		0,
+		0,
+		0
+	];
+	const m = target.rotation !== void 0 ? 6 : 3;
+	const eps = 1e-6;
+	const { segments, q, lo, hi } = flattenChain(chainTo(assembly, endEffector), options.seed);
+	const n = q.length;
+	const tipPose = (state) => forwardKinematics(assembly, overridesOf(segments, state)).get(endEffector) ?? IDENTITY_POSE;
+	const e = new Float64Array(m);
+	const J = new Float64Array(m * n);
+	let pose = tipPose(q);
+	let err = residualTwist(e, pose, target, tip, m);
+	let iter = 0;
+	for (; iter < maxIterations && n > 0 && err > tolerance; iter++) {
+		fillJacobian(J, q, n, m, pose, tip, eps, tipPose);
+		const dq = dlsStep(J, e, n, m, lambda);
+		if (!dq) break;
+		for (let j = 0; j < n; j++) {
+			const next = el(q, j) + el(dq, j);
+			q[j] = Math.min(el(hi, j), Math.max(el(lo, j), next));
+		}
+		pose = tipPose(q);
+		err = residualTwist(e, pose, target, tip, m);
+	}
+	return {
+		values: overridesOf(segments, q),
+		converged: err <= tolerance,
+		iterations: iter,
+		error: err
+	};
+}
+/** Resolve a value spec (number, array, or absent) to a per-DOF array. */
+function valuesOf(joint, spec) {
+	return joint.dofs.map((dof, i) => {
+		const v = (Array.isArray(spec) ? spec[i] : i === 0 ? spec : void 0) ?? dof.value;
+		return Math.min(dof.max, Math.max(dof.min, v));
+	});
+}
+/**
+* Sample a straight-line path in joint space from `from` to `to` over `steps`
+* segments, yielding `steps + 1` samples (inclusive of both endpoints). Each
+* sample carries the interpolated per-DOF values (clamped to range) and the
+* forward-kinematics poses of every node. Joints absent from `from`/`to` hold
+* their stored value at both ends.
+*/
+function jointTrajectory(assembly, from, to, steps) {
+	const joints = [];
+	walkAssembly(assembly, (n) => {
+		if (n.joints) joints.push(...n.joints);
+	});
+	const ends = joints.map((j) => ({
+		child: j.child,
+		a: valuesOf(j, from[j.child]),
+		b: valuesOf(j, to[j.child])
+	}));
+	const count = Math.max(1, Math.floor(steps));
+	const samples = [];
+	for (let s = 0; s <= count; s++) {
+		const t = s / count;
+		const values = {};
+		for (const end of ends) values[end.child] = end.a.map((a, i) => a + ((end.b[i] ?? a) - a) * t);
+		samples.push({
+			t,
+			values,
+			poses: forwardKinematics(assembly, values)
+		});
+	}
+	return samples;
+}
+//#endregion
 //#region src/operations/historyFns.ts
 /** Create a new empty history. */
 function createHistory() {
@@ -936,4 +1229,4 @@ function thread(options) {
 	}
 }
 //#endregion
-export { quatRotate as A, gridPattern as B, prismaticJoint as C, sphericalJoint as D, setJointValues as E, findNode as F, exportAssemblySTEP as H, removeChild as I, updateNode as L, collectShapes as M, countNodes as N, quatFromAxisAngle as O, createAssemblyNode as P, walkAssembly as R, planarJoint as S, setJointValue as T, createAssembly as U, linearPattern as V, addJoint as _, deserializeHistory as a, jointTransform as b, modifyStep as c, replayFrom as d, replayHistory as f, undoLast as g, stepsFrom as h, createRegistry as i, addChild as j, quatFromTo as k, registerOperation as l, stepCount as m, addStep as n, findStep as o, serializeHistory as p, createHistory as r, getShape as s, thread as t, registerShape as u, cylindricalJoint as v, revoluteJoint as w, mechanismDOF as x, forwardKinematics as y, circularPattern as z };
+export { quatFromAxisAngle as A, walkAssembly as B, mechanismDOF as C, setJointValue as D, revoluteJoint as E, countNodes as F, createAssembly as G, gridPattern as H, createAssemblyNode as I, findNode as L, quatRotate as M, addChild as N, setJointValues as O, collectShapes as P, removeChild as R, jointTransform as S, prismaticJoint as T, linearPattern as U, circularPattern as V, exportAssemblySTEP as W, inverseKinematics as _, deserializeHistory as a, cylindricalJoint as b, modifyStep as c, replayFrom as d, replayHistory as f, undoLast as g, stepsFrom as h, createRegistry as i, quatFromTo as j, sphericalJoint as k, registerOperation as l, stepCount as m, addStep as n, findStep as o, serializeHistory as p, createHistory as r, getShape as s, thread as t, registerShape as u, jointTrajectory as v, planarJoint as w, forwardKinematics as x, addJoint as y, updateNode as z };

package/dist/{threadFns-B7a1EVpS.cjs → threadFns-ubwexS-v.cjs}

@@ -565,7 +565,7 @@ function jointTransform(joint, value = joint.value) {
 	const overrides = Array.isArray(value) ? value : void 0;
 	const primary = overrides ? void 0 : value;
 	const origin = joint.axis.origin;
-	let pose = IDENTITY_POSE;
+	let pose = IDENTITY_POSE$1;
 	for (let i = 0; i < joint.dofs.length; i++) {
 		const dof = joint.dofs[i];
 		if (!dof) continue;
@@ -582,7 +582,7 @@ function addJoint(assembly, joint) {
 		joints: [...existing, joint]
 	};
 }
-var IDENTITY_POSE = {
+var IDENTITY_POSE$1 = {
 	position: [
 		0,
 		0,
@@ -639,7 +639,7 @@ function forwardKinematics(assembly, jointValues = {}) {
 		names.add(j.child);
 	}
 	const poses = /* @__PURE__ */ new Map();
-	for (const name of names) if (!byChild.has(name)) poses.set(name, IDENTITY_POSE);
+	for (const name of names) if (!byChild.has(name)) poses.set(name, IDENTITY_POSE$1);
 	const pending = [...joints];
 	let progress = true;
 	while (progress && pending.length > 0) {
@@ -656,7 +656,7 @@ function forwardKinematics(assembly, jointValues = {}) {
 			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);
+	for (const j of pending) if (!poses.has(j.child)) poses.set(j.child, IDENTITY_POSE$1);
 	return poses;
 }
 /**
@@ -669,6 +669,299 @@ function mechanismDOF(assembly) {
 	return collectJoints(assembly).reduce((sum, j) => sum + j.dofs.length, 0);
 }
 //#endregion
+//#region src/operations/ikFns.ts
+var IDENTITY_POSE = {
+	position: [
+		0,
+		0,
+		0
+	],
+	rotation: [
+		1,
+		0,
+		0,
+		0
+	]
+};
+function applyPose(pose, p) {
+	const r = quatRotate(pose.rotation, p);
+	return [
+		r[0] + pose.position[0],
+		r[1] + pose.position[1],
+		r[2] + pose.position[2]
+	];
+}
+function quatConjugate(q) {
+	return [
+		q[0],
+		-q[1],
+		-q[2],
+		-q[3]
+	];
+}
+/**
+* The rotation vector (axis · angle) taking orientation `from` to `to`, i.e. the
+* angular error that drives `from` toward `to`. Returns the zero vector when the
+* orientations coincide.
+*/
+function rotationError(from, to) {
+	let [w, x, y, z] = quatMultiply(to, quatConjugate(from));
+	const norm = Math.hypot(w, x, y, z) || 1;
+	w /= norm;
+	x /= norm;
+	y /= norm;
+	z /= norm;
+	if (w < 0) {
+		w = -w;
+		x = -x;
+		y = -y;
+		z = -z;
+	}
+	const s = Math.hypot(x, y, z);
+	if (s < 1e-12) return [
+		0,
+		0,
+		0
+	];
+	const k = 2 * Math.atan2(s, w) / s;
+	return [
+		x * k,
+		y * k,
+		z * k
+	];
+}
+/** Joints from the root down to `endEffector`, in root→leaf order. */
+function chainTo(assembly, endEffector) {
+	const joints = [];
+	walkAssembly(assembly, (n) => {
+		if (n.joints) joints.push(...n.joints);
+	});
+	const byChild = /* @__PURE__ */ new Map();
+	for (const j of joints) byChild.set(j.child, j);
+	const chain = [];
+	const seen = /* @__PURE__ */ new Set();
+	let cur = endEffector;
+	while (cur && byChild.has(cur) && !seen.has(cur)) {
+		seen.add(cur);
+		const j = byChild.get(cur);
+		if (!j) break;
+		chain.push(j);
+		cur = j.parent;
+	}
+	return chain.reverse();
+}
+/** Read a Float64Array element as a definite number (dense matrices are full). */
+function el(a, i) {
+	return a[i] ?? 0;
+}
+/** Solve `A x = b` for an `n×n` system by Gauss-Jordan with partial pivoting. */
+function solveLinear(A, b, n) {
+	const w = n + 1;
+	const M = new Float64Array(n * w);
+	for (let r = 0; r < n; r++) {
+		for (let c = 0; c < n; c++) M[r * w + c] = el(A, r * n + c);
+		M[r * w + n] = el(b, r);
+	}
+	for (let col = 0; col < n; col++) {
+		let piv = col;
+		for (let r = col + 1; r < n; r++) if (Math.abs(el(M, r * w + col)) > Math.abs(el(M, piv * w + col))) piv = r;
+		if (Math.abs(el(M, piv * w + col)) < 1e-12) return null;
+		if (piv !== col) for (let k = col; k < w; k++) {
+			const tmp = el(M, col * w + k);
+			M[col * w + k] = el(M, piv * w + k);
+			M[piv * w + k] = tmp;
+		}
+		const d = el(M, col * w + col);
+		for (let k = col; k < w; k++) M[col * w + k] = el(M, col * w + k) / d;
+		for (let r = 0; r < n; r++) {
+			if (r === col) continue;
+			const f = el(M, r * w + col);
+			if (f === 0) continue;
+			for (let k = col; k < w; k++) M[r * w + k] = el(M, r * w + k) - f * el(M, col * w + k);
+		}
+	}
+	const x = new Float64Array(n);
+	for (let r = 0; r < n; r++) x[r] = el(M, r * w + n);
+	return x;
+}
+/** Flatten a chain's DOFs into a parameter vector with bounds, applying the seed. */
+function flattenChain(chain, seed) {
+	const segments = [];
+	const q = [];
+	const lo = [];
+	const hi = [];
+	for (const j of chain) {
+		const s = seed?.[j.child];
+		segments.push({
+			child: j.child,
+			count: j.dofs.length
+		});
+		j.dofs.forEach((dof, i) => {
+			const v = (Array.isArray(s) ? s[i] : i === 0 ? s : void 0) ?? dof.value;
+			q.push(Math.min(dof.max, Math.max(dof.min, v)));
+			lo.push(dof.min);
+			hi.push(dof.max);
+		});
+	}
+	return {
+		segments,
+		q: Float64Array.from(q),
+		lo: Float64Array.from(lo),
+		hi: Float64Array.from(hi)
+	};
+}
+/** Slice a parameter vector back into per-joint value arrays keyed by child. */
+function overridesOf(segments, q) {
+	const out = {};
+	let i = 0;
+	for (const seg of segments) {
+		const vals = [];
+		for (let k = 0; k < seg.count; k++) vals.push(el(q, i++));
+		out[seg.child] = vals;
+	}
+	return out;
+}
+/** Residual twist `e` (target − current) for a pose; returns its norm. */
+function residualTwist(out, pose, target, tip, m) {
+	const pos = applyPose(pose, tip);
+	out[0] = target.position[0] - pos[0];
+	out[1] = target.position[1] - pos[1];
+	out[2] = target.position[2] - pos[2];
+	if (m === 6 && target.rotation) {
+		const r = rotationError(pose.rotation, target.rotation);
+		out[3] = r[0];
+		out[4] = r[1];
+		out[5] = r[2];
+	}
+	let s = 0;
+	for (let i = 0; i < m; i++) s += el(out, i) ** 2;
+	return Math.sqrt(s);
+}
+/** Finite-difference Jacobian: column `j` is the end-effector twist from δq[j]. */
+function fillJacobian(J, q, n, m, base, tip, eps, tipPose) {
+	const basePos = applyPose(base, tip);
+	for (let j = 0; j < n; j++) {
+		const saved = el(q, j);
+		q[j] = saved + eps;
+		const p2 = tipPose(q);
+		q[j] = saved;
+		const pos2 = applyPose(p2, tip);
+		J[j] = (pos2[0] - basePos[0]) / eps;
+		J[n + j] = (pos2[1] - basePos[1]) / eps;
+		J[2 * n + j] = (pos2[2] - basePos[2]) / eps;
+		if (m === 6) {
+			const dr = rotationError(base.rotation, p2.rotation);
+			J[3 * n + j] = dr[0] / eps;
+			J[4 * n + j] = dr[1] / eps;
+			J[5 * n + j] = dr[2] / eps;
+		}
+	}
+}
+/** One damped-least-squares step: `Δq = Jᵀ(JJᵀ + λ²I)⁻¹ e`. */
+function dlsStep(J, e, n, m, lambda) {
+	const A = new Float64Array(m * m);
+	const lam2 = lambda * lambda;
+	for (let r = 0; r < m; r++) for (let c = 0; c < m; c++) {
+		let s = 0;
+		for (let k = 0; k < n; k++) s += el(J, r * n + k) * el(J, c * n + k);
+		A[r * m + c] = s + (r === c ? lam2 : 0);
+	}
+	const y = solveLinear(A, e, m);
+	if (!y) return null;
+	const dq = new Float64Array(n);
+	for (let j = 0; j < n; j++) {
+		let v = 0;
+		for (let r = 0; r < m; r++) v += el(J, r * n + j) * el(y, r);
+		dq[j] = v;
+	}
+	return dq;
+}
+/**
+* Solve for the joint values that place `endEffector` (offset by `tip`) at
+* `target`, by damped-least-squares descent on a numerical Jacobian. Joint
+* ranges are honored: every iterate is clamped to each DOF's `[min, max]`.
+*
+* Returns the solved per-DOF values keyed by child node (ready to pass to
+* `forwardKinematics`), whether it converged, the iteration count, and the final
+* residual norm. An end-effector with no driving joints, or an unreachable
+* target, returns `converged: false` with the best configuration found.
+*/
+function inverseKinematics(assembly, endEffector, target, options = {}) {
+	const maxIterations = options.maxIterations ?? 200;
+	const tolerance = options.tolerance ?? 1e-5;
+	const lambda = options.damping ?? .05;
+	const tip = options.tip ?? [
+		0,
+		0,
+		0
+	];
+	const m = target.rotation !== void 0 ? 6 : 3;
+	const eps = 1e-6;
+	const { segments, q, lo, hi } = flattenChain(chainTo(assembly, endEffector), options.seed);
+	const n = q.length;
+	const tipPose = (state) => forwardKinematics(assembly, overridesOf(segments, state)).get(endEffector) ?? IDENTITY_POSE;
+	const e = new Float64Array(m);
+	const J = new Float64Array(m * n);
+	let pose = tipPose(q);
+	let err = residualTwist(e, pose, target, tip, m);
+	let iter = 0;
+	for (; iter < maxIterations && n > 0 && err > tolerance; iter++) {
+		fillJacobian(J, q, n, m, pose, tip, eps, tipPose);
+		const dq = dlsStep(J, e, n, m, lambda);
+		if (!dq) break;
+		for (let j = 0; j < n; j++) {
+			const next = el(q, j) + el(dq, j);
+			q[j] = Math.min(el(hi, j), Math.max(el(lo, j), next));
+		}
+		pose = tipPose(q);
+		err = residualTwist(e, pose, target, tip, m);
+	}
+	return {
+		values: overridesOf(segments, q),
+		converged: err <= tolerance,
+		iterations: iter,
+		error: err
+	};
+}
+/** Resolve a value spec (number, array, or absent) to a per-DOF array. */
+function valuesOf(joint, spec) {
+	return joint.dofs.map((dof, i) => {
+		const v = (Array.isArray(spec) ? spec[i] : i === 0 ? spec : void 0) ?? dof.value;
+		return Math.min(dof.max, Math.max(dof.min, v));
+	});
+}
+/**
+* Sample a straight-line path in joint space from `from` to `to` over `steps`
+* segments, yielding `steps + 1` samples (inclusive of both endpoints). Each
+* sample carries the interpolated per-DOF values (clamped to range) and the
+* forward-kinematics poses of every node. Joints absent from `from`/`to` hold
+* their stored value at both ends.
+*/
+function jointTrajectory(assembly, from, to, steps) {
+	const joints = [];
+	walkAssembly(assembly, (n) => {
+		if (n.joints) joints.push(...n.joints);
+	});
+	const ends = joints.map((j) => ({
+		child: j.child,
+		a: valuesOf(j, from[j.child]),
+		b: valuesOf(j, to[j.child])
+	}));
+	const count = Math.max(1, Math.floor(steps));
+	const samples = [];
+	for (let s = 0; s <= count; s++) {
+		const t = s / count;
+		const values = {};
+		for (const end of ends) values[end.child] = end.a.map((a, i) => a + ((end.b[i] ?? a) - a) * t);
+		samples.push({
+			t,
+			values,
+			poses: forwardKinematics(assembly, values)
+		});
+	}
+	return samples;
+}
+//#endregion
 //#region src/operations/historyFns.ts
 /** Create a new empty history. */
 function createHistory() {
@@ -1044,6 +1337,18 @@ Object.defineProperty(exports, "gridPattern", {
 		return gridPattern;
 	}
 });
+Object.defineProperty(exports, "inverseKinematics", {
+	enumerable: true,
+	get: function() {
+		return inverseKinematics;
+	}
+});
+Object.defineProperty(exports, "jointTrajectory", {
+	enumerable: true,
+	get: function() {
+		return jointTrajectory;
+	}
+});
 Object.defineProperty(exports, "jointTransform", {
 	enumerable: true,
 	get: function() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brepjs",
-  "version": "18.79.0",
+  "version": "18.81.0",
   "description": "Web CAD library with pluggable geometry kernel",
   "keywords": [
     "cad",