jscad-electronics 0.0.180 → 0.0.182

package/dist/vanilla.d.ts

@@ -1,5 +1,8 @@
 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 * as _jscad_modeling_src_geometries_types from '@jscad/modeling/src/geometries/types';
 
 type VNode = {
     type: any;
@@ -21,6 +24,59 @@ type RenderResult = {
 
 declare function convertCSGToThreeGeom(csg: any): BufferGeometry;
 
+type NemaMotorProps = NemaMotorModelPropsInput & {
+    bodyColor?: string;
+    capColor?: string;
+    shaftColor?: string;
+};
+type NemaFrameMotorProps = Omit<NemaMotorProps, "nemaSize">;
+/** Mounting face at Z=0, body along -Z, shaft along +Z; all lengths in mm.
+ * Parameters follow the modelprinter NEMA contract; JSCAD builds all geometry.
+ */
+declare function NemaMotor({ bodyColor, capColor, shaftColor, ...props }: NemaMotorProps): react_jsx_runtime.JSX.Element;
+declare const NEMA8: (props: NemaFrameMotorProps) => react_jsx_runtime.JSX.Element;
+declare const NEMA17: (props: NemaFrameMotorProps) => react_jsx_runtime.JSX.Element;
+declare const NEMA23: (props: NemaFrameMotorProps) => react_jsx_runtime.JSX.Element;
+
+/** Indexed triangles, counterclockwise from outside; millimeters, Z up. */
+interface HexSocketBoltMesh {
+    positions: number[];
+    indices: number[];
+}
+/**
+ * Head bearing plane at Z=0; tip at -length; head extends along +Z.
+ * Produces a closed surface with a blind hex socket and a right-hand,
+ * truncated 60-degree helical thread. Threads are a visual approximation.
+ * No renderer dependencies are needed to consume the indexed mesh.
+ */
+declare const createHexSocketBoltMesh: (input: HexSocketBoltModelPropsInput) => HexSocketBoltMesh;
+
+type HexSocketBoltProps = HexSocketBoltModelPropsInput & {
+    color?: string;
+};
+/** Bearing plane Z=0, tip along -Z, head along +Z. Threads are approximate. */
+declare function createHexSocketBoltGeom(input: HexSocketBoltModelPropsInput): _jscad_modeling_src_geometries_types.Geom3;
+declare function HexSocketBolt({ color, ...props }: HexSocketBoltProps): react_jsx_runtime.JSX.Element;
+
+interface SheetMetalMesh {
+    positions: number[];
+    indices: number[];
+}
+/** Watertight sheet-metal plate, 90-degree angle or U-channel. Millimeters,
+ * right-handed +Z up. Base midsurface at Z=0, centered in X/Y; flanges rise
+ * above it. Lengths measure straight tangent-to-tangent sections. Bend skins
+ * use the specified inside radius and constant material thickness.
+ * Holes are through-cut on straight panels only; no bend allowance/unfolding.
+ */
+declare function createSheetMetalMesh(input: SheetMetalModelPropsInput): SheetMetalMesh;
+
+type SheetMetalProps = SheetMetalModelPropsInput & {
+    color?: string;
+};
+/** Base midsurface Z=0; bends and flanges rise along +Z. Dimensions in mm. */
+declare function createSheetMetalGeom(input: SheetMetalModelPropsInput): _jscad_modeling_src_geometries_types.Geom3;
+declare function SheetMetal({ color, ...props }: SheetMetalProps): 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): {
@@ -29,4 +85,4 @@ declare function createJSCADRenderer(jscad: typeof jscadModeling): {
     };
 };
 
-export { type ColoredGeom, Fragment, type RenderResult, type VNode, convertCSGToThreeGeom, createJSCADRenderer, 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, type VNode, convertCSGToThreeGeom, createHexSocketBoltGeom, createHexSocketBoltMesh, createJSCADRenderer, createSheetMetalGeom, createSheetMetalMesh, getJscadModelForFootprint, getJscadModelForFootprintWithPads, h };

package/dist/vanilla.js

@@ -19,6 +19,7 @@ function h(type, props, ...restChildren) {
 }
 
 // lib/ExtrudedPads.tsx
+import { mp } from "@tscircuit/modelprinter";
 import { fp } from "@tscircuit/footprinter";
 
 // lib/vanilla/primitives.ts
@@ -36,6 +37,7 @@ var Colorize = /* @__PURE__ */ Symbol("Colorize");
 var Polygon = /* @__PURE__ */ Symbol("Polygon");
 var ExtrudeLinear = /* @__PURE__ */ Symbol("ExtrudeLinear");
 var RoundedCylinder = /* @__PURE__ */ Symbol("RoundedCylinder");
+var Custom = /* @__PURE__ */ Symbol("Custom");
 
 // lib/vanilla/react-shim.ts
 var Fragment2 = Fragment;
@@ -170,6 +172,12 @@ var ExtrudedPads = ({
   circuitJson,
   footprint
 }) => {
+  if (!circuitJson && footprint && ["nema", "hexsocketbolt", "sheetmetal"].includes(
+    mp.string(footprint.split("_", 1)[0]).params().fn
+  )) {
+    mp.string(footprint).json();
+    return null;
+  }
   if (!circuitJson && footprint) {
     circuitJson = fp.string(footprint).circuitJson();
   }
@@ -193,6 +201,395 @@ var ExtrudedPads = ({
   ] });
 };
 
