jscad-electronics 0.0.184 → 0.0.186

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, HelicalGearModelPropsInput, WormGearModelPropsInput } from '@tscircuit/modelprinter';
 import * as _jscad_modeling_src_geometries_types from '@jscad/modeling/src/geometries/types';
 
 type VNode = {
@@ -78,6 +78,62 @@ 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 HelicalGearMesh = SpurGearMesh;
+/**
+ * Twisted transverse involute teeth from Z=0 to faceWidth, with a stationary
+ * round bore and optional hub. Zero helix angle reproduces the spur mesh.
+ */
+declare function createHelicalGearMesh(input: HelicalGearModelPropsInput): HelicalGearMesh;
+
+type HelicalGearProps = HelicalGearModelPropsInput & {
+    color?: string;
+};
+/** Axis +Z, lower face Z=0; optional hub extends above the gear face. */
+declare function createHelicalGearGeom(input: HelicalGearModelPropsInput): _jscad_modeling_src_geometries_types.Geom3;
+declare function HelicalGear({ color, ...props }: HelicalGearProps): react_jsx_runtime.JSX.Element;
+
+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 +142,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, HelicalGear, type HelicalGearMesh, type HelicalGearProps, 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, createHelicalGearGeom, createHelicalGearMesh, createHexSocketBoltGeom, createHexSocketBoltMesh, createJSCADRenderer, createSheetMetalGeom, createSheetMetalMesh, createSpurGearGeom, createSpurGearMesh, createWormGearGeom, createWormGearMesh, getJscadModelForFootprint, getJscadModelForFootprintWithPads, h };

package/dist/vanilla.js

@@ -172,9 +172,14 @@ var ExtrudedPads = ({
   circuitJson,
   footprint
 }) => {
-  if (!circuitJson && footprint && ["nema", "hexsocketbolt", "sheetmetal"].includes(
-    mp.string(footprint.split("_", 1)[0]).params().fn
-  )) {
+  if (!circuitJson && footprint && [
+    "nema",
+    "hexsocketbolt",
+    "sheetmetal",
+    "spurgear",
+    "wormgear",
+    "helicalgear"
+  ].includes(mp.string(footprint.split("_", 1)[0]).params().fn)) {
     mp.string(footprint).json();
     return null;
   }
@@ -201,6 +206,220 @@ var ExtrudedPads = ({
   ] });
 };
 
