jscad-electronics 0.0.205 → 0.0.207

package/dist/vanilla.js

@@ -183,24 +183,24 @@ var FootprintPlatedHole = ({
 import { buttonScrewModelDefinitionSchema } from "@tscircuit/modelprinter";
 
 // lib/model-registry.ts
-function defineModelRenderer(model20) {
-  return model20;
+function defineModelRenderer(model22) {
+  return model22;
 }
 var ModelRendererRegistry = class {
   models = /* @__PURE__ */ new Map();
-  register(model20) {
-    if (typeof model20.name !== "string" || !/^[a-z]+$/.test(model20.name)) {
+  register(model22) {
+    if (typeof model22.name !== "string" || !/^[a-z]+$/.test(model22.name)) {
       throw new Error(
         "Model renderer names must contain only lowercase letters"
       );
     }
-    if (this.models.has(model20.name)) {
-      throw new Error(`Model renderer "${model20.name}" is already registered`);
+    if (this.models.has(model22.name)) {
+      throw new Error(`Model renderer "${model22.name}" is already registered`);
     }
-    if (model20.pads !== "none" && model20.pads !== "footprinter") {
+    if (model22.pads !== "none" && model22.pads !== "footprinter") {
       throw new Error('Model renderer pads must be "none" or "footprinter"');
     }
-    const { name, schema, render: render2, pads } = model20;
+    const { name, schema, render: render2, pads } = model22;
     this.models.set(name, {
       name,
       schema,
@@ -454,6 +454,314 @@ function register2(registry) {
   registry.register(model2);
 }
 
+// lib/models/clampingshaftcollar/register.tsx
+import { clampingShaftCollarModelDefinitionSchema } from "@tscircuit/modelprinter";
+
+// lib/models/clampingshaftcollar/mesh.ts
+import jscad3 from "@jscad/modeling";
+import {
+  clampingShaftCollarModelPropsSchema,
+  getClampingShaftCollarDimensions
+} from "@tscircuit/modelprinter";
+
+// lib/mechanical/shaft-mount-geometry.ts
+import jscad2 from "@jscad/modeling";
+var bodySegments = 64;
+var threadSegments = 24;
+var samplesPerTurn = 12;
+function assertShaftMountResolution(holes) {
+  let triangles = 0;
+  for (const hole of holes) {
+    const steps = hole.threadPitch ? Math.ceil(hole.depth / hole.threadPitch * samplesPerTurn) : 1;
+    if (!Number.isFinite(steps) || steps > 768)
+      throw new Error(
+        "Shaft mount exceeds mesh resolution limit (64 thread turns per hole)"
+      );
+    triangles += (steps + 1) * threadSegments * 2;
+  }
+  if (triangles > 1e5)
+    throw new Error("Shaft mount exceeds total mesh resolution limit");
+}
+function createAnnularSleeve({
+  outerRadius,
+  boreARadius,
+  boreBRadius = boreARadius,
+  length,
+  chamfer,
+  stepZ = length / 2
+}) {
+  const halfAngle = Math.PI / bodySegments;
+  const cosine = Math.cos(halfAngle);
+  if ((Math.max(boreARadius, boreBRadius) + chamfer) / cosine >= (outerRadius - chamfer) * cosine - 1e-6)
+    throw new Error(
+      "Shaft mount wall/chamfer ligament exceeds mesh resolution limit"
+    );
+  const raw = [
+    [0, outerRadius - chamfer, false],
+    [chamfer, outerRadius, false],
+    [length - chamfer, outerRadius, false],
+    [length, outerRadius - chamfer, false],
+    [length, boreBRadius + chamfer, true],
+    [length - chamfer, boreBRadius, true],
+    [stepZ, boreBRadius, true],
+    [stepZ, boreARadius, true],
+    [chamfer, boreARadius, true],
+    [0, boreARadius + chamfer, true]
+  ];
+  const profile = raw.filter(
+    ([z, r], i) => i === 0 || z !== raw[i - 1][0] || r !== raw[i - 1][1]
+  );
+  const positions = [];
+  const indices = [];
+  for (const [z, r, isBore] of profile)
+    for (let i = 0; i < bodySegments; i++) {
+      const angle = (i + (isBore ? 0.5 : 0)) * Math.PI * 2 / bodySegments;
+      const radius = isBore ? r / cosine : r;
+      positions.push(radius * Math.cos(angle), radius * Math.sin(angle), z);
+    }
+  for (let row = 0; row < profile.length; row++)
+    for (let i = 0; i < bodySegments; i++) {
+      const next = (i + 1) % bodySegments;
+      const a = row * bodySegments + i, b = row * bodySegments + next;
+      const c = (row + 1) % profile.length * bodySegments + next, d = (row + 1) % profile.length * bodySegments + i;
+      indices.push(a, b, c, a, c, d);
+    }
+  return indexedMeshToGeom3({ positions, indices });
+}
+function createMountingHoleCutter(hole) {
+  assertShaftMountResolution([hole]);
+  const pitch = hole.threadPitch;
+  const steps = pitch ? Math.max(2, Math.ceil(hole.depth / pitch * samplesPerTurn)) : 1;
+  const segments = pitch ? threadSegments : 48;
+  const extension = 1e-4;
+  const radius = hole.diameter / 2;
+  const threadDepth = pitch ? Math.min(pitch * 0.541266, radius * 0.8) : 0;
+  const hand = hole.threadHand === "left" ? -1 : 1;
+  const positions = [];
+  const indices = [];
+  const [dx, dy, dz] = hole.direction;
+  if (Math.abs(dz) > 1e-10 || Math.abs(Math.hypot(dx, dy) - 1) > 1e-10)
+    throw new Error("Expected a horizontal unit hole axis");
+  const push = (x, y, z) => {
+    positions.push(
+      hole.start[0] + y * dy + z * dx,
+      hole.start[1] - y * dx + z * dy,
+      hole.start[2] + x
+    );
+  };
+  for (let row = 0; row <= steps; row++) {
+    const z = -extension + (hole.depth + 2 * extension) * row / steps;
+    for (let i = 0; i < segments; i++) {
+      const angle = i * Math.PI * 2 / segments;
+      const phase = pitch ? ((z / pitch - hand * angle / (Math.PI * 2)) % 1 + 1) % 1 : 0;
+      const distance2 = Math.min(phase, 1 - phase);
+      const r = radius - Math.min(
+        threadDepth,
+        Math.max(0, (distance2 - 1 / 8) * (pitch ?? 0) * Math.sqrt(3))
+      );
+      push(r * Math.cos(angle), r * Math.sin(angle), z);
+    }
+  }
+  for (let row = 0; row < steps; row++)
+    for (let i = 0; i < segments; i++) {
+      const next = (i + 1) % segments;
+      const a = row * segments + i, b = row * segments + next, c = (row + 1) * segments + next, d = (row + 1) * segments + i;
+      indices.push(a, b, c, a, c, d);
+    }
+  for (const end of [0, steps]) {
+    const center = positions.length / 3;
+    push(0, 0, end === 0 ? -extension : hole.depth + extension);
+    for (let i = 0; i < segments; i++) {
+      const a = end * segments + i, b = end * segments + (i + 1) % segments;
+      indices.push(center, end === 0 ? b : a, end === 0 ? a : b);
+    }
+  }
+  return indexedMeshToGeom3({ positions, indices });
+}
+function subtractShaftMountParts(body, ...cutters) {
+  const factor = 100;
+  const scaled = [body, ...cutters].map(
+    (geometry) => jscad2.transforms.scale([factor, factor, factor], geometry)
+  );
+  const result = jscad2.booleans.subtract(scaled[0], ...scaled.slice(1));
+  return jscad2.transforms.scale([1 / factor, 1 / factor, 1 / factor], result);
+}
+function finishShaftMountMesh(geometry) {
+  const positions = [];
+  const vertices = /* @__PURE__ */ new Map();
+  const tolerance = 1e-6;
+  const weld = (point) => {
+    const cell = point.map((v) => Math.floor(v / tolerance));
+    for (let x = -1; x <= 1; x++)
+      for (let y = -1; y <= 1; y++)
+        for (let z = -1; z <= 1; z++) {
+          const nearby = vertices.get(
+            [cell[0] + x, cell[1] + y, cell[2] + z].join(",")
+          ) ?? [];
+          for (const index2 of nearby)
+            if (Math.hypot(
+              ...point.map((v, axis) => v - positions[index2 * 3 + axis])
+            ) < tolerance)
+              return index2;
+        }
+    const index = positions.length / 3;
+    positions.push(...point);
+    const key = cell.join(",");
+    vertices.set(key, [...vertices.get(key) ?? [], index]);
+    return index;
+  };
+  const polygons = jscad2.geometries.geom3.toPolygons(geometry).map(
+    (polygon) => polygon.vertices.map(weld).filter((id, i, ids) => id !== ids[(i + ids.length - 1) % ids.length])
+  ).map((ids) => [...new Set(ids)]).filter((ids) => ids.length >= 3).filter((ids) => {
+    let longest = 0;
+    let origin = [];
+    let direction = [];
+    for (let i = 0; i < ids.length; i++)
+      for (let j = i + 1; j < ids.length; j++) {
+        const a = positions.slice(ids[i] * 3, ids[i] * 3 + 3);
+        const delta = positions.slice(ids[j] * 3, ids[j] * 3 + 3).map((v, axis) => v - a[axis]);
+        const squared = delta.reduce((sum, v) => sum + v * v, 0);
+        if (squared > longest) {
+          longest = squared;
+          origin = a;
+          direction = delta;
+        }
+      }
+    return ids.some((id) => {
+      const delta = positions.slice(id * 3, id * 3 + 3).map((v, axis) => v - origin[axis]);
+      const t = delta.reduce((sum, v, axis) => sum + v * direction[axis], 0) / longest;
+      return Math.hypot(...delta.map((v, axis) => v - t * direction[axis])) >= tolerance;
+    });
+  });
+  const edgeKey = (a, b) => `${Math.min(a, b)},${Math.max(a, b)}`;
+  const edges = /* @__PURE__ */ new Map();
+  for (const polygon of polygons)
+    for (let i = 0; i < polygon.length; i++) {
+      const a = polygon[i], b = polygon[(i + 1) % polygon.length], key = edgeKey(a, b);
+      const edge = edges.get(key) ?? { a, b, count: 0 };
+      edge.count++;
+      edges.set(key, edge);
+    }
+  const unmatched = [...edges.values()].filter((edge) => edge.count === 1);
+  const candidates = [...new Set(unmatched.flatMap((edge) => [edge.a, edge.b]))];
+  const splits = /* @__PURE__ */ new Map();
+  for (const { a, b } of unmatched) {
+    const origin = positions.slice(a * 3, a * 3 + 3);
+    const direction = positions.slice(b * 3, b * 3 + 3).map((v, axis) => v - origin[axis]);
+    const squared = direction.reduce((sum, v) => sum + v * v, 0);
+    const points = [];
+    for (const id of candidates) {
+      if (id === a || id === b) continue;
+      const delta = positions.slice(id * 3, id * 3 + 3).map((v, axis) => v - origin[axis]);
+      const t = delta.reduce((sum, v, axis) => sum + v * direction[axis], 0) / squared;
+      if (t <= 0 || t >= 1) continue;
+      const distance2 = Math.hypot(
+        ...delta.map((v, axis) => v - t * direction[axis])
+      );
+      if (distance2 < tolerance) points.push({ id, t });
+    }
+    points.sort((p, q) => p.t - q.t);
+    splits.set(
+      `${a},${b}`,
+      points.map((p) => p.id)
+    );
+    splits.set(`${b},${a}`, points.map((p) => p.id).reverse());
+  }
+  const indices = [];
+  for (const polygon of polygons) {
+    const perimeter = polygon.flatMap((a, i) => [
+      a,
+      ...(splits.get(`${a},${polygon[(i + 1) % polygon.length]}`) ?? []).filter((id) => !polygon.includes(id))
+    ]);
+    const unique = perimeter.filter(
+      (id, i) => id !== perimeter[(i + perimeter.length - 1) % perimeter.length]
+    );
+    if (unique.length === 3) {
+      indices.push(...unique);
+      continue;
+    }
+    const center = positions.length / 3;
+    positions.push(
+      ...[0, 1, 2].map(
+        (axis) => unique.reduce((sum, id) => sum + positions[id * 3 + axis], 0) / unique.length
+      )
+    );
+    for (let i = 0; i < unique.length; i++)
+      indices.push(center, unique[i], unique[(i + 1) % unique.length]);
+  }
+  const compact = [];
+  const remap = /* @__PURE__ */ new Map();
+  return {
+    positions: compact,
+    indices: indices.map((index) => {
+      let next = remap.get(index);
+      if (next === void 0) {
+        next = compact.length / 3;
+        remap.set(index, next);
+        compact.push(...positions.slice(index * 3, index * 3 + 3));
+      }
+      return next;
+    })
+  };
+}
+
+// lib/models/clampingshaftcollar/mesh.ts
+function createClampingShaftCollarMesh(input) {
+  const props = clampingShaftCollarModelPropsSchema.parse(input);
+  const dimensions = getClampingShaftCollarDimensions(props);
+  assertShaftMountResolution([dimensions.threadedHole]);
+  const body = createAnnularSleeve({
+    outerRadius: props.outerDiameter / 2,
+    boreARadius: props.boreDiameter / 2,
+    length: props.width,
+    chamfer: props.chamfer
+  });
+  const s = dimensions.split;
+  const epsilon = 1e-4;
+  const slit = jscad3.primitives.cuboid({
+    size: [
+      s.xMax - s.xMin + epsilon,
+      s.yMax - s.yMin,
+      s.zMax - s.zMin + 2 * epsilon
+    ],
+    center: [
+      (s.xMax + s.xMin + epsilon) / 2,
+      (s.yMax + s.yMin) / 2,
+      (s.zMax + s.zMin) / 2
+    ]
+  });
+  return finishShaftMountMesh(
+    subtractShaftMountParts(
+      body,
+      slit,
+      createMountingHoleCutter(dimensions.clearanceHole),
+      createMountingHoleCutter(dimensions.threadedHole)
+    )
+  );
+}
+
+// lib/models/clampingshaftcollar/ClampingShaftCollar.tsx
+function createClampingShaftCollarGeom(input) {
+  return indexedMeshToGeom3(createClampingShaftCollarMesh(input));
+}
+function ClampingShaftCollar({
+  color = "#737e8f",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createClampingShaftCollarGeom(props) }) });
+}
+
+// lib/models/clampingshaftcollar/register.tsx
+var model3 = defineModelRenderer({
+  name: "clampingshaftcollar",
+  schema: clampingShaftCollarModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(ClampingShaftCollar, { ...props }),
+  pads: "none"
+});
+function register3(registry) {
+  registry.register(model3);
+}
+
 // lib/models/compressionspring/register.tsx
 import { compressionSpringModelDefinitionSchema } from "@tscircuit/modelprinter";
 
@@ -657,14 +965,14 @@ function CompressionSpring({
 }
 
 // lib/models/compressionspring/register.tsx
-var model3 = defineModelRenderer({
+var model4 = defineModelRenderer({
   name: "compressionspring",
   schema: compressionSpringModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(CompressionSpring, { ...props }),
   pads: "none"
 });
-function register3(registry) {
-  registry.register(model3);
+function register4(registry) {
+  registry.register(model4);
 }
 
 // lib/models/flangedbushing/register.tsx
@@ -720,14 +1028,14 @@ function FlangedBushing({
 }
 
 // lib/models/flangedbushing/register.tsx
-var model4 = defineModelRenderer({
+var model5 = defineModelRenderer({
   name: "flangedbushing",
   schema: flangedBushingModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlangedBushing, { ...props }),
   pads: "none"
 });
-function register4(registry) {
-  registry.register(model4);
+function register5(registry) {
+  registry.register(model5);
 }
 
 // lib/models/flatheadscrew/register.tsx
@@ -860,14 +1168,14 @@ function FlatHeadScrew({
 }
 
 // lib/models/flatheadscrew/register.tsx
-var model5 = defineModelRenderer({
+var model6 = defineModelRenderer({
   name: "flatheadscrew",
   schema: flatHeadScrewModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlatHeadScrew, { ...props }),
   pads: "none"
 });
-function register5(registry) {
-  registry.register(model5);
+function register6(registry) {
+  registry.register(model6);
 }
 
 // lib/models/flexscreen/register.tsx
@@ -1545,14 +1853,14 @@ var FlexScreen = (props) => {
 };
 
 // lib/models/flexscreen/register.tsx
-var model6 = defineModelRenderer({
+var model7 = defineModelRenderer({
   name: "flexscreen",
   schema: flexScreenModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlexScreen, { ...props }),
   pads: "footprinter"
 });
-function register6(registry) {
-  registry.register(model6);
+function register7(registry) {
+  registry.register(model7);
 }
 
 // lib/models/helicalgear/register.tsx
@@ -1758,14 +2066,14 @@ function HelicalGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/helicalgear/register.tsx
-var model7 = defineModelRenderer({
+var model8 = defineModelRenderer({
   name: "helicalgear",
   schema: helicalGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HelicalGear, { ...props }),
   pads: "none"
 });
-function register7(registry) {
-  registry.register(model7);
+function register8(registry) {
+  registry.register(model8);
 }
 
 // lib/models/hexbolt/register.tsx
@@ -1906,14 +2214,14 @@ function HexBolt({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/hexbolt/register.tsx
-var model8 = defineModelRenderer({
+var model9 = defineModelRenderer({
   name: "hexbolt",
   schema: hexBoltModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexBolt, { ...props }),
   pads: "none"
 });
-function register8(registry) {
-  registry.register(model8);
+function register9(registry) {
+  registry.register(model9);
 }
 
 // lib/models/hexnut/register.tsx
@@ -2036,14 +2344,14 @@ function HexNut({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/hexnut/register.tsx
-var model9 = defineModelRenderer({
+var model10 = defineModelRenderer({
   name: "hexnut",
   schema: hexNutModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexNut, { ...props }),
   pads: "none"
 });
-function register9(registry) {
-  registry.register(model9);
+function register10(registry) {
+  registry.register(model10);
 }
 
 // lib/models/hexsocketbolt/register.tsx
@@ -2155,24 +2463,24 @@ function HexSocketBolt({
 }
 
 // lib/models/hexsocketbolt/register.tsx
-var model10 = defineModelRenderer({
+var model11 = defineModelRenderer({
   name: "hexsocketbolt",
   schema: hexSocketBoltModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexSocketBolt, { ...props }),
   pads: "none"
 });
-function register10(registry) {
-  registry.register(model10);
+function register11(registry) {
+  registry.register(model11);
 }
 
 // lib/models/nema/register.tsx
 import { nemaMotorModelDefinitionSchema } from "@tscircuit/modelprinter";
 
 // lib/NemaMotor.tsx
-import jscad3 from "@jscad/modeling";
+import jscad5 from "@jscad/modeling";
 
 // lib/utils/nemaMotorWireGeometry.ts
-import jscad2 from "@jscad/modeling";
+import jscad4 from "@jscad/modeling";
 import {
   getJstMotorConnector,
   getNemaMotorReferencePoints
@@ -2190,9 +2498,9 @@ function createNemaMotorWireGeometry(input) {
   if (p.wireConnection === "none") return [];
   const { position } = getNemaMotorReferencePoints(p).wireside;
   const angle = p.wireSideAngle * Math.PI / 180;
-  const place = (geometry) => jscad2.transforms.translate(
+  const place = (geometry) => jscad4.transforms.translate(
     [position.x, position.y, position.z],
-    jscad2.transforms.rotateZ(angle, geometry)
+    jscad4.transforms.rotateZ(angle, geometry)
   );
   if (p.wireConnection === "stubs") {
     const colors = [
@@ -2208,15 +2516,15 @@ function createNemaMotorWireGeometry(input) {
     return Array.from({ length: p.wireCount }, (_, i) => ({
       color: colors[i],
       geometry: place(
-        jscad2.transforms.translate(
+        jscad4.transforms.translate(
           [
             (p.wireLength - 0.15) / 2,
             (i - (p.wireCount - 1) / 2) * p.wireDiameter * 1.5,
             0
           ],
-          jscad2.transforms.rotateY(
+          jscad4.transforms.rotateY(
             Math.PI / 2,
-            jscad2.primitives.cylinder({
+            jscad4.primitives.cylinder({
               height: p.wireLength + 0.15,
               radius: p.wireDiameter / 2,
               segments: 24
@@ -2231,12 +2539,12 @@ function createNemaMotorWireGeometry(input) {
   const wall = pitch === 2 ? 0.6 : 0.3;
   const contactLength = pitch === 2 ? 3.4 : 2.4;
   const contactSize = pitch === 2 ? 0.5 : 0.3;
-  const shell = jscad2.booleans.subtract(
-    jscad2.primitives.cuboid({
+  const shell = jscad4.booleans.subtract(
+    jscad4.primitives.cuboid({
       size: [matingDepth + 0.1, bodyWidth, bodyHeight],
       center: [(matingDepth - 0.1) / 2, 0, 0]
     }),
-    jscad2.primitives.cuboid({
+    jscad4.primitives.cuboid({
       size: [matingDepth - 0.5, bodyWidth - 2 * wall, bodyHeight - 2 * wall],
       center: [matingDepth / 2 + 0.55, 0, 0]
     })
@@ -2246,7 +2554,7 @@ function createNemaMotorWireGeometry(input) {
     ...Array.from({ length: pinCount }, (_, i) => ({
       color: "#b8bec6",
       geometry: place(
-        jscad2.primitives.cuboid({
+        jscad4.primitives.cuboid({
           size: [contactLength, contactSize, contactSize],
           center: [contactLength / 2, (i - (pinCount - 1) / 2) * pitch, 0]
         })
@@ -2354,7 +2662,7 @@ function createNemaMotorSections(input) {
 }
 
 // lib/NemaMotor.tsx
-var generalize = jscad3.modifiers.generalize;
+var generalize = jscad5.modifiers.generalize;
 function NemaMotor({
   bodyColor = "#242830",
   capColor = "#aeb5bd",
@@ -2363,7 +2671,7 @@ function NemaMotor({
   ...props
 }) {
   const p = resolveNemaMotorProps(props);
-  const screw = p.backFace === "screws" ? jscad3.transforms.rotateX(
+  const screw = p.backFace === "screws" ? jscad5.transforms.rotateX(
     Math.PI,
     createHexSocketBoltGeom({
       metricSize: p.backFaceScrewSize,
@@ -2374,14 +2682,14 @@ function NemaMotor({
   const halfPitch = p.backFaceHoleSpacing / 2;
   return /* @__PURE__ */ jsxs(Fragment2, { children: [
     createNemaMotorSections(p).map((section, index) => {
-      const outline = jscad3.geometries.geom2.fromPoints(section.outline);
-      const profile = section.holes.length ? jscad3.booleans.subtract(
+      const outline = jscad5.geometries.geom2.fromPoints(section.outline);
+      const profile = section.holes.length ? jscad5.booleans.subtract(
         outline,
-        ...section.holes.map((h2) => jscad3.geometries.geom2.fromPoints(h2))
+        ...section.holes.map((h2) => jscad5.geometries.geom2.fromPoints(h2))
       ) : outline;
-      const geometry = jscad3.transforms.translate(
+      const geometry = jscad5.transforms.translate(
         [0, 0, section.zMin],
-        jscad3.extrusions.extrudeLinear(
+        jscad5.extrusions.extrudeLinear(
           { height: section.zMax - section.zMin },
           profile
         )
@@ -2414,7 +2722,7 @@ function NemaMotor({
           children: /* @__PURE__ */ jsx(
             Custom,
             {
-              geometry: jscad3.transforms.translate(
+              geometry: jscad5.transforms.translate(
                 [x, y, -p.bodyLength],
                 generalize({ simplify: true }, screw)
               )
@@ -2431,14 +2739,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 model11 = defineModelRenderer({
+var model12 = defineModelRenderer({
   name: "nema",
   schema: nemaMotorModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(NemaMotor, { ...props }),
   pads: "none"
 });
-function register11(registry) {
-  registry.register(model11);
+function register12(registry) {
+  registry.register(model12);
 }
 
 // lib/models/panscrew/register.tsx
@@ -2650,14 +2958,14 @@ function PanScrew({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/panscrew/register.tsx
-var model12 = defineModelRenderer({
+var model13 = defineModelRenderer({
   name: "panscrew",
   schema: panScrewModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(PanScrew, { ...props }),
   pads: "none"
 });
-function register12(registry) {
-  registry.register(model12);
+function register13(registry) {
+  registry.register(model13);
 }
 
 // lib/models/plainbushing/register.tsx
@@ -2720,14 +3028,60 @@ function PlainBushing({
 }
 
 // lib/models/plainbushing/register.tsx
-var model13 = defineModelRenderer({
+var model14 = defineModelRenderer({
   name: "plainbushing",
   schema: plainBushingModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(PlainBushing, { ...props }),
   pads: "none"
 });
-function register13(registry) {
-  registry.register(model13);
+function register14(registry) {
+  registry.register(model14);
+}
+
+// lib/models/shaftcollar/register.tsx
+import { shaftCollarModelDefinitionSchema } from "@tscircuit/modelprinter";
+
+// lib/models/shaftcollar/mesh.ts
+import "@jscad/modeling";
+import {
+  shaftCollarModelPropsSchema,
+  getShaftCollarDimensions
+} from "@tscircuit/modelprinter";
+function createShaftCollarMesh(input) {
+  const props = shaftCollarModelPropsSchema.parse(input);
+  const dimensions = getShaftCollarDimensions(props);
+  assertShaftMountResolution([dimensions.screwHole]);
+  const body = createAnnularSleeve({
+    outerRadius: props.outerDiameter / 2,
+    boreARadius: props.boreDiameter / 2,
+    length: props.width,
+    chamfer: props.chamfer
+  });
+  return finishShaftMountMesh(
+    subtractShaftMountParts(
+      body,
+      createMountingHoleCutter(dimensions.screwHole)
+    )
+  );
+}
+
+// lib/models/shaftcollar/ShaftCollar.tsx
+function createShaftCollarGeom(input) {
+  return indexedMeshToGeom3(createShaftCollarMesh(input));
+}
+function ShaftCollar({ color = "#737e8f", ...props }) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createShaftCollarGeom(props) }) });
+}
+
+// lib/models/shaftcollar/register.tsx
+var model15 = defineModelRenderer({
+  name: "shaftcollar",
+  schema: shaftCollarModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(ShaftCollar, { ...props }),
+  pads: "none"
+});
+function register15(registry) {
+  registry.register(model15);
 }
 
 // lib/models/sheetmetal/register.tsx
@@ -2887,14 +3241,14 @@ function SheetMetal({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/sheetmetal/register.tsx
-var model14 = defineModelRenderer({
+var model16 = defineModelRenderer({
   name: "sheetmetal",
   schema: sheetMetalModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SheetMetal, { ...props }),
   pads: "none"
 });
-function register14(registry) {
-  registry.register(model14);
+function register16(registry) {
+  registry.register(model16);
 }
 
 // lib/models/spurgear/register.tsx
@@ -2909,14 +3263,14 @@ function SpurGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/spurgear/register.tsx
-var model15 = defineModelRenderer({
+var model17 = defineModelRenderer({
   name: "spurgear",
   schema: spurGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SpurGear, { ...props }),
   pads: "none"
 });
-function register15(registry) {
-  registry.register(model15);
+function register17(registry) {
+  registry.register(model17);
 }
 
 // lib/models/tslotextrusion/register.tsx
@@ -3066,14 +3420,14 @@ function TSlotExtrusion({
 }
 
 // lib/models/tslotextrusion/register.tsx
-var model16 = defineModelRenderer({
+var model18 = defineModelRenderer({
   name: "tslotextrusion",
   schema: tSlotExtrusionModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(TSlotExtrusion, { ...props }),
   pads: "none"
 });
-function register16(registry) {
-  registry.register(model16);
+function register18(registry) {
+  registry.register(model18);
 }
 
 // lib/models/tslotgusset/register.tsx
@@ -3126,14 +3480,14 @@ function TSlotGusset({ color = "#8995a3", ...props }) {
 }
 
 // lib/models/tslotgusset/register.tsx
-var model17 = defineModelRenderer({
+var model19 = defineModelRenderer({
   name: "tslotgusset",
   schema: tSlotGussetModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(TSlotGusset, { ...props }),
   pads: "none"
 });
-function register17(registry) {
-  registry.register(model17);
+function register19(registry) {
+  registry.register(model19);
 }
 
 // lib/models/tslotinsidecorner/register.tsx
@@ -3213,14 +3567,14 @@ function TSlotInsideCorner({
 }
 
 // lib/models/tslotinsidecorner/register.tsx
-var model18 = defineModelRenderer({
+var model20 = defineModelRenderer({
   name: "tslotinsidecorner",
   schema: tSlotInsideCornerModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(TSlotInsideCorner, { ...props }),
   pads: "none"
 });
-function register18(registry) {
-  registry.register(model18);
+function register20(registry) {
+  registry.register(model20);
 }
 
 // lib/models/wormgear/register.tsx
@@ -3412,14 +3766,14 @@ function WormGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/wormgear/register.tsx
-var model19 = defineModelRenderer({
+var model21 = defineModelRenderer({
   name: "wormgear",
   schema: wormGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(WormGear, { ...props }),
   pads: "none"
 });
-function register19(registry) {
-  registry.register(model19);
+function register21(registry) {
+  registry.register(model21);
 }
 
 // lib/generated/model-renderers.ts
@@ -3443,6 +3797,8 @@ function registerAllModelRenderers(registry) {
   register17(registry);
   register18(registry);
   register19(registry);
+  register20(registry);
+  register21(registry);
 }
 
 // lib/default-model-registry.ts
@@ -10999,10 +11355,10 @@ var SOT143 = ({ footprint = "sot143" }) => {
 var Footprinter3d = ({ footprint }) => {
   const modelFn = mp3.string(footprint.split("_", 1)[0]).params().fn;
   if (mp3.getModelNames().includes(modelFn)) {
-    const model20 = mp3.string(footprint).json();
-    const renderer = modelRendererRegistry.get(model20.fn);
+    const model22 = mp3.string(footprint).json();
+    const renderer = modelRendererRegistry.get(model22.fn);
     if (renderer) {
-      return renderer.render(model20);
+      return renderer.render(model22);
     }
   }
   let normalizedFootprint = footprint;
@@ -11835,8 +12191,8 @@ function renderNode(node, colorCtx, renderCtx) {
   }
   return (children ?? []).flatMap((c) => renderNode(c, colorCtx, renderCtx));
 }
-function render(root, jscad4) {
-  const geometries = renderNode(root, void 0, { jscad: jscad4 });
+function render(root, jscad7) {
+  const geometries = renderNode(root, void 0, { jscad: jscad7 });
   return {
     geometries: geometries.map(
       (entry) => entry.material ? { ...entry, geom: { ...entry.geom, material: entry.material } } : entry
@@ -11928,24 +12284,24 @@ function convertCSGToThreeGeom(csg) {
 }
 
 // lib/vanilla/index.ts
-function getJscadModelForFootprint(footprint, jscad4) {
+function getJscadModelForFootprint(footprint, jscad7) {
   const vnode = h(Footprinter3d, { footprint });
-  return render(vnode, jscad4);
+  return render(vnode, jscad7);
 }
-function getJscadModelForFootprintWithPads(footprint, jscad4) {
+function getJscadModelForFootprintWithPads(footprint, jscad7) {
   const vnode = h(
     Fragment,
     {},
     h(Footprinter3d, { footprint }),
     h(ExtrudedPads, { footprint })
   );
-  return render(vnode, jscad4);
+  return render(vnode, jscad7);
 }
-function createJSCADRenderer(jscad4) {
+function createJSCADRenderer(jscad7) {
   function createJSCADRoot(container) {
     return {
       render(element) {
-        const { geometries } = render(element, jscad4);
+        const { geometries } = render(element, jscad7);
         container.splice(0, container.length, ...geometries);
       }
     };
@@ -11955,6 +12311,7 @@ function createJSCADRenderer(jscad4) {
 export {
   ButtonScrew,
   CableGrommet,
+  ClampingShaftCollar,
   CompressionSpring,
   FlangedBushing,
   FlatHeadScrew,
@@ -11969,6 +12326,7 @@ export {
   NemaMotor,
   PanScrew,
   PlainBushing,
+  ShaftCollar,
   SheetMetal,
   SpurGear,
   TSlotExtrusion,
@@ -11980,6 +12338,8 @@ export {
   createButtonScrewMesh,
   createCableGrommetGeom,
   createCableGrommetMesh,
+  createClampingShaftCollarGeom,
+  createClampingShaftCollarMesh,
   createCompressionSpringGeom,
   createCompressionSpringMesh,
   createFlangedBushingGeom,
@@ -11999,6 +12359,8 @@ export {
   createPanScrewMesh,
   createPlainBushingGeom,
   createPlainBushingMesh,
+  createShaftCollarGeom,
+  createShaftCollarMesh,
   createSheetMetalGeom,
   createSheetMetalMesh,
   createSpurGearGeom,