jscad-electronics 0.0.194 → 0.0.196

package/dist/vanilla.js

@@ -179,28 +179,28 @@ var FootprintPlatedHole = ({
   throw new Error("Shape not supported: " + hole.shape);
 };
 
-// lib/models/flexscreen/register.tsx
-import { flexScreenModelDefinitionSchema } from "@tscircuit/modelprinter";
+// lib/models/flatheadscrew/register.tsx
+import { flatHeadScrewModelDefinitionSchema } from "@tscircuit/modelprinter";
 
 // lib/model-registry.ts
-function defineModelRenderer(model9) {
-  return model9;
+function defineModelRenderer(model11) {
+  return model11;
 }
 var ModelRendererRegistry = class {
   models = /* @__PURE__ */ new Map();
-  register(model9) {
-    if (typeof model9.name !== "string" || !/^[a-z]+$/.test(model9.name)) {
+  register(model11) {
+    if (typeof model11.name !== "string" || !/^[a-z]+$/.test(model11.name)) {
       throw new Error(
         "Model renderer names must contain only lowercase letters"
       );
     }
-    if (this.models.has(model9.name)) {
-      throw new Error(`Model renderer "${model9.name}" is already registered`);
+    if (this.models.has(model11.name)) {
+      throw new Error(`Model renderer "${model11.name}" is already registered`);
     }
-    if (model9.pads !== "none" && model9.pads !== "footprinter") {
+    if (model11.pads !== "none" && model11.pads !== "footprinter") {
       throw new Error('Model renderer pads must be "none" or "footprinter"');
     }
-    const { name, schema, render: render2, pads } = model9;
+    const { name, schema, render: render2, pads } = model11;
     this.models.set(name, {
       name,
       schema,
@@ -226,6 +226,161 @@ var ModelRendererRegistry = class {
   }
 };
 
+// lib/models/flatheadscrew/mesh.ts
+import {
+  flatHeadScrewModelPropsSchema
+} from "@tscircuit/modelprinter";
+function createFlatHeadScrewMesh(input, options = {}) {
+  const p = flatHeadScrewModelPropsSchema.parse(input);
+  const segments = options.radialSegments ?? 96;
+  const axial = options.threadStepsPerTurn ?? 24;
+  if (!Number.isInteger(segments) || segments < 24 || segments > 192 || segments % 24 !== 0 || !Number.isInteger(axial) || axial < 24 || axial > 96)
+    throw new Error(
+      "Screw mesh resolution requires 24..192 radial segments divisible by 24 and 24..96 thread steps"
+    );
+  const positions = [], indices = [];
+  const welded = /* @__PURE__ */ new Map();
+  const vertex = (x, y, z) => {
+    const key = [x, y, z].map((v) => Math.round(v * 1e10)).join(":");
+    const existing = welded.get(key);
+    if (existing !== void 0) return existing;
+    const index = positions.length / 3;
+    positions.push(x, y, z);
+    welded.set(key, index);
+    return index;
+  };
+  const triangle = (a, b, c) => {
+    if (a === b || b === c || c === a) return;
+    const point = (i) => positions.slice(3 * i, 3 * i + 3);
+    const A = point(a), B = point(b), C = point(c);
+    const u = B.map((v2, i) => v2 - A[i]), v = C.map((w, i) => w - A[i]);
+    const area = Math.hypot(
+      u[1] * v[2] - u[2] * v[1],
+      u[2] * v[0] - u[0] * v[2],
+      u[0] * v[1] - u[1] * v[0]
+    );
+    if (area > 1e-12) indices.push(a, b, c);
+  };
+  const ring = (radiusAt, zAt) => Array.from({ length: segments }, (_, i) => {
+    const theta = i * 2 * Math.PI / segments, r = radiusAt(theta);
+    return vertex(
+      r * Math.cos(theta),
+      r * Math.sin(theta),
+      typeof zAt === "number" ? zAt : zAt(theta)
+    );
+  });
+  const connect = (a, b) => {
+    for (let i = 0; i < segments; i++) {
+      const n = (i + 1) % segments;
+      triangle(a[i], a[n], b[n]);
+      triangle(a[i], b[n], b[i]);
+    }
+  };
+  const cap = (a, z, up) => {
+    const c = vertex(0, 0, z);
+    for (let i = 0; i < segments; i++) {
+      const n = (i + 1) % segments;
+      up ? triangle(c, a[i], a[n]) : triangle(c, a[n], a[i]);
+    }
+  };
+  let previous = [];
+  const add = (radiusAt, zAt) => {
+    const r = ring(radiusAt, zAt);
+    if (previous.length) connect(previous, r);
+    previous = r;
+    return r;
+  };
+  const major = p.diameter / 2, minor = p.threadRootDiameter / 2, pitch = p.threadPitch;
+  const shaftEnd = -p.headHeight - p.underHeadRadius * (Math.sqrt(2) - 1);
+  const steps = p.showThreads ? Math.ceil((shaftEnd + p.length) / pitch * axial) : 1;
+  if ((steps + 100) * segments > 4e5)
+    throw new Error("Screw exceeds mesh resolution limit");
+  const levels = /* @__PURE__ */ new Set([
+    -p.length,
+    -p.length + p.tipChamfer,
+    shaftEnd
+  ]);
+  if (p.showThreads)
+    for (let i = 0; i <= steps; i++)
+      levels.add(-p.length + (shaftEnd + p.length) * i / steps);
+  for (const z of [...levels].sort((a, b) => a - b)) {
+    const r = add((theta) => {
+      const phase = (((z + p.length) / pitch - (p.threadHand === "right" ? 1 : -1) * theta / (2 * Math.PI)) % 1 + 1) % 1;
+      const d = Math.min(phase, 1 - phase);
+      const groove = Math.min(
+        major - minor,
+        Math.max(0, (d - 1 / 16) * pitch * Math.sqrt(3))
+      );
+      const thread = p.showThreads ? major - groove : major;
+      return Math.min(
+        thread,
+        major - Math.max(0, p.tipChamfer - (z + p.length))
+      );
+    }, z);
+    if (z === -p.length) cap(r, z, false);
+  }
+  add(() => major, shaftEnd);
+  const filletCenterR = major + p.underHeadRadius;
+  const filletCenterZ = shaftEnd;
+  for (let i = 1; i <= 16; i++) {
+    const angle = Math.PI - (Math.PI - 3 * Math.PI / 4) * i / 16;
+    add(
+      () => filletCenterR + p.underHeadRadius * Math.cos(angle),
+      filletCenterZ + p.underHeadRadius * Math.sin(angle)
+    );
+  }
+  const hexRadius = (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);
+  cap(previous, -p.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/models/flatheadscrew/FlatHeadScrew.tsx
+function createFlatHeadScrewGeom(input, options) {
+  return indexedMeshToGeom3(createFlatHeadScrewMesh(input, options));
+}
+function FlatHeadScrew({
+  color = "#737e8f",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createFlatHeadScrewGeom(props) }) });
+}
+
+// lib/models/flatheadscrew/register.tsx
+var model = defineModelRenderer({
+  name: "flatheadscrew",
+  schema: flatHeadScrewModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlatHeadScrew, { ...props }),
+  pads: "none"
+});
+function register(registry) {
+  registry.register(model);
+}
+
+// lib/models/flexscreen/register.tsx
+import { flexScreenModelDefinitionSchema } from "@tscircuit/modelprinter";
+
 // lib/Screen.tsx
 var Screen = ({
   width: width10 = 30,
@@ -898,34 +1053,19 @@ var FlexScreen = (props) => {
 };
 
 // lib/models/flexscreen/register.tsx
-var model = defineModelRenderer({
+var model2 = defineModelRenderer({
   name: "flexscreen",
   schema: flexScreenModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlexScreen, { ...props }),
   pads: "footprinter"
 });
-function register(registry) {
-  registry.register(model);
+function register2(registry) {
+  registry.register(model2);
 }
 
 // lib/models/helicalgear/register.tsx
 import { helicalGearModelDefinitionSchema } from "@tscircuit/modelprinter";
 
-// 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,
@@ -1126,14 +1266,14 @@ function HelicalGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/helicalgear/register.tsx
-var model2 = defineModelRenderer({
+var model3 = defineModelRenderer({
   name: "helicalgear",
   schema: helicalGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HelicalGear, { ...props }),
   pads: "none"
 });
-function register2(registry) {
-  registry.register(model2);
+function register3(registry) {
+  registry.register(model3);
 }
 
 // lib/models/hexbolt/register.tsx
@@ -1274,14 +1414,14 @@ function HexBolt({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/hexbolt/register.tsx
-var model3 = defineModelRenderer({
+var model4 = defineModelRenderer({
   name: "hexbolt",
   schema: hexBoltModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexBolt, { ...props }),
   pads: "none"
 });
-function register3(registry) {
-  registry.register(model3);
+function register4(registry) {
+  registry.register(model4);
 }
 
 // lib/models/hexsocketbolt/register.tsx
@@ -1393,14 +1533,14 @@ function HexSocketBolt({
 }
 
 // lib/models/hexsocketbolt/register.tsx
-var model4 = defineModelRenderer({
+var model5 = defineModelRenderer({
   name: "hexsocketbolt",
   schema: hexSocketBoltModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexSocketBolt, { ...props }),
   pads: "none"
 });
-function register4(registry) {
-  registry.register(model4);
+function register5(registry) {
+  registry.register(model5);
 }
 
 // lib/models/nema/register.tsx
@@ -1669,14 +1809,233 @@ var NEMA17 = (props) => /* @__PURE__ */ jsx(NemaMotor, { ...props, nemaSize: 17
 var NEMA23 = (props) => /* @__PURE__ */ jsx(NemaMotor, { ...props, nemaSize: 23 });
 
 // lib/models/nema/register.tsx
-var model5 = defineModelRenderer({
+var model6 = defineModelRenderer({
   name: "nema",
   schema: nemaMotorModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(NemaMotor, { ...props }),
   pads: "none"
 });
-function register5(registry) {
-  registry.register(model5);
+function register6(registry) {
+  registry.register(model6);
+}
+
+// lib/models/panscrew/register.tsx
+import { panScrewModelDefinitionSchema } from "@tscircuit/modelprinter";
+
+// lib/models/panscrew/mesh.ts
+import {
+  panScrewModelPropsSchema
+} from "@tscircuit/modelprinter";
+function createPanScrewMesh(input, options = {}) {
+  const p = panScrewModelPropsSchema.parse(input);
+  const segments = options.radialSegments ?? 96;
+  const axial = options.threadStepsPerTurn ?? 24;
+  if (!Number.isInteger(segments) || segments < 24 || segments > 192 || segments % 24 !== 0 || !Number.isInteger(axial) || axial < 24 || axial > 96)
+    throw new Error(
+      "Screw mesh resolution requires 24..192 radial segments divisible by 24 and 24..96 thread steps"
+    );
+  const positions = [], indices = [];
+  const welded = /* @__PURE__ */ new Map();
+  const vertex = (x, y, z) => {
+    const key = [x, y, z].map((v) => Math.round(v * 1e10)).join(":");
+    const existing = welded.get(key);
+    if (existing !== void 0) return existing;
+    const index = positions.length / 3;
+    positions.push(x, y, z);
+    welded.set(key, index);
+    return index;
+  };
+  const triangle = (a, b, c) => {
+    if (a === b || b === c || c === a) return;
+    const point2 = (i) => positions.slice(3 * i, 3 * i + 3);
+    const A = point2(a), B = point2(b), C = point2(c);
+    const u = B.map((v2, i) => v2 - A[i]), v = C.map((w, i) => w - A[i]);
+    const area = Math.hypot(
+      u[1] * v[2] - u[2] * v[1],
+      u[2] * v[0] - u[0] * v[2],
+      u[0] * v[1] - u[1] * v[0]
+    );
+    if (area > 1e-12) indices.push(a, b, c);
+  };
+  const ring = (radiusAt, zAt) => Array.from({ length: segments }, (_, i) => {
+    const theta = i * 2 * Math.PI / segments, r = radiusAt(theta);
+    return vertex(
+      r * Math.cos(theta),
+      r * Math.sin(theta),
+      typeof zAt === "number" ? zAt : zAt(theta)
+    );
+  });
+  const connect = (a, b) => {
+    for (let i = 0; i < segments; i++) {
+      const n = (i + 1) % segments;
+      triangle(a[i], a[n], b[n]);
+      triangle(a[i], b[n], b[i]);
+    }
+  };
+  const cap = (a, z, up) => {
+    const c = vertex(0, 0, z);
+    for (let i = 0; i < segments; i++) {
+      const n = (i + 1) % segments;
+      up ? triangle(c, a[i], a[n]) : triangle(c, a[n], a[i]);
+    }
+  };
+  let previous = [];
+  const add = (radiusAt, zAt) => {
+    const r = ring(radiusAt, zAt);
+    if (previous.length) connect(previous, r);
+    previous = r;
+    return r;
+  };
+  const major = p.diameter / 2, minor = p.threadRootDiameter / 2, pitch = p.threadPitch;
+  const shaftEnd = -p.underHeadRadius;
+  const steps = p.showThreads ? Math.ceil((shaftEnd + p.length) / pitch * axial) : 1;
+  if ((steps + 160) * segments > 4e5)
+    throw new Error("Screw exceeds mesh resolution limit");
+  const levels = /* @__PURE__ */ new Set([
+    -p.length,
+    -p.length + p.tipChamfer,
+    shaftEnd
+  ]);
+  if (p.showThreads)
+    for (let i = 0; i <= steps; i++)
+      levels.add(-p.length + (shaftEnd + p.length) * i / steps);
+  for (const z of [...levels].sort((a, b) => a - b)) {
+    const r = add((theta) => {
+      const phase = (((z + p.length) / pitch - (p.threadHand === "right" ? 1 : -1) * theta / (2 * Math.PI)) % 1 + 1) % 1;
+      const d = Math.min(phase, 1 - phase);
+      const groove = Math.min(
+        major - minor,
+        Math.max(0, (d - 1 / 16) * pitch * Math.sqrt(3))
+      );
+      const thread = p.showThreads ? major - groove : major;
+      return Math.min(
+        thread,
+        major - Math.max(0, p.tipChamfer - (z + p.length))
+      );
+    }, z);
+    if (z === -p.length) cap(r, z, false);
+  }
+  add(() => major, shaftEnd);
+  const filletCenterR = major + p.underHeadRadius;
+  const filletCenterZ = shaftEnd;
+  for (let i = 1; i <= 16; i++) {
+    const angle = Math.PI - (Math.PI - Math.PI / 2) * i / 16;
+    add(
+      () => filletCenterR + p.underHeadRadius * Math.cos(angle),
+      filletCenterZ + p.underHeadRadius * Math.sin(angle)
+    );
+  }
+  const crown = (r) => p.headHeight - p.crownRadius + Math.sqrt(p.crownRadius * p.crownRadius - r * r);
+  const rad265 = p.recessOuterWingAngle * Math.PI / 180, rad28 = p.recessInnerWingAngle * Math.PI / 180;
+  const tg = (p.recessReferenceDiameter - p.recessG) / 2 / Math.tan(rad265);
+  const totalDepth = tg + p.recessG / 2 * Math.tan(rad28);
+  const tb = tg + (p.recessG - p.recessB) / 2 * Math.tan(rad28);
+  const beta = p.recessBeta * Math.PI / 180;
+  const alphaProjected = Math.atan(
+    Math.tan(p.recessAlpha * Math.PI / 360) / Math.cos(beta)
+  );
+  const cornerProjected = Math.atan(
+    Math.tan(46 * Math.PI / 180) / Math.cos(beta)
+  );
+  const dre = p.recessE / 2 / Math.tan(alphaProjected);
+  const cornerRadius = (z, theta) => {
+    const depth = p.recessReferencePlaneHeight - z;
+    const b = p.recessB / 2 - (depth - tb) * Math.tan(beta);
+    const delta = Math.abs(
+      (theta - Math.PI / 4 + Math.PI / 4 + 4 * Math.PI) % (Math.PI / 2) - Math.PI / 4
+    );
+    const ca = Math.cos(delta), sa = Math.sin(delta);
+    const tanA = Math.tan(alphaProjected), tanC = Math.tan(cornerProjected);
+    const first = tanA * b / (tanA * ca - sa);
+    const corner = first * ca <= b + dre ? first : (tanC * (b + dre) - p.recessE / 2) / (tanC * ca - sa);
+    return Math.max(0, corner);
+  };
+  const recessRadius = (z, theta) => {
+    const depth = p.recessReferencePlaneHeight - z;
+    const outer = depth <= tg ? p.recessReferenceDiameter / 2 - depth * Math.tan(rad265) : (totalDepth - depth) / Math.tan(rad28);
+    return Math.max(0, Math.min(outer, cornerRadius(z, theta)));
+  };
+  const entryRadius = p.recessRadius, sphereZ = p.headHeight - p.crownRadius, slope = Math.tan(rad265), line = p.recessReferenceDiameter / 2 - slope * p.recessReferencePlaneHeight + entryRadius / Math.cos(rad265), offset = slope * sphereZ + line, innerSphere = p.crownRadius - entryRadius, centerAboveSphere = (-slope * offset + Math.sqrt((1 + slope * slope) * innerSphere ** 2 - offset ** 2)) / (1 + slope * slope), entryCenterZ = sphereZ + centerAboveSphere, entryCenterR = slope * entryCenterZ + line, entryStart = Math.atan2(centerAboveSphere, entryCenterR), entryEnd = Math.PI - rad265, mouthR = entryCenterR + entryRadius * Math.cos(entryStart), wallZ = entryCenterZ + entryRadius * Math.sin(entryEnd);
+  add(() => p.headDiameter / 2, 0);
+  add(() => p.headDiameter / 2, crown(p.headDiameter / 2));
+  const opening = Array.from({ length: segments }, (_, i) => {
+    const theta = i * 2 * Math.PI / segments;
+    let lo = 0, hi = mouthR;
+    for (let n = 0; n < 48; n++) {
+      const r = (lo + hi) / 2;
+      if (r < cornerRadius(crown(r), theta)) lo = r;
+      else hi = r;
+    }
+    return (lo + hi) / 2;
+  });
+  for (let n = 1; n <= 20; n++) {
+    const r = (theta) => {
+      const i = Math.round(theta * segments / (2 * Math.PI)) % segments;
+      return p.headDiameter / 2 + (opening[i] - p.headDiameter / 2) * n / 20;
+    };
+    add(r, (theta) => crown(r(theta)));
+  }
+  const entryClips = Array.from({ length: segments }, (_, i) => {
+    const theta = i * 2 * Math.PI / segments;
+    const point2 = (angle2) => ({
+      r: entryCenterR + entryRadius * Math.cos(angle2),
+      z: entryCenterZ + entryRadius * Math.sin(angle2)
+    });
+    const outside = (angle2) => {
+      const q = point2(angle2);
+      return q.r > cornerRadius(q.z, theta);
+    };
+    if (!outside(entryStart)) return { angle: entryStart, ...point2(entryStart) };
+    if (outside(entryEnd))
+      return { angle: entryEnd, r: cornerRadius(wallZ, theta), z: wallZ };
+    let lo = entryStart, hi = entryEnd;
+    for (let n = 0; n < 48; n++) {
+      const angle2 = (lo + hi) / 2;
+      if (outside(angle2)) lo = angle2;
+      else hi = angle2;
+    }
+    const angle = (lo + hi) / 2;
+    return { angle, ...point2(angle) };
+  });
+  for (let n = 0; n <= 24; n++) {
+    const angle = entryStart + (entryEnd - entryStart) * n / 24;
+    const r = entryCenterR + entryRadius * Math.cos(angle), z = entryCenterZ + entryRadius * Math.sin(angle);
+    const clip = (theta) => entryClips[Math.round(theta * segments / (2 * Math.PI)) % segments];
+    add(
+      (theta) => angle <= clip(theta).angle ? clip(theta).r : r,
+      (theta) => angle <= clip(theta).angle ? clip(theta).z : z
+    );
+  }
+  const floor = p.recessReferencePlaneHeight - totalDepth;
+  const driveLevels = /* @__PURE__ */ new Set([p.recessReferencePlaneHeight - tg]);
+  for (let n = 1; n < 48; n++)
+    driveLevels.add(wallZ + (floor - wallZ) * n / 48);
+  for (const z of [...driveLevels].filter((z2) => z2 < wallZ && z2 > floor).sort((a, b) => b - a)) {
+    add((theta) => recessRadius(z, theta), z);
+  }
+  const point = vertex(0, 0, floor);
+  for (let i = 0; i < segments; i++)
+    triangle(point, previous[i], previous[(i + 1) % segments]);
+  return { positions, indices };
+}
+
+// lib/models/panscrew/PanScrew.tsx
+function createPanScrewGeom(input, options) {
+  return indexedMeshToGeom3(createPanScrewMesh(input, options));
+}
+function PanScrew({ color = "#737e8f", ...props }) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createPanScrewGeom(props) }) });
+}
+
+// lib/models/panscrew/register.tsx
+var model7 = defineModelRenderer({
+  name: "panscrew",
+  schema: panScrewModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(PanScrew, { ...props }),
+  pads: "none"
+});
+function register7(registry) {
+  registry.register(model7);
 }
 
 // lib/models/sheetmetal/register.tsx
@@ -1836,14 +2195,14 @@ function SheetMetal({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/sheetmetal/register.tsx
-var model6 = defineModelRenderer({
+var model8 = defineModelRenderer({
   name: "sheetmetal",
   schema: sheetMetalModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SheetMetal, { ...props }),
   pads: "none"
 });
-function register6(registry) {
-  registry.register(model6);
+function register8(registry) {
+  registry.register(model8);
 }
 
 // lib/models/spurgear/register.tsx
@@ -1858,14 +2217,14 @@ function SpurGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/spurgear/register.tsx
-var model7 = defineModelRenderer({
+var model9 = defineModelRenderer({
   name: "spurgear",
   schema: spurGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SpurGear, { ...props }),
   pads: "none"
 });
-function register7(registry) {
-  registry.register(model7);
+function register9(registry) {
+  registry.register(model9);
 }
 
 // lib/models/wormgear/register.tsx
@@ -2057,14 +2416,14 @@ function WormGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/wormgear/register.tsx
-var model8 = defineModelRenderer({
+var model10 = defineModelRenderer({
   name: "wormgear",
   schema: wormGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(WormGear, { ...props }),
   pads: "none"
 });
-function register8(registry) {
-  registry.register(model8);
+function register10(registry) {
+  registry.register(model10);
 }
 
 // lib/generated/model-renderers.ts
@@ -2077,6 +2436,8 @@ function registerAllModelRenderers(registry) {
   register6(registry);
   register7(registry);
   register8(registry);
+  register9(registry);
+  register10(registry);
 }
 
 // lib/default-model-registry.ts
@@ -9633,10 +9994,10 @@ var SOT143 = ({ footprint = "sot143" }) => {
 var Footprinter3d = ({ footprint }) => {
   const modelFn = mp3.string(footprint.split("_", 1)[0]).params().fn;
   if (mp3.getModelNames().includes(modelFn)) {
-    const model9 = mp3.string(footprint).json();
-    const renderer = modelRendererRegistry.get(model9.fn);
+    const model11 = mp3.string(footprint).json();
+    const renderer = modelRendererRegistry.get(model11.fn);
     if (renderer) {
-      return renderer.render(model9);
+      return renderer.render(model11);
     }
   }
   let normalizedFootprint = footprint;
@@ -10587,6 +10948,7 @@ function createJSCADRenderer(jscad4) {
   return { createJSCADRoot };
 }
 export {
+  FlatHeadScrew,
   Fragment,
   HelicalGear,
   HexBolt,
@@ -10595,10 +10957,13 @@ export {
   NEMA23,
   NEMA8,
   NemaMotor,
+  PanScrew,
   SheetMetal,
   SpurGear,
   WormGear,
   convertCSGToThreeGeom,
+  createFlatHeadScrewGeom,
+  createFlatHeadScrewMesh,
   createHelicalGearGeom,
   createHelicalGearMesh,
   createHexBoltGeom,
@@ -10606,6 +10971,8 @@ export {
   createHexSocketBoltGeom,
   createHexSocketBoltMesh,
   createJSCADRenderer,
+  createPanScrewGeom,
+  createPanScrewMesh,
   createSheetMetalGeom,
   createSheetMetalMesh,
   createSpurGearGeom,