+// lib/mechanical/hex-socket-bolt-mesh.ts
+import {
+  hexSocketBoltDimensions,
+  hexSocketBoltModelPropsSchema
+} from "@tscircuit/modelprinter";
+var createHexSocketBoltMesh = (input) => {
+  const props = hexSocketBoltModelPropsSchema.parse(input);
+  const {
+    diameter,
+    threadPitch: pitch,
+    headDiameter,
+    headHeight,
+    socketWidth,
+    socketDepth
+  } = hexSocketBoltDimensions[props.metricSize];
+  const { length, showThreads } = props;
+  const segments = 96;
+  const steps = Math.max(2, Math.ceil(length / pitch * 24));
+  if (steps > 24e3)
+    throw new Error(
+      "Bolt length exceeds mesh resolution limit (1000 thread turns)"
+    );
+  const positions = [];
+  const indices = [];
+  const radius = diameter / 2;
+  const depth = pitch * 0.61343;
+  const bevel = Math.min(0.2, headHeight * 0.08);
+  const tipBevel = Math.min(pitch * 0.6, length / 3);
+  const ring = (z, radiusAt) => {
+    const start = positions.length / 3;
+    for (let i = 0; i < segments; i++) {
+      const angle = i * Math.PI * 2 / segments;
+      const r = radiusAt(angle);
+      positions.push(r * Math.cos(angle), r * Math.sin(angle), z);
+    }
+    return start;
+  };
+  const connect = (a, b) => {
+    for (let i = 0; i < segments; i++) {
+      const next = (i + 1) % segments;
+      indices.push(a + i, a + next, b + next, a + i, b + next, b + i);
+    }
+  };
+  const cap = (start, z, upward) => {
+    const center = positions.length / 3;
+    positions.push(0, 0, z);
+    for (let i = 0; i < segments; i++) {
+      const a = start + i;
+      const b = start + (i + 1) % segments;
+      indices.push(center, upward ? a : b, upward ? b : a);
+    }
+  };
+  let previous = -1;
+  for (let step = 0; step <= steps; step++) {
+    const z = -length + length * step / steps;
+    const current = ring(z, (angle) => {
+      const phase = ((z / pitch - angle / (2 * Math.PI)) % 1 + 1) % 1;
+      const distance2 = Math.min(phase, 1 - phase);
+      const groove = Math.min(
+        depth,
+        Math.max(0, (distance2 - 1 / 16) * pitch * Math.sqrt(3))
+      );
+      const endRamp = Math.min(
+        1,
+        (z + length) / tipBevel,
+        -z / Math.min(pitch / 2, length / 3)
+      );
+      const tipCut = tipBevel * Math.max(0, 1 - (z + length) / tipBevel);
+      return radius - (showThreads ? groove * endRamp : 0) - tipCut;
+    });
+    if (previous < 0) cap(current, z, false);
+    else connect(previous, current);
+    previous = current;
+  }
+  const addRing = (z, radiusAt) => {
+    const current = ring(z, radiusAt);
+    connect(previous, current);
+    previous = current;
+  };
+  addRing(0, () => headDiameter / 2 - bevel);
+  addRing(bevel, () => headDiameter / 2);
+  addRing(headHeight - bevel, () => headDiameter / 2);
+  addRing(headHeight, () => headDiameter / 2 - bevel);
+  const hexRadius = (angle, acrossFlats) => acrossFlats / 2 / Math.cos((angle + Math.PI / 6) % (Math.PI / 3) - Math.PI / 6);
+  addRing(headHeight, (angle) => hexRadius(angle, socketWidth + bevel));
+  addRing(headHeight - bevel / 2, (angle) => hexRadius(angle, socketWidth));
+  addRing(headHeight - socketDepth, (angle) => hexRadius(angle, socketWidth));
+  cap(previous, headHeight - socketDepth, true);
+  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));
+}
+function HexSocketBolt({
+  color = "#737e8f",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createHexSocketBoltGeom(props) }) });
+}
+
+// lib/mechanical/sheet-metal-mesh.ts
+import earcut from "earcut";
+import {
+  sheetMetalModelPropsSchema
+} from "@tscircuit/modelprinter";
+function holeOutline(hole) {
+  const radius = (hole.shape === "round" ? hole.diameter : hole.width) / 2;
+  const straight = hole.shape === "slot" ? (hole.length - hole.width) / 2 : 0;
+  if (straight < 0) throw new Error("Slot length must be at least its width");
+  return Array.from({ length: 64 }, (_, i) => {
+    if (hole.shape === "round") {
+      const angle2 = i * Math.PI / 32;
+      return {
+        u: hole.u + radius * Math.cos(angle2),
+        v: hole.v + radius * Math.sin(angle2)
+      };
+    }
+    const half = i < 32 ? 1 : -1;
+    const angle = -Math.PI / 2 + (i < 32 ? i : i - 32) * Math.PI / 31 + (i < 32 ? 0 : Math.PI);
+    const along = half * straight + radius * Math.cos(angle);
+    const across = radius * Math.sin(angle);
+    return hole.shape === "slot" && hole.axis === "v" ? { u: hole.u - across, v: hole.v + along } : { u: hole.u + along, v: hole.v + across };
+  });
+}
+function createSheetMetalMesh(input) {
+  const props = sheetMetalModelPropsSchema.parse(input);
+  const { width: width10, baseLength, flangeHeight, thickness, profile } = props;
+  const radius = props.insideBendRadius + thickness / 2;
+  const positions = [];
+  const indices = [];
+  const addTriangle = (vertices, reverse = false) => {
+    const start = positions.length / 3;
+    for (const vertex of vertices) positions.push(...vertex);
+    indices.push(start, start + (reverse ? 2 : 1), start + (reverse ? 1 : 2));
+  };
+  const addQuad = (vertices, reverse = false) => {
+    addTriangle([vertices[0], vertices[1], vertices[2]], reverse);
+    addTriangle([vertices[0], vertices[2], vertices[3]], reverse);
+  };
+  const panels = profile === "plate" ? ["base"] : profile === "angle" ? ["base", "right"] : ["base", "left", "right"];
+  for (const hole of props.holes) {
+    if (!panels.includes(hole.panel))
+      throw new Error(`No ${hole.panel} panel on ${profile}`);
+  }
+  for (const panel of panels) {
+    const length = panel === "base" ? baseLength : flangeHeight;
+    const holes = props.holes.filter((hole) => hole.panel === panel).map(holeOutline);
+    const bounds = holes.map((outline2) => ({
+      minU: Math.min(...outline2.map((p) => p.u)),
+      maxU: Math.max(...outline2.map((p) => p.u)),
+      minV: Math.min(...outline2.map((p) => p.v)),
+      maxV: Math.max(...outline2.map((p) => p.v))
+    }));
+    for (const [i, box] of bounds.entries()) {
+      if (box.minU <= -length / 2 || box.maxU >= length / 2 || box.minV <= -width10 / 2 || box.maxV >= width10 / 2)
+        throw new Error(`Hole crosses ${panel} panel edge or bend tangent`);
+      for (const previous of bounds.slice(0, i))
+        if (box.minU <= previous.maxU && box.maxU >= previous.minU && box.minV <= previous.maxV && box.maxV >= previous.minV)
+          throw new Error("Hole bounding boxes must not overlap");
+    }
+    const outline = [
+      { u: -length / 2, v: -width10 / 2 },
+      { u: length / 2, v: -width10 / 2 },
+      { u: length / 2, v: width10 / 2 },
+      { u: -length / 2, v: width10 / 2 }
+    ];
+    const loops = [outline, ...holes.map((hole) => [...hole].reverse())];
+    const points = loops.flat();
+    const starts = holes.map((_, i) => 4 + i * 64);
+    const triangles = earcut(
+      points.flatMap((p) => [p.u, p.v]),
+      starts
+    );
+    const project = (point, offset) => panel === "base" ? [point.u, point.v, offset] : [
+      (panel === "left" ? -1 : 1) * (baseLength / 2 + radius - offset),
+      point.v,
+      radius + flangeHeight / 2 + point.u
+    ];
+    const reverse = panel === "left";
+    for (let i = 0; i < triangles.length; i += 3) {
+      const face2 = triangles.slice(i, i + 3).map((index) => points[index]);
+      addTriangle(
+        face2.map((p) => project(p, thickness / 2)),
+        reverse
+      );
+      addTriangle(
+        face2.map((p) => project(p, -thickness / 2)),
+        !reverse
+      );
+    }
+    for (const [loopIndex, loop] of loops.entries())
+      for (let i = 0; i < loop.length; i++) {
+        const a = loop[i], b = loop[(i + 1) % loop.length];
+        if (loopIndex === 0 && a.u === b.u && (panel === "base" && (a.u > 0 && profile !== "plate" || a.u < 0 && profile === "channel") || panel !== "base" && a.u < 0))
+          continue;
+        addQuad(
+          [
+            project(a, -thickness / 2),
+            project(b, -thickness / 2),
+            project(b, thickness / 2),
+            project(a, thickness / 2)
+          ],
+          reverse
+        );
+      }
+  }
+  const sides = profile === "plate" ? [] : profile === "angle" ? [1] : [-1, 1];
+  for (const side of sides) {
+    const project = (angle, crossSection) => {
+      const r = radius - crossSection.offset;
+      return [
+        side * (baseLength / 2 + r * Math.sin(angle)),
+        crossSection.y,
+        radius - r * Math.cos(angle)
+      ];
+    };
+    for (let i = 0; i < 32; i++) {
+      const a = i * Math.PI / 64, b = (i + 1) * Math.PI / 64;
+      for (const offset of [-thickness / 2, thickness / 2]) {
+        addQuad(
+          [
+            project(a, { y: -width10 / 2, offset }),
+            project(b, { y: -width10 / 2, offset }),
+            project(b, { y: width10 / 2, offset }),
+            project(a, { y: width10 / 2, offset })
+          ],
+          offset < 0 !== side < 0
+        );
+      }
+      for (const y of [-width10 / 2, width10 / 2]) {
+        addQuad(
+          [
+            project(a, { y, offset: -thickness / 2 }),
+            project(b, { y, offset: -thickness / 2 }),
+            project(b, { y, offset: thickness / 2 }),
+            project(a, { y, offset: thickness / 2 })
+          ],
+          y > 0 !== side < 0
+        );
+      }
+    }
+  }
+  return { positions, indices };
+}
+
+// lib/SheetMetal.tsx
+function createSheetMetalGeom(input) {
+  return indexedMeshToGeom3(createSheetMetalMesh(input));
+}
+function SheetMetal({ color = "#737e8f", ...props }) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createSheetMetalGeom(props) }) });
+}
+
+// lib/NemaMotor.tsx
+import jscad2 from "@jscad/modeling";
+
+// lib/utils/nemaMotorParameters.ts
+import { mp as mp2, nemaMotorModelPropsSchema } from "@tscircuit/modelprinter";
+var resolveNemaMotorProps = nemaMotorModelPropsSchema.parse.bind(
+  nemaMotorModelPropsSchema
+);
+
+// lib/utils/nemaMotorGeometry.ts
+var circle = (radius, x = 0, y = 0) => Array.from({ length: 96 }, (_, i) => [
+  x + radius * Math.cos(i * Math.PI / 48),
+  y + radius * Math.sin(i * Math.PI / 48)
+]);
+var face = (width10, chamfer) => {
+  const h2 = width10 / 2, c = chamfer;
+  if (c === 0)
+    return [
+      [-h2, -h2],
+      [h2, -h2],
+      [h2, h2],
+      [-h2, h2]
+    ];
+  return [
+    [-h2 + c, -h2],
+    [h2 - c, -h2],
+    [h2, -h2 + c],
+    [h2, h2 - c],
+    [h2 - c, h2],
+    [-h2 + c, h2],
+    [-h2, h2 - c],
+    [-h2, -h2 + c]
+  ];
+};
+function createNemaMotorSections(input) {
+  const p = resolveNemaMotorProps(input);
+  const sections = [];
+  const add = (name, outline, zMin, zMax, holes2 = []) => {
+    if (zMax > zMin) sections.push({ name, outline, holes: holes2, zMin, zMax });
+  };
+  const front = face(p.bodyWidth, p.faceCornerChamfer);
+  const core = face(p.bodyWidth, p.bodyCornerChamfer);
+  const h2 = p.mountingHoleSpacing / 2;
+  const centers = [
+    [-h2, -h2],
+    [h2, -h2],
+    [h2, h2],
+    [-h2, h2]
+  ];
+  const holes = centers.map(
+    ([x, y]) => circle(p.mountingHoleDiameter / 2, x, y)
+  );
+  const holeDepth = p.mountingHoleThrough ? p.frontCapLength : p.mountingHoleDepth;
+  add("frontCap", front, -holeDepth, 0, holes);
+  add("frontCap", front, -p.frontCapLength, -holeDepth);
+  add("body", core, -p.bodyLength + p.rearCapLength, -p.frontCapLength);
+  add(
+    "rearCap",
+    p.mountingHoleThrough ? core : front,
+    -p.bodyLength,
+    -p.bodyLength + p.rearCapLength
+  );
+  add("pilot", circle(p.pilotDiameter / 2), 0, p.pilotLength);
+  const r = p.shaftDiameter / 2;
+  const round = circle(r);
+  if (p.shaftShape === "round")
+    add("shaft", round, p.pilotLength, p.shaftLength);
+  else {
+    const cut = r - p.shaftFlatDepth;
+    const angle = Math.acos(cut / r);
+    const profile = Array.from({ length: 97 }, (_, i) => {
+      const a = angle + (2 * Math.PI - 2 * angle) * i / 96;
+      return [r * Math.cos(a), r * Math.sin(a)];
+    });
+    const rotation = p.shaftFlatAngle * Math.PI / 180;
+    const d = profile.map(([x, y]) => [
+      x * Math.cos(rotation) - y * Math.sin(rotation),
+      x * Math.sin(rotation) + y * Math.cos(rotation)
+    ]);
+    add("shaft", round, p.pilotLength, p.shaftLength - p.shaftFlatLength);
+    add("shaft", d, p.shaftLength - p.shaftFlatLength, p.shaftLength);
+  }
+  return sections;
+}
+
+// lib/NemaMotor.tsx
+function NemaMotor({
+  bodyColor = "#242830",
+  capColor = "#aeb5bd",
+  shaftColor = "#b8bec6",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(Fragment2, { children: createNemaMotorSections(props).map((section, index) => {
+    const outline = jscad2.geometries.geom2.fromPoints(section.outline);
+    const profile = section.holes.length ? jscad2.booleans.subtract(
+      outline,
+      ...section.holes.map((h2) => jscad2.geometries.geom2.fromPoints(h2))
+    ) : outline;
+    const geometry = jscad2.transforms.translate(
+      [0, 0, section.zMin],
+      jscad2.extrusions.extrudeLinear(
+        { height: section.zMax - section.zMin },
+        profile
+      )
+    );
+    return /* @__PURE__ */ jsx(
+      Colorize,
+      {
+        color: section.name === "body" ? bodyColor : section.name === "shaft" ? shaftColor : capColor,
+        children: /* @__PURE__ */ jsx(Custom, { geometry })
+      },
+      `${section.name}-${index}`
+    );
+  }) });
+}
+var NEMA8 = (props) => /* @__PURE__ */ jsx(NemaMotor, { ...props, nemaSize: 8 });
+var NEMA17 = (props) => /* @__PURE__ */ jsx(NemaMotor, { ...props, nemaSize: 17 });
+var NEMA23 = (props) => /* @__PURE__ */ jsx(NemaMotor, { ...props, nemaSize: 23 });
+
 // lib/LGA.tsx
 function LGA(p) {
   for (const k of [
@@ -489,7 +886,7 @@ function renderFootprinterBodyModel(p) {
 
 // lib/Footprinter3d.tsx
 import { fp as fp10 } from "@tscircuit/footprinter";
-import { mp } from "@tscircuit/modelprinter";
+import { mp as mp3 } from "@tscircuit/modelprinter";
 
 // lib/ChipBody.tsx
 var ChipBody = ({
@@ -8195,10 +8592,22 @@ var FlexScreen = (props) => {
 
 // lib/Footprinter3d.tsx
 var Footprinter3d = ({ footprint }) => {
-  const modelFn = mp.string(footprint.split("_", 1)[0]).params().fn;
-  if (mp.getModelNames().includes(modelFn)) {
-    const model = mp.string(footprint).json();
+  const modelFn = mp3.string(footprint.split("_", 1)[0]).params().fn;
+  if (mp3.getModelNames().includes(modelFn)) {
+    const model = mp3.string(footprint).json();
     switch (model.fn) {
+      case "nema": {
+        const { fn, ...props } = model;
+        return /* @__PURE__ */ jsx(NemaMotor, { ...props });
+      }
+      case "hexsocketbolt": {
+        const { fn, ...props } = model;
+        return /* @__PURE__ */ jsx(HexSocketBolt, { ...props });
+      }
+      case "sheetmetal": {
+        const { fn, ...props } = model;
+        return /* @__PURE__ */ jsx(SheetMetal, { ...props });
+      }
       case "flexscreen": {
         const { fn: _, ...flexScreenProps } = model;
         return /* @__PURE__ */ jsx(FlexScreen, { ...flexScreenProps });
@@ -8942,6 +9351,9 @@ function renderNode(node, colorCtx, renderCtx) {
     else geom = hulls.hull(geoms);
     return [{ geom, color: colorCtx }];
   }
+  if (type === Custom) {
+    return [{ geom: props.geometry, color: colorCtx }];
+  }
   if (type === Polygon) {
     const points = props?.points ?? [];
     const g2 = geometries.geom2.fromPoints(points);
@@ -9002,8 +9414,8 @@ function renderNode(node, colorCtx, renderCtx) {
   }
   return (children ?? []).flatMap((c) => renderNode(c, colorCtx, renderCtx));
 }
-function render(root, jscad) {
-  const geometries = renderNode(root, void 0, { jscad });
+function render(root, jscad3) {
+  const geometries = renderNode(root, void 0, { jscad: jscad3 });
   return { geometries };
 }
 
@@ -9091,24 +9503,24 @@ function convertCSGToThreeGeom(csg) {
 }
 
 // lib/vanilla/index.ts
-function getJscadModelForFootprint(footprint, jscad) {
+function getJscadModelForFootprint(footprint, jscad3) {
   const vnode = h(Footprinter3d, { footprint });
-  return render(vnode, jscad);
+  return render(vnode, jscad3);
 }
-function getJscadModelForFootprintWithPads(footprint, jscad) {
+function getJscadModelForFootprintWithPads(footprint, jscad3) {
   const vnode = h(
     Fragment,
     {},
     h(Footprinter3d, { footprint }),
     h(ExtrudedPads, { footprint })
   );
-  return render(vnode, jscad);
+  return render(vnode, jscad3);
 }
-function createJSCADRenderer(jscad) {
+function createJSCADRenderer(jscad3) {
   function createJSCADRoot(container) {
     return {
       render(element) {
-        const { geometries } = render(element, jscad);
+        const { geometries } = render(element, jscad3);
         container.splice(0, container.length, ...geometries);
       }
     };
@@ -9117,8 +9529,18 @@ function createJSCADRenderer(jscad) {
 }
 export {
   Fragment,
+  HexSocketBolt,
+  NEMA17,
+  NEMA23,
+  NEMA8,
+  NemaMotor,
+  SheetMetal,
   convertCSGToThreeGeom,
+  createHexSocketBoltGeom,
+  createHexSocketBoltMesh,
   createJSCADRenderer,
+  createSheetMetalGeom,
+  createSheetMetalMesh,
   getJscadModelForFootprint,
   getJscadModelForFootprintWithPads,
   h