jscad-electronics 0.0.198 → 0.0.200

package/dist/vanilla.js

@@ -179,28 +179,28 @@ var FootprintPlatedHole = ({
   throw new Error("Shape not supported: " + hole.shape);
 };
 
-// lib/models/flangedbushing/register.tsx
-import { flangedBushingModelDefinitionSchema } from "@tscircuit/modelprinter";
+// lib/models/buttonscrew/register.tsx
+import { buttonScrewModelDefinitionSchema } from "@tscircuit/modelprinter";
 
 // lib/model-registry.ts
-function defineModelRenderer(model13) {
-  return model13;
+function defineModelRenderer(model15) {
+  return model15;
 }
 var ModelRendererRegistry = class {
   models = /* @__PURE__ */ new Map();
-  register(model13) {
-    if (typeof model13.name !== "string" || !/^[a-z]+$/.test(model13.name)) {
+  register(model15) {
+    if (typeof model15.name !== "string" || !/^[a-z]+$/.test(model15.name)) {
       throw new Error(
         "Model renderer names must contain only lowercase letters"
       );
     }
-    if (this.models.has(model13.name)) {
-      throw new Error(`Model renderer "${model13.name}" is already registered`);
+    if (this.models.has(model15.name)) {
+      throw new Error(`Model renderer "${model15.name}" is already registered`);
     }
-    if (model13.pads !== "none" && model13.pads !== "footprinter") {
+    if (model15.pads !== "none" && model15.pads !== "footprinter") {
       throw new Error('Model renderer pads must be "none" or "footprinter"');
     }
-    const { name, schema, render: render2, pads } = model13;
+    const { name, schema, render: render2, pads } = model15;
     this.models.set(name, {
       name,
       schema,
@@ -226,6 +226,118 @@ var ModelRendererRegistry = class {
   }
 };
 
+// lib/models/buttonscrew/mesh.ts
+import {
+  buttonScrewModelPropsSchema,
+  getButtonScrewDimensions
+} from "@tscircuit/modelprinter";
+function resolution(options) {
+  const radial = options.radialSegments ?? 96;
+  const axial = options.segmentsPerPitch ?? 32;
+  if (!Number.isInteger(radial) || radial < 24 || radial > 192 || radial % 12 !== 0 || !Number.isInteger(axial) || axial < 8 || axial > 64)
+    throw new Error(
+      "Mesh resolution limit: radial segments must be a multiple of 12 in [24,192], pitch segments an integer in [8,64]"
+    );
+  return { radial, axial };
+}
+function surface(segments) {
+  const positions = [], indices = [];
+  const ring = (z, radius) => {
+    const start = positions.length / 3;
+    for (let i = 0; i < segments; i++) {
+      const angle = i * 2 * Math.PI / segments;
+      const r = radius(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 n = (i + 1) % segments;
+      indices.push(a + i, a + n, b + n, a + i, b + n, b + i);
+    }
+  };
+  const cap = (start, z, up) => {
+    const center = positions.length / 3;
+    positions.push(0, 0, z);
+    for (let i = 0; i < segments; i++) {
+      const n = (i + 1) % segments;
+      indices.push(center, start + (up ? i : n), start + (up ? n : i));
+    }
+  };
+  return { positions, indices, ring, connect, cap };
+}
+function hexRadius(angle, acrossFlats) {
+  const period = Math.PI / 3;
+  const distance2 = ((angle - Math.PI / 2 + period / 2) % period + period) % period - period / 2;
+  return acrossFlats / 2 / Math.cos(distance2);
+}
+function threadDistance(z, angle, pitch, hand = 1) {
+  const phase = ((z / pitch - hand * angle / (2 * Math.PI)) % 1 + 1) % 1;
+  return Math.min(phase, 1 - phase);
+}
+function createButtonScrewMesh(input, options = {}) {
+  const props = buttonScrewModelPropsSchema.parse(input);
+  const d = getButtonScrewDimensions(input);
+  const { radial, axial } = resolution(options);
+  const steps = Math.max(2, Math.ceil(props.length / d.threadPitch * axial));
+  if (steps > 24e3 || !Number.isFinite(steps))
+    throw new Error("Mesh resolution limit: too many thread turns");
+  const m = surface(radial);
+  const radius = d.diameter / 2;
+  const depth = (d.diameter - d.threadMinorDiameter) / 2;
+  const fillet = d.underHeadRadius;
+  const levels = new Set(
+    props.showThreads ? Array.from(
+      { length: steps + 1 },
+      (_, i) => -props.length + props.length * i / steps
+    ) : [-props.length, 0]
+  );
+  levels.add(-props.length + d.tipChamfer);
+  levels.add(-d.threadPitch);
+  for (let i = 0; i <= 16; i++)
+    levels.add(-fillet + fillet * Math.sin(i * Math.PI / 32));
+  let previous = -1;
+  const shaftLevels = [...levels].sort((a, b) => a - b).filter((z, index, sorted) => index === 0 || z - sorted[index - 1] > 1e-10);
+  for (const z of shaftLevels) {
+    const current = m.ring(z, (angle) => {
+      const envelope = z >= -fillet ? radius + fillet - Math.sqrt(Math.max(0, fillet ** 2 - (z + fillet) ** 2)) : radius;
+      const groove = Math.min(
+        depth,
+        Math.max(
+          0,
+          (threadDistance(z + props.length, angle, d.threadPitch) - 1 / 16) * d.threadPitch * Math.sqrt(3)
+        )
+      );
+      const threaded = envelope - (props.showThreads ? groove * Math.min(1, -z / d.threadPitch) : 0);
+      const tip = z + props.length < d.tipChamfer ? radius - (d.tipChamfer - (z + props.length)) : Infinity;
+      return Math.min(threaded, tip);
+    });
+    if (previous < 0) m.cap(current, z, false);
+    else m.connect(previous, current);
+    previous = current;
+  }
+  const add = (z, radiusAt) => {
+    const current = m.ring(z, radiusAt);
+    m.connect(previous, current);
+    previous = current;
+  };
+  add(0, () => d.headDiameter / 2);
+  for (let i = 1; i <= 24; i++) {
+    const z = d.headHeight * i / 24;
+    add(
+      z,
+      () => d.crownArcCenterR + Math.sqrt(
+        Math.max(0, d.crownRadius ** 2 - (z - d.crownArcCenterZ) ** 2)
+      )
+    );
+  }
+  add(d.topZ, (angle) => hexRadius(angle, d.socketWidth));
+  add(d.topZ - d.socketDepth, (angle) => hexRadius(angle, d.socketWidth));
+  m.cap(previous, d.topZ - d.socketDepth, true);
+  return { positions: m.positions, indices: m.indices };
+}
+
 // lib/mechanical/indexedMeshToGeom3.ts
 import jscad from "@jscad/modeling";
 function indexedMeshToGeom3(mesh) {
@@ -241,6 +353,28 @@ function indexedMeshToGeom3(mesh) {
   return jscad.geometries.geom3.fromPoints(polygons);
 }
 
+// lib/models/buttonscrew/ButtonScrew.tsx
+function createButtonScrewGeom(input, resolution3) {
+  return indexedMeshToGeom3(createButtonScrewMesh(input, resolution3));
+}
+function ButtonScrew({ color = "#737e8f", ...props }) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createButtonScrewGeom(props) }) });
+}
+
+// lib/models/buttonscrew/register.tsx
+var model = defineModelRenderer({
+  name: "buttonscrew",
+  schema: buttonScrewModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(ButtonScrew, { ...props }),
+  pads: "none"
+});
+function register(registry) {
+  registry.register(model);
+}
+
+// lib/models/flangedbushing/register.tsx
+import { flangedBushingModelDefinitionSchema } from "@tscircuit/modelprinter";
+
 // lib/models/flangedbushing/mesh.ts
 import {
   flangedBushingModelPropsSchema,
@@ -291,14 +425,14 @@ function FlangedBushing({
 }
 
 // lib/models/flangedbushing/register.tsx
-var model = defineModelRenderer({
+var model2 = defineModelRenderer({
   name: "flangedbushing",
   schema: flangedBushingModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlangedBushing, { ...props }),
   pads: "none"
 });
-function register(registry) {
-  registry.register(model);
+function register2(registry) {
+  registry.register(model2);
 }
 
 // lib/models/flatheadscrew/register.tsx
@@ -407,14 +541,14 @@ function createFlatHeadScrewMesh(input, options = {}) {
       filletCenterZ + p.underHeadRadius * Math.sin(angle)
     );
   }
-  const hexRadius = (theta) => p.socketAcrossFlats / 2 / Math.max(
+  const hexRadius3 = (theta) => p.socketAcrossFlats / 2 / Math.max(
     Math.abs(Math.sin(theta)),
     Math.abs(Math.sin(theta + 2 * Math.PI / 3)),
     Math.abs(Math.sin(theta + 4 * Math.PI / 3))
   );
   add(() => p.headDiameter / 2, 0);
-  add(hexRadius, 0);
-  add(hexRadius, -p.socketDepth);
+  add(hexRadius3, 0);
+  add(hexRadius3, -p.socketDepth);
   cap(previous, -p.socketDepth, true);
   return { positions, indices };
 }
@@ -431,14 +565,14 @@ function FlatHeadScrew({
 }
 
 // lib/models/flatheadscrew/register.tsx
-var model2 = defineModelRenderer({
+var model3 = defineModelRenderer({
   name: "flatheadscrew",
   schema: flatHeadScrewModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlatHeadScrew, { ...props }),
   pads: "none"
 });
-function register2(registry) {
-  registry.register(model2);
+function register3(registry) {
+  registry.register(model3);
 }
 
 // lib/models/flexscreen/register.tsx
@@ -1116,14 +1250,14 @@ var FlexScreen = (props) => {
 };
 
 // lib/models/flexscreen/register.tsx
-var model3 = defineModelRenderer({
+var model4 = defineModelRenderer({
   name: "flexscreen",
   schema: flexScreenModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlexScreen, { ...props }),
   pads: "footprinter"
 });
-function register3(registry) {
-  registry.register(model3);
+function register4(registry) {
+  registry.register(model4);
 }
 
 // lib/models/helicalgear/register.tsx
@@ -1329,14 +1463,14 @@ function HelicalGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/helicalgear/register.tsx
-var model4 = defineModelRenderer({
+var model5 = defineModelRenderer({
   name: "helicalgear",
   schema: helicalGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HelicalGear, { ...props }),
   pads: "none"
 });
-function register4(registry) {
-  registry.register(model4);
+function register5(registry) {
+  registry.register(model5);
 }
 
 // lib/models/hexbolt/register.tsx
@@ -1445,20 +1579,20 @@ function createHexBoltMesh(input, options = {}) {
       filletCenterZ + p.underHeadRadius * Math.sin(angle)
     );
   }
-  const hexRadius = (theta) => p.headAcrossFlats / 2 / Math.max(
+  const hexRadius3 = (theta) => p.headAcrossFlats / 2 / Math.max(
     Math.abs(Math.sin(theta)),
     Math.abs(Math.sin(theta + 2 * Math.PI / 3)),
     Math.abs(Math.sin(theta + 4 * Math.PI / 3))
   );
-  add(hexRadius, 0);
+  add(hexRadius3, 0);
   const slope = Math.tan(p.headChamferAngle * Math.PI / 180);
   const start = p.headHeight - (p.headCornerDiameter - p.headChamferDiameter) / 2 * slope;
-  add(hexRadius, start);
+  add(hexRadius3, start);
   for (let i = 1; i <= 12; i++) {
     const z = start + (p.headHeight - start) * i / 12;
     add(
       (theta) => Math.min(
-        hexRadius(theta),
+        hexRadius3(theta),
         p.headChamferDiameter / 2 + (p.headHeight - z) / slope
       ),
       z
@@ -1477,14 +1611,144 @@ function HexBolt({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/hexbolt/register.tsx
-var model5 = defineModelRenderer({
+var model6 = defineModelRenderer({
   name: "hexbolt",
   schema: hexBoltModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexBolt, { ...props }),
   pads: "none"
 });
-function register5(registry) {
-  registry.register(model5);
+function register6(registry) {
+  registry.register(model6);
+}
+
+// lib/models/hexnut/register.tsx
+import { hexNutModelDefinitionSchema } from "@tscircuit/modelprinter";
+
+// lib/models/hexnut/mesh.ts
+import {
+  hexNutModelPropsSchema,
+  getHexNutDimensions
+} from "@tscircuit/modelprinter";
+function resolution2(options) {
+  const radial = options.radialSegments ?? 96;
+  const axial = options.segmentsPerPitch ?? 32;
+  if (!Number.isInteger(radial) || radial < 24 || radial > 192 || radial % 12 !== 0 || !Number.isInteger(axial) || axial < 8 || axial > 64)
+    throw new Error(
+      "Mesh resolution limit: radial segments must be a multiple of 12 in [24,192], pitch segments an integer in [8,64]"
+    );
+  return { radial, axial };
+}
+function surface2(segments) {
+  const positions = [], indices = [];
+  const ring = (z, radius) => {
+    const start = positions.length / 3;
+    for (let i = 0; i < segments; i++) {
+      const angle = i * 2 * Math.PI / segments;
+      const r = radius(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 n = (i + 1) % segments;
+      indices.push(a + i, a + n, b + n, a + i, b + n, b + i);
+    }
+  };
+  const cap = (start, z, up) => {
+    const center = positions.length / 3;
+    positions.push(0, 0, z);
+    for (let i = 0; i < segments; i++) {
+      const n = (i + 1) % segments;
+      indices.push(center, start + (up ? i : n), start + (up ? n : i));
+    }
+  };
+  return { positions, indices, ring, connect, cap };
+}
+function hexRadius2(angle, acrossFlats) {
+  const period = Math.PI / 3;
+  const distance2 = ((angle - Math.PI / 2 + period / 2) % period + period) % period - period / 2;
+  return acrossFlats / 2 / Math.cos(distance2);
+}
+function threadDistance2(z, angle, pitch, hand = 1) {
+  const phase = ((z / pitch - hand * angle / (2 * Math.PI)) % 1 + 1) % 1;
+  return Math.min(phase, 1 - phase);
+}
+function createHexNutMesh(input, options = {}) {
+  const props = hexNutModelPropsSchema.parse(input);
+  const d = getHexNutDimensions(input);
+  const { radial, axial } = resolution2(options);
+  const steps = Math.max(2, Math.ceil(d.height / d.threadPitch * axial));
+  if (steps > 24e3 || !Number.isFinite(steps))
+    throw new Error("Mesh resolution limit: too many thread turns");
+  const m = surface2(radial);
+  const outer = (z, angle) => Math.min(
+    hexRadius2(angle, d.acrossFlats),
+    d.faceDiameter / 2 + Math.min(z, d.height - z) * Math.sqrt(3)
+  );
+  const outerLevels = [
+    0,
+    d.outerChamferDepth,
+    d.height - d.outerChamferDepth,
+    d.height
+  ];
+  for (let index = 0; index < radial; index++) {
+    const angle = index * 2 * Math.PI / radial;
+    const height10 = (hexRadius2(angle, d.acrossFlats) - d.faceDiameter / 2) / Math.sqrt(3);
+    if (height10 > 1e-9 && height10 < d.outerChamferDepth - 1e-9)
+      outerLevels.push(height10, d.height - height10);
+  }
+  const outerZ = outerLevels.sort((a, b) => a - b).filter((z, index, sorted) => index === 0 || z - sorted[index - 1] > 1e-10);
+  const first = m.ring(0, (angle) => outer(0, angle));
+  let previous = first;
+  for (const z of outerZ.slice(1)) {
+    const current = m.ring(z, (angle) => outer(z, angle));
+    m.connect(previous, current);
+    previous = current;
+  }
+  const levels = new Set(
+    props.showThreads ? Array.from({ length: steps + 1 }, (_, i) => d.height * i / steps) : [0, d.height]
+  );
+  levels.add(d.boreChamferDepth);
+  levels.add(d.height - d.boreChamferDepth);
+  const minor = d.boreMinorDiameter / 2;
+  const depth = (d.diameter - d.boreMinorDiameter) / 2;
+  for (const z of [...levels].sort((a, b) => b - a)) {
+    const current = m.ring(z, (angle) => {
+      const groove = Math.min(
+        depth,
+        Math.max(
+          0,
+          (threadDistance2(z, angle, d.threadPitch) - 1 / 8) * d.threadPitch * Math.sqrt(3)
+        )
+      );
+      const threaded = minor + (props.showThreads ? groove : 0);
+      return Math.max(threaded, d.mouthDiameter / 2 - Math.min(z, d.height - z));
+    });
+    m.connect(previous, current);
+    previous = current;
+  }
+  m.connect(previous, first);
+  return { positions: m.positions, indices: m.indices };
+}
+
+// lib/models/hexnut/HexNut.tsx
+function createHexNutGeom(input, resolution3) {
+  return indexedMeshToGeom3(createHexNutMesh(input, resolution3));
+}
+function HexNut({ color = "#737e8f", ...props }) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createHexNutGeom(props) }) });
+}
+
+// lib/models/hexnut/register.tsx
+var model7 = defineModelRenderer({
+  name: "hexnut",
+  schema: hexNutModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexNut, { ...props }),
+  pads: "none"
+});
+function register7(registry) {
+  registry.register(model7);
 }
 
 // lib/models/hexsocketbolt/register.tsx
@@ -1576,10 +1840,10 @@ var createHexSocketBoltMesh = (input) => {
   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));
+  const hexRadius3 = (angle, acrossFlats) => acrossFlats / 2 / Math.cos((angle + Math.PI / 6) % (Math.PI / 3) - Math.PI / 6);
+  addRing(headHeight, (angle) => hexRadius3(angle, socketWidth + bevel));
+  addRing(headHeight - bevel / 2, (angle) => hexRadius3(angle, socketWidth));
+  addRing(headHeight - socketDepth, (angle) => hexRadius3(angle, socketWidth));
   cap(previous, headHeight - socketDepth, true);
   return { positions, indices };
 };
@@ -1596,14 +1860,14 @@ function HexSocketBolt({
 }
 
 // lib/models/hexsocketbolt/register.tsx
-var model6 = defineModelRenderer({
+var model8 = defineModelRenderer({
   name: "hexsocketbolt",
   schema: hexSocketBoltModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexSocketBolt, { ...props }),
   pads: "none"
 });
-function register6(registry) {
-  registry.register(model6);
+function register8(registry) {
+  registry.register(model8);
 }
 
 // lib/models/nema/register.tsx
@@ -1872,14 +2136,14 @@ var NEMA17 = (props) => /* @__PURE__ */ jsx(NemaMotor, { ...props, nemaSize: 17
 var NEMA23 = (props) => /* @__PURE__ */ jsx(NemaMotor, { ...props, nemaSize: 23 });
 
 // lib/models/nema/register.tsx
-var model7 = defineModelRenderer({
+var model9 = defineModelRenderer({
   name: "nema",
   schema: nemaMotorModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(NemaMotor, { ...props }),
   pads: "none"
 });
-function register7(registry) {
-  registry.register(model7);
+function register9(registry) {
+  registry.register(model9);
 }
 
 // lib/models/panscrew/register.tsx
@@ -2091,14 +2355,14 @@ function PanScrew({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/panscrew/register.tsx
-var model8 = defineModelRenderer({
+var model10 = defineModelRenderer({
   name: "panscrew",
   schema: panScrewModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(PanScrew, { ...props }),
   pads: "none"
 });
-function register8(registry) {
-  registry.register(model8);
+function register10(registry) {
+  registry.register(model10);
 }
 
 // lib/models/plainbushing/register.tsx
@@ -2161,14 +2425,14 @@ function PlainBushing({
 }
 
 // lib/models/plainbushing/register.tsx
-var model9 = defineModelRenderer({
+var model11 = defineModelRenderer({
   name: "plainbushing",
   schema: plainBushingModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(PlainBushing, { ...props }),
   pads: "none"
 });
-function register9(registry) {
-  registry.register(model9);
+function register11(registry) {
+  registry.register(model11);
 }
 
 // lib/models/sheetmetal/register.tsx
@@ -2328,14 +2592,14 @@ function SheetMetal({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/sheetmetal/register.tsx
-var model10 = defineModelRenderer({
+var model12 = defineModelRenderer({
   name: "sheetmetal",
   schema: sheetMetalModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SheetMetal, { ...props }),
   pads: "none"
 });
-function register10(registry) {
-  registry.register(model10);
+function register12(registry) {
+  registry.register(model12);
 }
 
 // lib/models/spurgear/register.tsx
@@ -2350,14 +2614,14 @@ function SpurGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/spurgear/register.tsx
-var model11 = defineModelRenderer({
+var model13 = defineModelRenderer({
   name: "spurgear",
   schema: spurGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SpurGear, { ...props }),
   pads: "none"
 });
-function register11(registry) {
-  registry.register(model11);
+function register13(registry) {
+  registry.register(model13);
 }
 
 // lib/models/wormgear/register.tsx
@@ -2549,14 +2813,14 @@ function WormGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/wormgear/register.tsx
-var model12 = defineModelRenderer({
+var model14 = defineModelRenderer({
   name: "wormgear",
   schema: wormGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(WormGear, { ...props }),
   pads: "none"
 });
-function register12(registry) {
-  registry.register(model12);
+function register14(registry) {
+  registry.register(model14);
 }
 
 // lib/generated/model-renderers.ts
@@ -2573,6 +2837,8 @@ function registerAllModelRenderers(registry) {
   register10(registry);
   register11(registry);
   register12(registry);
+  register13(registry);
+  register14(registry);
 }
 
 // lib/default-model-registry.ts
@@ -10129,10 +10395,10 @@ var SOT143 = ({ footprint = "sot143" }) => {
 var Footprinter3d = ({ footprint }) => {
   const modelFn = mp3.string(footprint.split("_", 1)[0]).params().fn;
   if (mp3.getModelNames().includes(modelFn)) {
-    const model13 = mp3.string(footprint).json();
-    const renderer = modelRendererRegistry.get(model13.fn);
+    const model15 = mp3.string(footprint).json();
+    const renderer = modelRendererRegistry.get(model15.fn);
     if (renderer) {
-      return renderer.render(model13);
+      return renderer.render(model15);
     }
   }
   let normalizedFootprint = footprint;
@@ -11083,11 +11349,13 @@ function createJSCADRenderer(jscad4) {
   return { createJSCADRoot };
 }
 export {
+  ButtonScrew,
   FlangedBushing,
   FlatHeadScrew,
   Fragment,
   HelicalGear,
   HexBolt,
+  HexNut,
   HexSocketBolt,
   NEMA17,
   NEMA23,
@@ -11099,6 +11367,8 @@ export {
   SpurGear,
   WormGear,
   convertCSGToThreeGeom,
+  createButtonScrewGeom,
+  createButtonScrewMesh,
   createFlangedBushingGeom,
   createFlangedBushingMesh,
   createFlatHeadScrewGeom,
@@ -11107,6 +11377,8 @@ export {
   createHelicalGearMesh,
   createHexBoltGeom,
   createHexBoltMesh,
+  createHexNutGeom,
+  createHexNutMesh,
   createHexSocketBoltGeom,
   createHexSocketBoltMesh,
   createJSCADRenderer,