+// lib/mechanical/indexedMeshToGeom3.ts
+import jscad from "@jscad/modeling";
+function indexedMeshToGeom3(mesh) {
+  const polygons = [];
+  for (let i = 0; i < mesh.indices.length; i += 3)
+    polygons.push(
+      mesh.indices.slice(i, i + 3).map((index) => [
+        mesh.positions[index * 3],
+        mesh.positions[index * 3 + 1],
+        mesh.positions[index * 3 + 2]
+      ])
+    );
+  return jscad.geometries.geom3.fromPoints(polygons);
+}
+
+// lib/mechanical/helical-gear-mesh.ts
+import {
+  getHelicalGearDimensions,
+  helicalGearModelPropsSchema
+} from "@tscircuit/modelprinter";
+
+// lib/mechanical/spur-gear-mesh.ts
+import {
+  getSpurGearDimensions,
+  spurGearModelPropsSchema
+} from "@tscircuit/modelprinter";
+import earcut from "earcut";
+function createSpurGearMesh(input) {
+  return createTwistedSpurGearMesh(input);
+}
+function createTwistedSpurGearMesh(input, twist = 0, segmentsPerTurn = 32) {
+  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 ? (twist === 0 ? 1.8 : 0.8) * Math.acos(innerRadius / rootRadius) : Math.PI;
+  const rootArcSteps = Math.max(
+    arcSteps,
+    Math.ceil(rootValleyAngle / safeRootStep)
+  );
+  const twistStep = Math.min(
+    toothAngle / 16,
+    2 * Math.PI / segmentsPerTurn,
+    safeRootStep
+  );
+  const layers = Math.max(1, Math.ceil(Math.abs(twist) / twistStep));
+  const pointsPerTooth = 2 * flankSteps + arcSteps + rootArcSteps + (rootRadius < baseRadius ? 2 : 0);
+  if (!Number.isFinite(rootArcSteps) || !Number.isFinite(layers) || (layers + 1) * props.toothCount * pointsPerTooth + 1024 > 1e6)
+    throw new Error(
+      "Involute gear exceeds mesh resolution limit (1 million vertices); reduce twist or resolution, or increase bore/hub wall thickness"
+    );
+  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 = earcut(
+      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);
+  let top = bottom;
+  let topOutline = outline;
+  for (let layer = 1; layer <= layers; layer++) {
+    const angle = twist * (layer / layers);
+    topOutline = twist === 0 ? outline : outline.map(
+      ([x, y]) => [
+        x * Math.cos(angle) - y * Math.sin(angle),
+        x * Math.sin(angle) + y * Math.cos(angle)
+      ]
+    );
+    const next = ring(topOutline, props.faceWidth * (layer / layers));
+    connect(top, next, outline.length);
+    top = next;
+  }
+  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(topOutline, 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(
+      topOutline,
+      top,
+      true,
+      bore ? { points: bore, start: boreTop } : void 0
+    );
+  return { positions, indices };
+}
+
+// lib/mechanical/helical-gear-mesh.ts
+function createHelicalGearMesh(input) {
+  const props = helicalGearModelPropsSchema.parse(input);
+  const { twistAngle } = getHelicalGearDimensions(props);
+  const { helixAngle, handedness, segmentsPerTurn, ...spur } = props;
+  return createTwistedSpurGearMesh(
+    spur,
+    twistAngle * Math.PI / 180,
+    segmentsPerTurn
+  );
+}
+
+// lib/HelicalGear.tsx
+function createHelicalGearGeom(input) {
+  return indexedMeshToGeom3(createHelicalGearMesh(input));
+}
+function HelicalGear({ color = "#737e8f", ...props }) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createHelicalGearGeom(props) }) });
+}
+
 // lib/mechanical/hex-socket-bolt-mesh.ts
 import {
   hexSocketBoltDimensions,
@@ -295,21 +514,6 @@ var createHexSocketBoltMesh = (input) => {
   return { positions, indices };
 };
 
-// lib/mechanical/indexedMeshToGeom3.ts
-import jscad from "@jscad/modeling";
-function indexedMeshToGeom3(mesh) {
-  const polygons = [];
-  for (let i = 0; i < mesh.indices.length; i += 3)
-    polygons.push(
-      mesh.indices.slice(i, i + 3).map((index) => [
-        mesh.positions[index * 3],
-        mesh.positions[index * 3 + 1],
-        mesh.positions[index * 3 + 2]
-      ])
-    );
-  return jscad.geometries.geom3.fromPoints(polygons);
-}
-
 // lib/HexSocketBolt.tsx
 function createHexSocketBoltGeom(input) {
   return indexedMeshToGeom3(createHexSocketBoltMesh(input));
@@ -322,7 +526,7 @@ function HexSocketBolt({
 }
 
 // lib/mechanical/sheet-metal-mesh.ts
-import earcut from "earcut";
+import earcut2 from "earcut";
 import {
   sheetMetalModelPropsSchema
 } from "@tscircuit/modelprinter";
@@ -390,7 +594,7 @@ function createSheetMetalMesh(input) {
     const loops = [outline, ...holes.map((hole) => [...hole].reverse())];
     const points = loops.flat();
     const starts = holes.map((_, i) => 4 + i * 64);
-    const triangles = earcut(
+    const triangles = earcut2(
       points.flatMap((p) => [p.u, p.v]),
       starts
     );
@@ -474,6 +678,199 @@ function SheetMetal({ color = "#737e8f", ...props }) {
   return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createSheetMetalGeom(props) }) });
 }
 
+// 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";
 
@@ -8723,6 +9120,18 @@ var Footprinter3d = ({ footprint }) => {
         const { fn, ...props } = model;
         return /* @__PURE__ */ jsx(SheetMetal, { ...props });
       }
+      case "helicalgear": {
+        const { fn, ...props } = model;
+        return /* @__PURE__ */ jsx(HelicalGear, { ...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 });
@@ -9644,18 +10053,27 @@ function createJSCADRenderer(jscad4) {
 }
 export {
   Fragment,
+  HelicalGear,
   HexSocketBolt,
   NEMA17,
   NEMA23,
   NEMA8,
   NemaMotor,
   SheetMetal,
+  SpurGear,
+  WormGear,
   convertCSGToThreeGeom,
+  createHelicalGearGeom,
+  createHelicalGearMesh,
   createHexSocketBoltGeom,
   createHexSocketBoltMesh,
   createJSCADRenderer,
   createSheetMetalGeom,
   createSheetMetalMesh,
+  createSpurGearGeom,
+  createSpurGearMesh,
+  createWormGearGeom,
+  createWormGearMesh,
   getJscadModelForFootprint,
   getJscadModelForFootprintWithPads,
   h