jscad-electronics 0.0.183 → 0.0.185

package/dist/vanilla.d.ts

@@ -1,7 +1,7 @@
 import { BufferGeometry } from 'three';
 import * as jscadModeling from '@jscad/modeling';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { NemaMotorModelPropsInput, HexSocketBoltModelPropsInput, SheetMetalModelPropsInput } from '@tscircuit/modelprinter';
+import { NemaMotorModelPropsInput, HexSocketBoltModelPropsInput, SheetMetalModelPropsInput, SpurGearModelPropsInput, WormGearModelPropsInput } from '@tscircuit/modelprinter';
 import * as _jscad_modeling_src_geometries_types from '@jscad/modeling/src/geometries/types';
 
 type VNode = {
@@ -78,6 +78,48 @@ type SheetMetalProps = SheetMetalModelPropsInput & {
 declare function createSheetMetalGeom(input: SheetMetalModelPropsInput): _jscad_modeling_src_geometries_types.Geom3;
 declare function SheetMetal({ color, ...props }: SheetMetalProps): react_jsx_runtime.JSX.Element;
 
+/** Indexed triangles, counterclockwise from outside; millimeters, Z up. */
+interface SpurGearMesh {
+    positions: number[];
+    indices: number[];
+}
+/**
+ * An external involute spur gear with its lower face at Z=0. Tooth centers
+ * start on +X and rotate counterclockwise with phase. The optional hub extends
+ * above the upper face, and the round bore passes through both gear and hub.
+ * Flanks are sampled involutes; tips and root valleys follow circular arcs.
+ * Below the base circle the flanks extend radially, without a generated
+ * trochoidal root fillet or cutter undercut. No CSG or renderer is required.
+ */
+declare function createSpurGearMesh(input: SpurGearModelPropsInput): SpurGearMesh;
+
+type SpurGearProps = SpurGearModelPropsInput & {
+    color?: string;
+};
+/** Axis +Z, lower face Z=0; optional hub extends above the gear face. */
+declare function createSpurGearGeom(input: SpurGearModelPropsInput): _jscad_modeling_src_geometries_types.Geom3;
+declare function SpurGear({ color, ...props }: SpurGearProps): react_jsx_runtime.JSX.Element;
+
+/** Indexed triangles, counterclockwise from outside; millimeters, Z up. */
+interface WormGearMesh {
+    positions: number[];
+    indices: number[];
+}
+/**
+ * A cylindrical worm from Z=0 to Z=length, with square-cut ends.
+ * The axial trapezoidal rack profile is swept around +Z. A right-hand crest
+ * winds counterclockwise as Z increases; phase rotates the entire solid.
+ * This is a faceted visual worm, not a hobbed wheel or a conjugate gear pair.
+ */
+declare const createWormGearMesh: (input: WormGearModelPropsInput) => WormGearMesh;
+
+type WormGearProps = WormGearModelPropsInput & {
+    color?: string;
+};
+/** Square-cut worm along +Z, from Z=0 to length. Threads are approximate. */
+declare function createWormGearGeom(input: WormGearModelPropsInput): _jscad_modeling_src_geometries_types.Geom3;
+declare function WormGear({ color, ...props }: WormGearProps): react_jsx_runtime.JSX.Element;
+
 declare function getJscadModelForFootprint(footprint: string, jscad: typeof jscadModeling): RenderResult;
 declare function getJscadModelForFootprintWithPads(footprint: string, jscad: typeof jscadModeling): RenderResult;
 declare function createJSCADRenderer(jscad: typeof jscadModeling): {
@@ -86,4 +128,4 @@ declare function createJSCADRenderer(jscad: typeof jscadModeling): {
     };
 };
 
-export { type ColoredGeom, Fragment, HexSocketBolt, type HexSocketBoltMesh, type HexSocketBoltProps, NEMA17, NEMA23, NEMA8, type NemaFrameMotorProps, NemaMotor, type NemaMotorProps, type RenderResult, SheetMetal, type SheetMetalMesh, type SheetMetalProps, type VNode, convertCSGToThreeGeom, createHexSocketBoltGeom, createHexSocketBoltMesh, createJSCADRenderer, createSheetMetalGeom, createSheetMetalMesh, getJscadModelForFootprint, getJscadModelForFootprintWithPads, h };
+export { type ColoredGeom, Fragment, HexSocketBolt, type HexSocketBoltMesh, type HexSocketBoltProps, NEMA17, NEMA23, NEMA8, type NemaFrameMotorProps, NemaMotor, type NemaMotorProps, type RenderResult, SheetMetal, type SheetMetalMesh, type SheetMetalProps, SpurGear, type SpurGearMesh, type SpurGearProps, type VNode, WormGear, type WormGearMesh, type WormGearProps, convertCSGToThreeGeom, createHexSocketBoltGeom, createHexSocketBoltMesh, createJSCADRenderer, createSheetMetalGeom, createSheetMetalMesh, createSpurGearGeom, createSpurGearMesh, createWormGearGeom, createWormGearMesh, getJscadModelForFootprint, getJscadModelForFootprintWithPads, h };

package/dist/vanilla.js

@@ -172,7 +172,7 @@ var ExtrudedPads = ({
   circuitJson,
   footprint
 }) => {
-  if (!circuitJson && footprint && ["nema", "hexsocketbolt", "sheetmetal"].includes(
+  if (!circuitJson && footprint && ["nema", "hexsocketbolt", "sheetmetal", "spurgear", "wormgear"].includes(
     mp.string(footprint.split("_", 1)[0]).params().fn
   )) {
     mp.string(footprint).json();
@@ -218,7 +218,7 @@ var createHexSocketBoltMesh = (input) => {
   } = hexSocketBoltDimensions[props.metricSize];
   const { length, showThreads } = props;
   const segments = 96;
-  const steps = Math.max(2, Math.ceil(length / pitch * 24));
+  const steps = showThreads ? Math.max(2, Math.ceil(length / pitch * 24)) : 2;
   if (steps > 24e3)
     throw new Error(
       "Bolt length exceeds mesh resolution limit (1000 thread turns)"
@@ -254,8 +254,11 @@ var createHexSocketBoltMesh = (input) => {
     }
   };
   let previous = -1;
-  for (let step = 0; step <= steps; step++) {
-    const z = -length + length * step / steps;
+  const shaftLevels = showThreads ? Array.from(
+    { length: steps + 1 },
+    (_, step) => -length + length * step / steps
+  ) : [-length, -length + tipBevel, 0];
+  for (const z of shaftLevels) {
     const current = ring(z, (angle) => {
       const phase = ((z / pitch - angle / (2 * Math.PI)) % 1 + 1) % 1;
       const distance2 = Math.min(phase, 1 - phase);
@@ -471,8 +474,357 @@ function SheetMetal({ color = "#737e8f", ...props }) {
   return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createSheetMetalGeom(props) }) });
 }
 
+// lib/mechanical/spur-gear-mesh.ts
+import {
+  getSpurGearDimensions,
+  spurGearModelPropsSchema
+} from "@tscircuit/modelprinter";
+import earcut2 from "earcut";
+function createSpurGearMesh(input) {
+  const props = spurGearModelPropsSchema.parse(input);
+  const dimensions = getSpurGearDimensions(props);
+  const pitchRadius = dimensions.pitchDiameter / 2;
+  const baseRadius = dimensions.baseDiameter / 2;
+  const outsideRadius = dimensions.outsideDiameter / 2;
+  const rootRadius = dimensions.rootDiameter / 2;
+  const pressureAngle = props.pressureAngle * Math.PI / 180;
+  const toothAngle = Math.PI * 2 / props.toothCount;
+  const phase = (props.phase % 360 + 360) % 360 * (Math.PI / 180);
+  const baseHalfAngle = dimensions.toothThickness / (2 * pitchRadius) + Math.tan(pressureAngle) - pressureAngle;
+  const startRadius = Math.max(baseRadius, rootRadius);
+  const startT = Math.sqrt(Math.max(0, (startRadius / baseRadius) ** 2 - 1));
+  const outsideT = Math.sqrt((outsideRadius / baseRadius) ** 2 - 1);
+  const halfAngle = (t) => baseHalfAngle - (t - Math.atan(t));
+  const rootHalfAngle = halfAngle(startT);
+  const tipHalfAngle = halfAngle(outsideT);
+  const flankSteps = Math.max(2, Math.ceil(props.segmentsPerTooth / 2));
+  const arcSteps = Math.max(1, Math.ceil(props.segmentsPerTooth / 4));
+  const rootValleyAngle = toothAngle - 2 * rootHalfAngle;
+  const innerRadius = Math.max(props.boreDiameter, props.hubDiameter) / 2;
+  const safeRootStep = innerRadius > 0 ? 1.8 * Math.acos(innerRadius / rootRadius) : Math.PI;
+  const rootArcSteps = Math.max(
+    arcSteps,
+    Math.ceil(rootValleyAngle / safeRootStep)
+  );
+  const pointsPerTooth = 2 * flankSteps + arcSteps + rootArcSteps + (rootRadius < baseRadius ? 2 : 0);
+  if (!Number.isFinite(rootArcSteps) || 2 * props.toothCount * pointsPerTooth + 1024 > 1e6)
+    throw new Error(
+      "Spur gear bore or hub clearance exceeds mesh resolution limit (1 million vertices)"
+    );
+  const outline = [];
+  const polar = (radius, angle) => {
+    outline.push([radius * Math.cos(angle), radius * Math.sin(angle)]);
+  };
+  for (let tooth = 0; tooth < props.toothCount; tooth++) {
+    const center = phase + tooth * toothAngle;
+    polar(rootRadius, center - rootHalfAngle);
+    if (rootRadius < baseRadius) polar(baseRadius, center - baseHalfAngle);
+    for (let step = 1; step <= flankSteps; step++) {
+      const t = startT + (outsideT - startT) * step / flankSteps;
+      polar(baseRadius * Math.sqrt(1 + t * t), center - halfAngle(t));
+    }
+    for (let step = 1; step <= arcSteps; step++)
+      polar(
+        outsideRadius,
+        center - tipHalfAngle + 2 * tipHalfAngle * step / arcSteps
+      );
+    for (let step = flankSteps - 1; step >= 0; step--) {
+      const t = startT + (outsideT - startT) * step / flankSteps;
+      polar(baseRadius * Math.sqrt(1 + t * t), center + halfAngle(t));
+    }
+    if (rootRadius < baseRadius) polar(rootRadius, center + baseHalfAngle);
+    for (let step = 1; step < rootArcSteps; step++)
+      polar(
+        rootRadius,
+        center + rootHalfAngle + rootValleyAngle * step / rootArcSteps
+      );
+  }
+  const positions = [];
+  const indices = [];
+  const ring = (points, z) => {
+    const start = positions.length / 3;
+    for (const [x, y] of points) positions.push(x, y, z);
+    return start;
+  };
+  const circleSegments = Math.max(48, Math.min(256, props.toothCount * 4));
+  const circle2 = (radius) => Array.from({ length: circleSegments }, (_, segment) => {
+    const angle = phase + segment * Math.PI * 2 / circleSegments;
+    return [radius * Math.cos(angle), radius * Math.sin(angle)];
+  });
+  const connect = (bottom2, top2, count, inward = false) => {
+    for (let i = 0; i < count; i++) {
+      const next = (i + 1) % count;
+      if (inward)
+        indices.push(
+          bottom2 + i,
+          top2 + next,
+          bottom2 + next,
+          bottom2 + i,
+          top2 + i,
+          top2 + next
+        );
+      else
+        indices.push(
+          bottom2 + i,
+          bottom2 + next,
+          top2 + next,
+          bottom2 + i,
+          top2 + next,
+          top2 + i
+        );
+    }
+  };
+  const cap = (outer, outerStart, upward, inner) => {
+    const points = inner ? [...outer, ...inner.points] : outer;
+    const triangles = earcut2(
+      points.flatMap(([x, y]) => [x, y]),
+      inner ? [outer.length] : []
+    );
+    const vertex = (index) => index < outer.length ? outerStart + index : inner.start + index - outer.length;
+    for (let i = 0; i < triangles.length; i += 3) {
+      const a = triangles[i];
+      const b = triangles[i + 1];
+      const c = triangles[i + 2];
+      const pa = points[a];
+      const pb = points[b];
+      const pc = points[c];
+      const area = (pb[0] - pa[0]) * (pc[1] - pa[1]) - (pb[1] - pa[1]) * (pc[0] - pa[0]);
+      if (area > 0 === upward) indices.push(vertex(a), vertex(b), vertex(c));
+      else indices.push(vertex(a), vertex(c), vertex(b));
+    }
+  };
+  const bottom = ring(outline, 0);
+  const top = ring(outline, props.faceWidth);
+  connect(bottom, top, outline.length);
+  const hasHub = props.hubDiameter > 0 && props.hubLength > 0;
+  const height10 = props.faceWidth + (hasHub ? props.hubLength : 0);
+  const bore = props.boreDiameter > 0 ? circle2(props.boreDiameter / 2) : void 0;
+  const boreBottom = bore ? ring(bore, 0) : void 0;
+  const boreTop = bore ? ring(bore, height10) : void 0;
+  if (bore) connect(boreBottom, boreTop, bore.length, true);
+  cap(
+    outline,
+    bottom,
+    false,
+    bore ? { points: bore, start: boreBottom } : void 0
+  );
+  if (hasHub) {
+    const hub = circle2(props.hubDiameter / 2);
+    const hubBottom = ring(hub, props.faceWidth);
+    const hubTop = ring(hub, height10);
+    cap(outline, top, true, { points: hub, start: hubBottom });
+    connect(hubBottom, hubTop, hub.length);
+    if (bore) connect(hubTop, boreTop, hub.length);
+    else cap(hub, hubTop, true);
+  } else
+    cap(
+      outline,
+      top,
+      true,
+      bore ? { points: bore, start: boreTop } : void 0
+    );
+  return { positions, indices };
+}
+
+// lib/SpurGear.tsx
+function createSpurGearGeom(input) {
+  return indexedMeshToGeom3(createSpurGearMesh(input));
+}
+function SpurGear({ color = "#737e8f", ...props }) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createSpurGearGeom(props) }) });
+}
+
+// lib/mechanical/worm-gear-mesh.ts
+import {
+  getWormGearDimensions,
+  wormGearModelPropsSchema
+} from "@tscircuit/modelprinter";
+import earcut3 from "earcut";
+var createWormGearMesh = (input) => {
+  const props = wormGearModelPropsSchema.parse(input);
+  const { outsideDiameter, rootDiameter, axialPitch, lead, toothThickness } = getWormGearDimensions(props);
+  const outsideRadius = outsideDiameter / 2;
+  const rootRadius = rootDiameter / 2;
+  const pitchRadius = props.pitchDiameter / 2;
+  const pressureTangent = Math.tan(props.pressureAngle * Math.PI / 180);
+  const tipHalfWidth = toothThickness / 2 - props.module * pressureTangent;
+  const rootHalfWidth = toothThickness / 2 + (props.module + props.clearance) * pressureTangent;
+  const boreRadius = props.boreDiameter / 2;
+  const angularStepLimit = boreRadius > 0 ? Math.acos(boreRadius / rootRadius) * 0.8 : Infinity;
+  const samplesPerPitch = Math.max(
+    Math.ceil(props.radialSegments / props.starts),
+    Math.ceil(Math.PI * 2 / (props.starts * angularStepLimit))
+  );
+  const stepsPerTurn = Math.max(
+    props.segmentsPerTurn,
+    props.radialSegments,
+    props.starts * 12,
+    Math.ceil(Math.PI * 2 / angularStepLimit)
+  );
+  const steps = Math.max(1, Math.ceil(props.length / lead * stepsPerTurn));
+  const extraVertices = boreRadius > 0 ? props.radialSegments * 2 : 2;
+  if (!Number.isFinite(samplesPerPitch) || !Number.isFinite(steps) || (steps + 1) * (samplesPerPitch + 6) * props.starts + extraVertices > 1e6) {
+    throw new Error(
+      "Worm gear exceeds mesh resolution limit (1000000 vertices); reduce length or resolution, or increase module or bore wall thickness"
+    );
+  }
+  const corners = [
+    0,
+    tipHalfWidth / axialPitch,
+    toothThickness / (2 * axialPitch),
+    rootHalfWidth / axialPitch,
+    1 - rootHalfWidth / axialPitch,
+    1 - toothThickness / (2 * axialPitch),
+    1 - tipHalfWidth / axialPitch,
+    1
+  ];
+  const fractions = [];
+  for (let index = 0; index < corners.length - 1; index++) {
+    const from = corners[index];
+    const width10 = corners[index + 1] - from;
+    const subdivisions = Math.max(1, Math.ceil(width10 * samplesPerPitch));
+    for (let subdivision = 0; subdivision < subdivisions; subdivision++) {
+      const fraction = from + width10 * subdivision / subdivisions;
+      if (fractions.length === 0 || fraction - fractions[fractions.length - 1] > 1e-12)
+        fractions.push(fraction);
+    }
+  }
+  const profile = [];
+  for (let start = 0; start < props.starts; start++) {
+    for (const fraction of fractions) {
+      const distance2 = Math.min(fraction, 1 - fraction) * axialPitch;
+      profile.push({
+        angle: (start + fraction) * Math.PI * 2 / props.starts,
+        radius: distance2 <= tipHalfWidth ? outsideRadius : distance2 >= rootHalfWidth ? rootRadius : pitchRadius + (toothThickness / 2 - distance2) / pressureTangent
+      });
+    }
+  }
+  const count = profile.length;
+  const positions = [];
+  const indices = [];
+  const phase = props.phase % 360 * Math.PI / 180;
+  const direction = props.handedness === "right" ? 1 : -1;
+  const ring = (z) => {
+    const first = positions.length / 3;
+    const rotation = phase + direction * (z / lead) * Math.PI * 2;
+    for (const sample of profile) {
+      const angle = sample.angle + rotation;
+      positions.push(
+        sample.radius * Math.cos(angle),
+        sample.radius * Math.sin(angle),
+        z
+      );
+    }
+    return first;
+  };
+  const connect = (lower, upper) => {
+    for (let index = 0; index < count; index++) {
+      const next = (index + 1) % count;
+      indices.push(
+        lower + index,
+        lower + next,
+        upper + next,
+        lower + index,
+        upper + next,
+        upper + index
+      );
+    }
+  };
+  const bottom = ring(0);
+  let previous = bottom;
+  for (let step = 1; step <= steps; step++) {
+    const current = ring(props.length * (step / steps));
+    connect(previous, current);
+    previous = current;
+  }
+  const top = previous;
+  if (props.boreDiameter === 0) {
+    const cap = (boundary, z, upward) => {
+      const center = positions.length / 3;
+      positions.push(0, 0, z);
+      for (let index = 0; index < count; index++) {
+        const next = (index + 1) % count;
+        indices.push(
+          center,
+          boundary + (upward ? index : next),
+          boundary + (upward ? next : index)
+        );
+      }
+    };
+    cap(bottom, 0, false);
+    cap(top, props.length, true);
+  } else {
+    const holeCount = props.radialSegments;
+    const boreRing = (z) => {
+      const first = positions.length / 3;
+      for (let index = 0; index < holeCount; index++) {
+        const angle = phase + index * Math.PI * 2 / holeCount;
+        positions.push(
+          boreRadius * Math.cos(angle),
+          boreRadius * Math.sin(angle),
+          z
+        );
+      }
+      return first;
+    };
+    const holeBottom = boreRing(0);
+    const holeTop = boreRing(props.length);
+    for (let index = 0; index < holeCount; index++) {
+      const next = (index + 1) % holeCount;
+      indices.push(
+        holeBottom + index,
+        holeTop + next,
+        holeBottom + next,
+        holeBottom + index,
+        holeTop + index,
+        holeTop + next
+      );
+    }
+    const cap = (boundary, hole, upward) => {
+      const vertices = Array.from(
+        { length: count },
+        (_, index) => boundary + index
+      );
+      vertices.push(
+        ...Array.from({ length: holeCount }, (_, index) => hole + index)
+      );
+      const flat = vertices.flatMap((vertex) => [
+        positions[vertex * 3],
+        positions[vertex * 3 + 1]
+      ]);
+      const triangles = earcut3(flat, [count], 2);
+      for (let index = 0; index < triangles.length; index += 3) {
+        const a = vertices[triangles[index]];
+        const b = vertices[triangles[index + 1]];
+        const c = vertices[triangles[index + 2]];
+        const signedArea = (positions[b * 3] - positions[a * 3]) * (positions[c * 3 + 1] - positions[a * 3 + 1]) - (positions[b * 3 + 1] - positions[a * 3 + 1]) * (positions[c * 3] - positions[a * 3]);
+        indices.push(
+          a,
+          signedArea > 0 === upward ? b : c,
+          signedArea > 0 === upward ? c : b
+        );
+      }
+    };
+    cap(bottom, holeBottom, false);
+    cap(top, holeTop, true);
+  }
+  return { positions, indices };
+};
+
+// lib/WormGear.tsx
+function createWormGearGeom(input) {
+  return indexedMeshToGeom3(createWormGearMesh(input));
+}
+function WormGear({ color = "#737e8f", ...props }) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createWormGearGeom(props) }) });
+}
+
 // lib/NemaMotor.tsx
