brepjs 18.78.1 → 18.80.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-a_C2wGGt.cjs");
+const require_threadFns = require("./threadFns-B7a1EVpS.cjs");
 const require_blueprintSketcher = require("./blueprintSketcher-BJPBKhF3.cjs");
 const require_helpers = require("./helpers-B8mE35Fm.cjs");
 const require_drawFns = require("./drawFns-DTpCthM5.cjs");
@@ -2132,94 +2132,6 @@ function roof(w, options) {
 	}
 }
 //#endregion
-//#region src/utils/quaternion.ts
-function dot$1(a, b) {
-	return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-}
-function cross$1(a, b) {
-	return [
-		a[1] * b[2] - a[2] * b[1],
-		a[2] * b[0] - a[0] * b[2],
-		a[0] * b[1] - a[1] * b[0]
-	];
-}
-function normalize$1(a) {
-	const l = Math.hypot(a[0], a[1], a[2]) || 1;
-	return [
-		a[0] / l,
-		a[1] / l,
-		a[2] / l
-	];
-}
-/** A unit vector perpendicular to `v` (for the 180°/parallel degenerate cases). */
-function anyPerpendicular$1(v) {
-	return normalize$1(cross$1(v, Math.abs(v[0]) < .9 ? [
-		1,
-		0,
-		0
-	] : [
-		0,
-		1,
-		0
-	]));
-}
-/** Rotate vector `v` by quaternion `q`. */
-function quatRotate(q, v) {
-	const [w, x, y, z] = q;
-	const tx = 2 * (y * v[2] - z * v[1]);
-	const ty = 2 * (z * v[0] - x * v[2]);
-	const tz = 2 * (x * v[1] - y * v[0]);
-	return [
-		v[0] + w * tx + (y * tz - z * ty),
-		v[1] + w * ty + (z * tx - x * tz),
-		v[2] + w * tz + (x * ty - y * tx)
-	];
-}
-/** Quaternion for a rotation of `angle` radians about (unit-normalized) `axis`. */
-function quatFromAxisAngle(axis, angle) {
-	const h = angle / 2;
-	const s = Math.sin(h);
-	const u = normalize$1(axis);
-	return [
-		Math.cos(h),
-		u[0] * s,
-		u[1] * s,
-		u[2] * s
-	];
-}
-/** Shortest-arc quaternion rotating unit vector `from` onto unit vector `to`. */
-function quatFromTo(from, to) {
-	const a = normalize$1(from);
-	const b = normalize$1(to);
-	const d = dot$1(a, b);
-	if (d >= .999999999) return [
-		1,
-		0,
-		0,
-		0
-	];
-	if (d <= -.999999999) return quatFromAxisAngle(anyPerpendicular$1(a), Math.PI);
-	const c = cross$1(a, b);
-	const len = Math.hypot(1 + d, c[0], c[1], c[2]) || 1;
-	return [
-		(1 + d) / len,
-		c[0] / len,
-		c[1] / len,
-		c[2] / len
-	];
-}
-/** Hamilton product `a ⊗ b` — the rotation that applies `b` first, then `a`. */
-function quatMultiply(a, b) {
-	const [aw, ax, ay, az] = a;
-	const [bw, bx, by, bz] = b;
-	return [
-		aw * bw - ax * bx - ay * by - az * bz,
-		aw * bx + ax * bw + ay * bz - az * by,
-		aw * by - ax * bz + ay * bw + az * bx,
-		aw * bz + ax * by - ay * bx + az * bw
-	];
-}
-//#endregion
 //#region src/kernel/solverAdapter.ts
 /**
 * Constraint solver adapter — analytical solver for simple assembly mates.
@@ -2297,12 +2209,12 @@ function anyPerpendicular(v) {
 }
 /** Apply a pose (rotate then translate) to an entity's origin and any directions. */
 function transformEntity(e, pose) {
-	const origin = add$1(quatRotate(pose.rotation, e.origin), pose.position);
+	const origin = add$1(require_threadFns.quatRotate(pose.rotation, e.origin), pose.position);
 	return {
 		type: e.type,
 		origin,
-		...e.normal ? { normal: quatRotate(pose.rotation, e.normal) } : {},
-		...e.direction ? { direction: quatRotate(pose.rotation, e.direction) } : {}
+		...e.normal ? { normal: require_threadFns.quatRotate(pose.rotation, e.normal) } : {},
+		...e.direction ? { direction: require_threadFns.quatRotate(pose.rotation, e.direction) } : {}
 	};
 }
 /**
@@ -2336,12 +2248,12 @@ function solveConcentric(ref, dep) {
 		0,
 		1
 	];
-	const rotation = quatFromTo(dep.direction ?? [
+	const rotation = require_threadFns.quatFromTo(dep.direction ?? [
 		0,
 		0,
 		1
 	], dRef);
-	const rotatedOrigin = quatRotate(rotation, dep.origin);
+	const rotatedOrigin = require_threadFns.quatRotate(rotation, dep.origin);
 	return {
 		position: sub(ref.origin, rotatedOrigin),
 		rotation
@@ -2371,13 +2283,125 @@ function solveAngle(ref, dep, angleRad) {
 			0,
 			0
 		],
-		rotation: quatFromAxisAngle(Math.hypot(c[0], c[1], c[2]) < 1e-9 ? anyPerpendicular(nDep) : c, phi - angleRad)
+		rotation: require_threadFns.quatFromAxisAngle(Math.hypot(c[0], c[1], c[2]) < 1e-9 ? anyPerpendicular(nDep) : c, phi - angleRad)
+	};
+}
+/**
+* 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
 	};
 }
-/** Entity types each positioning constraint requires of (entityA, entityB). */
+/**
+* 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"
 };
@@ -2387,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
@@ -2428,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);
@@ -2619,191 +2674,6 @@ function solveAssembly(assembly) {
 	}
 }
 //#endregion
-//#region src/operations/jointFns.ts
-var DEG2RAD$1 = Math.PI / 180;
-function clamp(value, min, max) {
-	return Math.min(max, Math.max(min, value));
-}
-function unit(v) {
-	const l = Math.hypot(v[0], v[1], v[2]) || 1;
-	return [
-		v[0] / l,
-		v[1] / l,
-		v[2] / l
-	];
-}
-function makeJoint(type, parent, child, axis, opts, defMin, defMax) {
-	const a = opts.min ?? defMin;
-	const b = opts.max ?? defMax;
-	const min = Math.min(a, b);
-	const max = Math.max(a, b);
-	return {
-		type,
-		parent,
-		child,
-		axis: {
-			origin: axis.origin,
-			direction: unit(axis.direction)
-		},
-		min,
-		max,
-		value: clamp(opts.value ?? 0, min, max)
-	};
-}
-/** A revolute (hinge) joint — the child rotates about `axis` by `value` degrees. */
-function revoluteJoint(parent, child, axis, opts = {}) {
-	return makeJoint("revolute", parent, child, axis, opts, -180, 180);
-}
-/**
-* A prismatic (slider) joint — the child translates along `axis` by `value`
-* units. Only `axis.direction` is used; `axis.origin` is ignored (a pure
-* translation has no anchor point), unlike a revolute joint which rotates about
-* the axis line through `origin`.
-*/
-function prismaticJoint(parent, child, axis, opts = {}) {
-	return makeJoint("prismatic", parent, child, axis, opts, 0, 100);
-}
-/** Return a copy of `joint` with its drivable parameter set (clamped to range). */
-function setJointValue(joint, value) {
-	return {
-		...joint,
-		value: clamp(value, joint.min, joint.max)
-	};
-}
-/**
-* The child's local rigid transform (relative to the parent) for a joint value.
-* Defaults to the joint's stored value; an explicit value is clamped to range.
-*
-* - **revolute**: rotation of `value` degrees about the axis line. Rotating
-*   about a line through `origin` is `p ↦ R·p + (origin − R·origin)`.
-* - **prismatic**: translation of `value` units along the axis direction.
-*/
-function jointTransform(joint, value = joint.value) {
-	const v = clamp(value, joint.min, joint.max);
-	const dir = unit(joint.axis.direction);
-	if (joint.type === "prismatic") return {
-		position: [
-			dir[0] * v,
-			dir[1] * v,
-			dir[2] * v
-		],
-		rotation: [
-			1,
-			0,
-			0,
-			0
-		]
-	};
-	const rotation = quatFromAxisAngle(dir, v * DEG2RAD$1);
-	const o = joint.axis.origin;
-	const ro = quatRotate(rotation, o);
-	return {
-		position: [
-			o[0] - ro[0],
-			o[1] - ro[1],
-			o[2] - ro[2]
-		],
-		rotation
-	};
-}
-/** Attach a joint to an assembly node. Returns a new node (immutable). */
-function addJoint(assembly, joint) {
-	const existing = assembly.joints ?? [];
-	return {
-		...assembly,
-		joints: [...existing, joint]
-	};
-}
-var IDENTITY_POSE = {
-	position: [
-		0,
-		0,
-		0
-	],
-	rotation: [
-		1,
-		0,
-		0,
-		0
-	]
-};
-/** Compose two poses: the result applies `b` in `a`'s frame (`a ∘ b`). */
-function composePose(a, b) {
-	const rb = quatRotate(a.rotation, b.position);
-	return {
-		position: [
-			a.position[0] + rb[0],
-			a.position[1] + rb[1],
-			a.position[2] + rb[2]
-		],
-		rotation: quatMultiply(a.rotation, b.rotation)
-	};
-}
-/** Collect every joint attached anywhere in the assembly tree. */
-function collectJoints(assembly) {
-	const joints = [];
-	require_threadFns.walkAssembly(assembly, (node) => {
-		if (node.joints) joints.push(...node.joints);
-	});
-	return joints;
-}
-/**
-* Forward kinematics: set joint values and propagate world poses down the
-* kinematic chain. Each joint's axis is interpreted in its **parent's** frame,
-* so a child's world pose is `parentWorld ∘ jointTransform(joint, value)`.
-*
-* Bodies not driven by a joint (chain roots) start at the origin. `jointValues`
-* overrides a joint's stored value, keyed by the **child** node name; omitted
-* joints use `joint.value`. Resolution is topological (reuses the Phase-0
-* ordering), so chains of any depth compose. Returns a world pose for every node.
-*/
-function forwardKinematics(assembly, jointValues = {}) {
-	const joints = [];
-	const names = /* @__PURE__ */ new Set();
-	require_threadFns.walkAssembly(assembly, (node) => {
-		names.add(node.name);
-		if (node.joints) joints.push(...node.joints);
-	});
-	const byChild = /* @__PURE__ */ new Map();
-	for (const j of joints) {
-		byChild.set(j.child, j);
-		names.add(j.parent);
-		names.add(j.child);
-	}
-	const poses = /* @__PURE__ */ new Map();
-	for (const name of names) if (!byChild.has(name)) poses.set(name, IDENTITY_POSE);
-	const pending = [...joints];
-	let progress = true;
-	while (progress && pending.length > 0) {
-		progress = false;
-		for (let i = pending.length - 1; i >= 0; i--) {
-			const j = pending[i];
-			if (!j) continue;
-			const parentPose = poses.get(j.parent);
-			if (!parentPose) continue;
-			pending.splice(i, 1);
-			progress = true;
-			if (poses.has(j.child)) continue;
-			const value = jointValues[j.child] ?? j.value;
-			poses.set(j.child, composePose(parentPose, jointTransform(j, value)));
-		}
-	}
-	for (const j of pending) if (!poses.has(j.child)) poses.set(j.child, IDENTITY_POSE);
-	return poses;
-}
-var JOINT_FREEDOM = {
-	revolute: 1,
-	prismatic: 1
-};
-/**
-* Open-chain mobility — the number of independent degrees of freedom. Each
-* revolute/prismatic joint contributes 1, so for a serial chain this equals the
-* joint count. (Closed-loop Grübler/Kutzbach analysis is future work.)
-*/
-function mechanismDOF(assembly) {
-	return collectJoints(assembly).reduce((sum, j) => sum + JOINT_FREEDOM[j.type], 0);
-}
-//#endregion
 //#region src/measurement/interferenceFns.ts
 /**
 * Interference detection between shapes.
@@ -6602,7 +6472,7 @@ exports.Sketcher = require_drawFns.Sketcher;
 exports.Sketches = require_textBlueprints.Sketches;
 exports.addChild = require_threadFns.addChild;
 exports.addHoles = require_primitiveFns.addHoles;
-exports.addJoint = addJoint;
+exports.addJoint = require_threadFns.addJoint;
 exports.addMate = addMate;
 exports.addStep = require_threadFns.addStep;
 exports.adjacentFaces = require_healingFns.adjacentFaces;
@@ -6726,6 +6596,7 @@ exports.cutAllBisect = require_healingFns.cutAllBisect;
 exports.cutBlueprints = require_boolean2D.cutBlueprints;
 exports.cutWithEvolution = require_healingFns.cutWithEvolution;
 exports.cylinder = require_primitiveFns.cylinder;
+exports.cylindricalJoint = require_threadFns.cylindricalJoint;
 exports.defaultScorer = require_shapeRefFns.defaultScorer;
 exports.dequeueTask = require_workerHandler.dequeueTask;
 exports.describe = describe;
@@ -6799,7 +6670,7 @@ exports.flatten = require_errors.flatten;
 exports.flipFaceOrientation = require_faceFns.flipFaceOrientation;
 exports.flipOrientation = require_curveFns.flipOrientation;
 exports.fontMetrics = require_textMetrics.fontMetrics;
-exports.forwardKinematics = forwardKinematics;
+exports.forwardKinematics = require_threadFns.forwardKinematics;
 exports.fromBREP = fromBREP$1;
 exports.fromKernelDir = fromKernelDir;
 exports.fromKernelPnt = fromKernelPnt;
@@ -6922,7 +6793,7 @@ exports.iterSolids = require_topologyQueryFns.iterSolids;
 exports.iterTopo = require_faceFns.iterTopo;
 exports.iterVertices = require_topologyQueryFns.iterVertices;
 exports.iterWires = require_topologyQueryFns.iterWires;
-exports.jointTransform = jointTransform;
+exports.jointTransform = require_threadFns.jointTransform;
 exports.kernelCall = require_topologyQueryFns.kernelCall;
 exports.kernelCallRaw = require_topologyQueryFns.kernelCallRaw;
 exports.kernelCallScoped = require_topologyQueryFns.kernelCallScoped;
@@ -6961,7 +6832,7 @@ Object.defineProperty(exports, "measurement", {
 		return measurement_exports;
 	}
 });
-exports.mechanismDOF = mechanismDOF;
+exports.mechanismDOF = require_threadFns.mechanismDOF;
 exports.mesh = mesh;
 exports.meshEdges = meshEdges;
 exports.meshMultiLOD = require_meshFns.meshMultiLOD;
@@ -7001,6 +6872,7 @@ exports.pendingCount = require_workerHandler.pendingCount;
 exports.pipeline = require_errors.pipeline;
 exports.pivotPlane = require_planeOps.pivotPlane;
 exports.planarFace = require_shapeTypes.planarFace;
+exports.planarJoint = require_threadFns.planarJoint;
 exports.planarWire = require_shapeTypes.planarWire;
 exports.planetPlacements = planetPlacements;
 exports.pocket = pocket;
@@ -7018,7 +6890,7 @@ Object.defineProperty(exports, "primitives", {
 		return primitives_exports;
 	}
 });
-exports.prismaticJoint = prismaticJoint;
+exports.prismaticJoint = require_threadFns.prismaticJoint;
 exports.projectEdges = require_cameraFns.projectEdges;
 exports.projectPointOnFace = require_faceFns.projectPointOnFace;
 Object.defineProperty(exports, "query", {
@@ -7050,7 +6922,7 @@ exports.resolveDirection = require_types.resolveDirection;
 exports.resolvePlane = require_planeOps.resolvePlane;
 exports.resolveRef = require_shapeRefFns.resolveRef;
 exports.reverseCurve = require_blueprintFns.reverseCurve;
-exports.revoluteJoint = revoluteJoint;
+exports.revoluteJoint = require_threadFns.revoluteJoint;
 exports.revolve = revolve;
 exports.roof = roof;
 exports.rotate = rotate;
@@ -7079,7 +6951,8 @@ exports.sdfTorus = torus;
 exports.section = section;
 exports.sectionToFace = sectionToFace;
 exports.serializeHistory = require_threadFns.serializeHistory;
-exports.setJointValue = setJointValue;
+exports.setJointValue = require_threadFns.setJointValue;
+exports.setJointValues = require_threadFns.setJointValues;
 exports.setShapeOrigin = require_shapeFns.setShapeOrigin;
 exports.setTagMetadata = require_shapeFns.setTagMetadata;
 exports.sewShells = require_primitiveFns.sewShells;
@@ -7115,6 +6988,7 @@ exports.solid = require_primitiveFns.solid;
 exports.solidFromShell = require_healingFns.solidFromShell;
 exports.solveAssembly = solveAssembly;
 exports.sphere = require_primitiveFns.sphere;
+exports.sphericalJoint = require_threadFns.sphericalJoint;
 exports.split = split;
 exports.stepCount = require_threadFns.stepCount;
 exports.stepsFrom = require_threadFns.stepsFrom;