brepjs 18.80.0 → 18.81.1

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-By0Gy2f9.cjs");
 const require_blueprintSketcher = require("./blueprintSketcher-BJPBKhF3.cjs");
 const require_helpers = require("./helpers-B8mE35Fm.cjs");
 const require_drawFns = require("./drawFns-DTpCthM5.cjs");
@@ -2444,8 +2444,11 @@ 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 solveTranslational(ref, dep, c.value ?? 0) ?? solvePlanePair(ref, dep, c.value ?? 0);
-		default: return solveTranslational(ref, dep, 0) ?? solvePlanePair(ref, dep, 0);
+		default: {
+			const pose = solveTranslational(ref, dep, c.type === "distance" ? c.value ?? 0 : 0);
+			if (!pose) throw new Error(`solveMate: unsupported entity pair escaped filter: ${ref.type}-${dep.type}`);
+			return pose;
+		}
 	}
 }
 /**
@@ -6742,6 +6745,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() {
@@ -6793,6 +6797,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-YzJhd0Kz.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";
@@ -2455,8 +2455,11 @@ 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 solveTranslational(ref, dep, c.value ?? 0) ?? solvePlanePair(ref, dep, c.value ?? 0);
-		default: return solveTranslational(ref, dep, 0) ?? solvePlanePair(ref, dep, 0);
+		default: {
+			const pose = solveTranslational(ref, dep, c.type === "distance" ? c.value ?? 0 : 0);
+			if (!pose) throw new Error(`solveMate: unsupported entity pair escaped filter: ${ref.type}-${dep.type}`);
+			return pose;
+		}
 	}
 }
 /**
@@ -6454,4 +6457,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/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/jointFns.d.ts

@@ -50,7 +50,12 @@ export interface JointOptions {
 export interface CylindricalOptions {
     /** Rotation DOF (degrees). Default range -180..180. */
     rotation?: JointOptions;
-    /** Translation DOF (length). Default range 0..100. */
+    /**
+     * Translation DOF (length). Default range 0..100, matching `prismaticJoint`
+     * (both model a slide along an axis). This is deliberately asymmetric with
+     * `planarJoint`'s in-plane translations, which default to -100..100 because
+     * an unanchored in-plane slide is naturally bidirectional.
+     */
     translation?: JointOptions;
 }
 /** Per-DOF ranges for a planar joint (two in-plane translations + a rotation). */

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-By0Gy2f9.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-YzJhd0Kz.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-B7a1EVpS.cjs → threadFns-By0Gy2f9.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,306 @@ 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].
+* The probe steps *inward* from a bound — `forwardKinematics` clamps each DOF to
+* its range, so a forward `+eps` at the upper limit would yield a zero column and
+* trap the solver at the ceiling. Stepping `-eps` there (and dividing by the
+* signed step) keeps every column a true one-sided derivative.
+*/
+function fillJacobian(J, q, n, m, lo, hi, base, tip, eps, tipPose) {
+	const basePos = applyPose(base, tip);
+	for (let j = 0; j < n; j++) {
+		const saved = el(q, j);
+		const h = saved + eps > el(hi, j) && saved - eps >= el(lo, j) ? -eps : eps;
+		q[j] = saved + h;
+		const p2 = tipPose(q);
+		q[j] = saved;
+		const pos2 = applyPose(p2, tip);
+		J[j] = (pos2[0] - basePos[0]) / h;
+		J[n + j] = (pos2[1] - basePos[1]) / h;
+		J[2 * n + j] = (pos2[2] - basePos[2]) / h;
+		if (m === 6) {
+			const dr = rotationError(base.rotation, p2.rotation);
+			J[3 * n + j] = dr[0] / h;
+			J[4 * n + j] = dr[1] / h;
+			J[5 * n + j] = dr[2] / h;
+		}
+	}
+}
+/** 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, lo, hi, 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 +1344,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/dist/{threadFns-Cra0yHSF.js → threadFns-YzJhd0Kz.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,306 @@ 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].
+* The probe steps *inward* from a bound — `forwardKinematics` clamps each DOF to
+* its range, so a forward `+eps` at the upper limit would yield a zero column and
+* trap the solver at the ceiling. Stepping `-eps` there (and dividing by the
+* signed step) keeps every column a true one-sided derivative.
+*/
+function fillJacobian(J, q, n, m, lo, hi, base, tip, eps, tipPose) {
+	const basePos = applyPose(base, tip);
+	for (let j = 0; j < n; j++) {
+		const saved = el(q, j);
+		const h = saved + eps > el(hi, j) && saved - eps >= el(lo, j) ? -eps : eps;
+		q[j] = saved + h;
+		const p2 = tipPose(q);
+		q[j] = saved;
+		const pos2 = applyPose(p2, tip);
+		J[j] = (pos2[0] - basePos[0]) / h;
+		J[n + j] = (pos2[1] - basePos[1]) / h;
+		J[2 * n + j] = (pos2[2] - basePos[2]) / h;
+		if (m === 6) {
+			const dr = rotationError(base.rotation, p2.rotation);
+			J[3 * n + j] = dr[0] / h;
+			J[4 * n + j] = dr[1] / h;
+			J[5 * n + j] = dr[2] / h;
+		}
+	}
+}
+/** 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, lo, hi, 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 +1236,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/package.json

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