+import jscad3 from "@jscad/modeling";
+
+// lib/utils/nemaMotorWireGeometry.ts
 import jscad2 from "@jscad/modeling";
+import { getNemaMotorReferencePoints } from "@tscircuit/modelprinter";
 
 // lib/utils/nemaMotorParameters.ts
 import { mp as mp2, nemaMotorModelPropsSchema } from "@tscircuit/modelprinter";
@@ -480,6 +832,66 @@ var resolveNemaMotorProps = nemaMotorModelPropsSchema.parse.bind(
   nemaMotorModelPropsSchema
 );
 
+// lib/utils/nemaMotorWireGeometry.ts
+function createNemaMotorWireGeometry(input) {
+  const p = resolveNemaMotorProps(input);
+  if (p.wireConnection === "none") return [];
+  const { position } = getNemaMotorReferencePoints(p).wireside;
+  const angle = p.wireSideAngle * Math.PI / 180;
+  const place = (geometry) => jscad2.transforms.translate(
+    [position.x, position.y, position.z],
+    jscad2.transforms.rotateZ(angle, geometry)
+  );
+  if (p.wireConnection === "stubs") {
+    const colors = [
+      "#d53f3f",
+      "#2463af",
+      "#3b934b",
+      "#252830",
+      "#e5d049",
+      "#eeeeee",
+      "#ce7432",
+      "#803e91"
+    ];
+    return Array.from({ length: p.wireCount }, (_, i) => ({
+      color: colors[i],
+      geometry: place(
+        jscad2.transforms.translate(
+          [
+            (p.wireLength - 0.15) / 2,
+            (i - (p.wireCount - 1) / 2) * p.wireDiameter * 1.5,
+            0
+          ],
+          jscad2.transforms.rotateY(
+            Math.PI / 2,
+            jscad2.primitives.cylinder({
+              height: p.wireLength + 0.15,
+              radius: p.wireDiameter / 2,
+              segments: 24
+            })
+          )
+        )
+      )
+    }));
+  }
+  const shell = jscad2.booleans.subtract(
+    jscad2.primitives.cuboid({ size: [6.1, 13.9, 4.5], center: [2.95, 0, 0] }),
+    jscad2.primitives.cuboid({ size: [5.5, 12.7, 3.3], center: [3.55, 0, 0] })
+  );
+  return [
+    { color: "#eeeeea", geometry: place(shell) },
+    ...Array.from({ length: 6 }, (_, i) => ({
+      color: "#b8bec6",
+      geometry: place(
+        jscad2.primitives.cuboid({
+          size: [3.4, 0.5, 0.5],
+          center: [1.7, (i - 2.5) * 2, 0]
+        })
+      )
+    }))
+  ];
+}
+
 // lib/utils/nemaMotorGeometry.ts
 var circle = (radius, x = 0, y = 0) => Array.from({ length: 96 }, (_, i) => [
   x + radius * Math.cos(i * Math.PI / 48),
@@ -579,6 +991,7 @@ function createNemaMotorSections(input) {
 }
 
 // lib/NemaMotor.tsx
+var generalize = jscad3.modifiers.generalize;
 function NemaMotor({
   bodyColor = "#242830",
   capColor = "#aeb5bd",
@@ -587,7 +1000,7 @@ function NemaMotor({
   ...props
 }) {
   const p = resolveNemaMotorProps(props);
-  const screw = p.backFace === "screws" ? jscad2.transforms.rotateX(
+  const screw = p.backFace === "screws" ? jscad3.transforms.rotateX(
     Math.PI,
     createHexSocketBoltGeom({
       metricSize: p.backFaceScrewSize,
@@ -598,14 +1011,14 @@ function NemaMotor({
   const halfPitch = p.backFaceHoleSpacing / 2;
   return /* @__PURE__ */ jsxs(Fragment2, { children: [
     createNemaMotorSections(p).map((section, index) => {
-      const outline = jscad2.geometries.geom2.fromPoints(section.outline);
-      const profile = section.holes.length ? jscad2.booleans.subtract(
+      const outline = jscad3.geometries.geom2.fromPoints(section.outline);
+      const profile = section.holes.length ? jscad3.booleans.subtract(
         outline,
-        ...section.holes.map((h2) => jscad2.geometries.geom2.fromPoints(h2))
+        ...section.holes.map((h2) => jscad3.geometries.geom2.fromPoints(h2))
       ) : outline;
-      const geometry = jscad2.transforms.translate(
+      const geometry = jscad3.transforms.translate(
         [0, 0, section.zMin],
-        jscad2.extrusions.extrudeLinear(
+        jscad3.extrusions.extrudeLinear(
           { height: section.zMax - section.zMin },
           profile
         )
@@ -614,18 +1027,19 @@ function NemaMotor({
         Colorize,
         {
           color: section.name === "body" ? bodyColor : section.name === "shaft" ? shaftColor : capColor,
-          children: /* @__PURE__ */ jsx(Custom, { geometry })
+          children: /* @__PURE__ */ jsx(Custom, { geometry: generalize({ simplify: true }, geometry) })
         },
         `${section.name}-${index}`
       );
     }),
+    createNemaMotorWireGeometry(p).map(({ geometry, color }, index) => /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: generalize({ simplify: true }, geometry) }) }, `wire-${index}`)),
     screw && [-halfPitch, halfPitch].flatMap(
       (x) => [-halfPitch, halfPitch].map((y) => /* @__PURE__ */ jsx(Colorize, { color: screwColor, children: /* @__PURE__ */ jsx(
         Custom,
         {
-          geometry: jscad2.transforms.translate(
+          geometry: jscad3.transforms.translate(
             [x, y, -p.bodyLength],
-            screw
+            generalize({ simplify: true }, screw)
           )
         }
       ) }, `rear-screw-${x}-${y}`))
@@ -8654,6 +9068,14 @@ var Footprinter3d = ({ footprint }) => {
         const { fn, ...props } = model;
         return /* @__PURE__ */ jsx(SheetMetal, { ...props });
       }
+      case "spurgear": {
+        const { fn, ...props } = model;
+        return /* @__PURE__ */ jsx(SpurGear, { ...props });
+      }
+      case "wormgear": {
+        const { fn, ...props } = model;
+        return /* @__PURE__ */ jsx(WormGear, { ...props });
+      }
       case "flexscreen": {
         const { fn: _, ...flexScreenProps } = model;
         return /* @__PURE__ */ jsx(FlexScreen, { ...flexScreenProps });
@@ -9460,8 +9882,8 @@ function renderNode(node, colorCtx, renderCtx) {
   }
   return (children ?? []).flatMap((c) => renderNode(c, colorCtx, renderCtx));
 }
-function render(root, jscad3) {
-  const geometries = renderNode(root, void 0, { jscad: jscad3 });
+function render(root, jscad4) {
+  const geometries = renderNode(root, void 0, { jscad: jscad4 });
   return { geometries };
 }
 
@@ -9549,24 +9971,24 @@ function convertCSGToThreeGeom(csg) {
 }
 
 // lib/vanilla/index.ts
-function getJscadModelForFootprint(footprint, jscad3) {
+function getJscadModelForFootprint(footprint, jscad4) {
   const vnode = h(Footprinter3d, { footprint });
-  return render(vnode, jscad3);
+  return render(vnode, jscad4);
 }
-function getJscadModelForFootprintWithPads(footprint, jscad3) {
+function getJscadModelForFootprintWithPads(footprint, jscad4) {
   const vnode = h(
     Fragment,
     {},
     h(Footprinter3d, { footprint }),
     h(ExtrudedPads, { footprint })
   );
-  return render(vnode, jscad3);
+  return render(vnode, jscad4);
 }
-function createJSCADRenderer(jscad3) {
+function createJSCADRenderer(jscad4) {
   function createJSCADRoot(container) {
     return {
       render(element) {
-        const { geometries } = render(element, jscad3);
+        const { geometries } = render(element, jscad4);
         container.splice(0, container.length, ...geometries);
       }
     };
@@ -9581,12 +10003,18 @@ export {
   NEMA8,
   NemaMotor,
   SheetMetal,
+  SpurGear,
+  WormGear,
   convertCSGToThreeGeom,
   createHexSocketBoltGeom,
   createHexSocketBoltMesh,
   createJSCADRenderer,
   createSheetMetalGeom,
   createSheetMetalMesh,
+  createSpurGearGeom,
+  createSpurGearMesh,
+  createWormGearGeom,
+  createWormGearMesh,
   getJscadModelForFootprint,
   getJscadModelForFootprintWithPads,
   h