jscad-electronics 0.0.204 → 0.0.206

package/dist/vanilla.d.ts

@@ -3,7 +3,7 @@ import { BufferGeometry } from 'three';
 import * as jscadModeling from '@jscad/modeling';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as _jscad_modeling_src_geometries_types from '@jscad/modeling/src/geometries/types';
-import { ButtonScrewModelPropsInput, CableGrommetModelPropsInput, CompressionSpringModelPropsInput, FlangedBushingModelPropsInput, FlatHeadScrewModelPropsInput, SpurGearModelPropsInput, HelicalGearModelPropsInput, HexBoltModelPropsInput, HexNutModelPropsInput, HexSocketBoltModelPropsInput, NemaMotorModelPropsInput, PanScrewModelPropsInput, PlainBushingModelPropsInput, SheetMetalModelPropsInput, TSlotExtrusionModelPropsInput, TSlotInsideCornerModelPropsInput, WormGearModelPropsInput } from '@tscircuit/modelprinter';
+import { ButtonScrewModelPropsInput, CableGrommetModelPropsInput, CompressionSpringModelPropsInput, FlangedBushingModelPropsInput, FlatHeadScrewModelPropsInput, SpurGearModelPropsInput, HelicalGearModelPropsInput, HexBoltModelPropsInput, HexNutModelPropsInput, HexSocketBoltModelPropsInput, NemaMotorModelPropsInput, PanScrewModelPropsInput, PlainBushingModelPropsInput, ShaftCollarModelPropsInput, SheetMetalModelPropsInput, TSlotExtrusionModelPropsInput, TSlotGussetModelPropsInput, TSlotInsideCornerModelPropsInput, WormGearModelPropsInput } from '@tscircuit/modelprinter';
 
 type VNode = {
     type: any;
@@ -243,6 +243,22 @@ type PlainBushingProps = PlainBushingModelPropsInput & {
 declare function createPlainBushingGeom(input: PlainBushingModelPropsInput): _jscad_modeling_src_geometries_types.Geom3;
 declare function PlainBushing({ color, ...props }: PlainBushingProps): react_jsx_runtime.JSX.Element;
 
+type ShaftMountMesh = {
+    positions: number[];
+    indices: number[];
+};
+
+type ShaftCollarMesh = ShaftMountMesh;
+/** Geometry is driven by the corresponding modelprinter schema and hole layout. */
+declare function createShaftCollarMesh(input: ShaftCollarModelPropsInput): ShaftCollarMesh;
+
+type ShaftCollarProps = ShaftCollarModelPropsInput & {
+    color?: string;
+};
+/** Datum and mounting-hole coordinates follow the modelprinter contract. */
+declare function createShaftCollarGeom(input: ShaftCollarModelPropsInput): _jscad_modeling_src_geometries_types.Geom3;
+declare function ShaftCollar({ color, ...props }: ShaftCollarProps): react_jsx_runtime.JSX.Element;
+
 interface SheetMetalMesh {
     positions: number[];
     indices: number[];
@@ -284,6 +300,21 @@ type TSlotExtrusionProps = TSlotExtrusionModelPropsInput & {
 declare function createTSlotExtrusionGeom(input?: TSlotExtrusionModelPropsInput): _jscad_modeling_src_geometries_types.Geom3;
 declare function TSlotExtrusion({ color, ...props }: TSlotExtrusionProps): react_jsx_runtime.JSX.Element;
 
+interface TSlotGussetMesh {
+    positions: number[];
+    indices: number[];
+}
+/** Right triangular flat plate at Z=0..thickness, with both complete through
+ * capsules at the mounting centers/orientations resolved by modelprinter.
+ */
+declare function createTSlotGussetMesh(input?: TSlotGussetModelPropsInput): TSlotGussetMesh;
+
+type TSlotGussetProps = TSlotGussetModelPropsInput & {
+    color?: string;
+};
+declare function createTSlotGussetGeom(input?: TSlotGussetModelPropsInput): _jscad_modeling_src_geometries_types.Geom3;
+declare function TSlotGusset({ color, ...props }: TSlotGussetProps): react_jsx_runtime.JSX.Element;
+
 interface TSlotInsideCornerMesh {
     positions: number[];
     indices: number[];
@@ -327,4 +358,4 @@ declare function createJSCADRenderer(jscad: typeof jscadModeling): {
     };
 };
 
-export { ButtonScrew, type ButtonScrewMesh, type ButtonScrewMeshOptions, type ButtonScrewProps, CableGrommet, type CableGrommetMesh, type CableGrommetMeshOptions, type CableGrommetProps, type ColoredGeom, CompressionSpring, type CompressionSpringMesh, type CompressionSpringMeshOptions, type CompressionSpringProps, FlangedBushing, type FlangedBushingMesh, type FlangedBushingProps, FlatHeadScrew, type FlatHeadScrewMesh, type FlatHeadScrewMeshOptions, type FlatHeadScrewProps, Fragment, HelicalGear, type HelicalGearMesh, type HelicalGearProps, HexBolt, type HexBoltMesh, type HexBoltMeshOptions, type HexBoltProps, HexNut, type HexNutMesh, type HexNutMeshOptions, type HexNutProps, HexSocketBolt, type HexSocketBoltMesh, type HexSocketBoltProps, NEMA17, NEMA23, NEMA8, type NemaFrameMotorProps, NemaMotor, type NemaMotorProps, PanScrew, type PanScrewMesh, type PanScrewMeshOptions, type PanScrewProps, PlainBushing, type PlainBushingMesh, type PlainBushingProps, type RenderResult, SheetMetal, type SheetMetalMesh, type SheetMetalProps, SpurGear, type SpurGearMesh, type SpurGearProps, TSlotExtrusion, type TSlotExtrusionMesh, type TSlotExtrusionProps, TSlotInsideCorner, type TSlotInsideCornerMesh, type TSlotInsideCornerProps, type VNode, WormGear, type WormGearMesh, type WormGearProps, convertCSGToThreeGeom, createButtonScrewGeom, createButtonScrewMesh, createCableGrommetGeom, createCableGrommetMesh, createCompressionSpringGeom, createCompressionSpringMesh, createFlangedBushingGeom, createFlangedBushingMesh, createFlatHeadScrewGeom, createFlatHeadScrewMesh, createHelicalGearGeom, createHelicalGearMesh, createHexBoltGeom, createHexBoltMesh, createHexNutGeom, createHexNutMesh, createHexSocketBoltGeom, createHexSocketBoltMesh, createJSCADRenderer, createPanScrewGeom, createPanScrewMesh, createPlainBushingGeom, createPlainBushingMesh, createSheetMetalGeom, createSheetMetalMesh, createSpurGearGeom, createSpurGearMesh, createTSlotExtrusionGeom, createTSlotExtrusionMesh, createTSlotInsideCornerGeom, createTSlotInsideCornerMesh, createWormGearGeom, createWormGearMesh, getJscadModelForFootprint, getJscadModelForFootprintWithPads, h };
+export { ButtonScrew, type ButtonScrewMesh, type ButtonScrewMeshOptions, type ButtonScrewProps, CableGrommet, type CableGrommetMesh, type CableGrommetMeshOptions, type CableGrommetProps, type ColoredGeom, CompressionSpring, type CompressionSpringMesh, type CompressionSpringMeshOptions, type CompressionSpringProps, FlangedBushing, type FlangedBushingMesh, type FlangedBushingProps, FlatHeadScrew, type FlatHeadScrewMesh, type FlatHeadScrewMeshOptions, type FlatHeadScrewProps, Fragment, HelicalGear, type HelicalGearMesh, type HelicalGearProps, HexBolt, type HexBoltMesh, type HexBoltMeshOptions, type HexBoltProps, HexNut, type HexNutMesh, type HexNutMeshOptions, type HexNutProps, HexSocketBolt, type HexSocketBoltMesh, type HexSocketBoltProps, NEMA17, NEMA23, NEMA8, type NemaFrameMotorProps, NemaMotor, type NemaMotorProps, PanScrew, type PanScrewMesh, type PanScrewMeshOptions, type PanScrewProps, PlainBushing, type PlainBushingMesh, type PlainBushingProps, type RenderResult, ShaftCollar, type ShaftCollarMesh, type ShaftCollarProps, SheetMetal, type SheetMetalMesh, type SheetMetalProps, SpurGear, type SpurGearMesh, type SpurGearProps, TSlotExtrusion, type TSlotExtrusionMesh, type TSlotExtrusionProps, TSlotGusset, type TSlotGussetMesh, type TSlotGussetProps, TSlotInsideCorner, type TSlotInsideCornerMesh, type TSlotInsideCornerProps, type VNode, WormGear, type WormGearMesh, type WormGearProps, convertCSGToThreeGeom, createButtonScrewGeom, createButtonScrewMesh, createCableGrommetGeom, createCableGrommetMesh, createCompressionSpringGeom, createCompressionSpringMesh, createFlangedBushingGeom, createFlangedBushingMesh, createFlatHeadScrewGeom, createFlatHeadScrewMesh, createHelicalGearGeom, createHelicalGearMesh, createHexBoltGeom, createHexBoltMesh, createHexNutGeom, createHexNutMesh, createHexSocketBoltGeom, createHexSocketBoltMesh, createJSCADRenderer, createPanScrewGeom, createPanScrewMesh, createPlainBushingGeom, createPlainBushingMesh, createShaftCollarGeom, createShaftCollarMesh, createSheetMetalGeom, createSheetMetalMesh, createSpurGearGeom, createSpurGearMesh, createTSlotExtrusionGeom, createTSlotExtrusionMesh, createTSlotGussetGeom, createTSlotGussetMesh, createTSlotInsideCornerGeom, createTSlotInsideCornerMesh, createWormGearGeom, createWormGearMesh, getJscadModelForFootprint, getJscadModelForFootprintWithPads, h };

package/dist/vanilla.js

@@ -183,24 +183,24 @@ var FootprintPlatedHole = ({
 import { buttonScrewModelDefinitionSchema } from "@tscircuit/modelprinter";
 
 // lib/model-registry.ts
-function defineModelRenderer(model19) {
-  return model19;
+function defineModelRenderer(model21) {
+  return model21;
 }
 var ModelRendererRegistry = class {
   models = /* @__PURE__ */ new Map();
-  register(model19) {
-    if (typeof model19.name !== "string" || !/^[a-z]+$/.test(model19.name)) {
+  register(model21) {
+    if (typeof model21.name !== "string" || !/^[a-z]+$/.test(model21.name)) {
       throw new Error(
         "Model renderer names must contain only lowercase letters"
       );
     }
-    if (this.models.has(model19.name)) {
-      throw new Error(`Model renderer "${model19.name}" is already registered`);
+    if (this.models.has(model21.name)) {
+      throw new Error(`Model renderer "${model21.name}" is already registered`);
     }
-    if (model19.pads !== "none" && model19.pads !== "footprinter") {
+    if (model21.pads !== "none" && model21.pads !== "footprinter") {
       throw new Error('Model renderer pads must be "none" or "footprinter"');
     }
-    const { name, schema, render: render2, pads } = model19;
+    const { name, schema, render: render2, pads } = model21;
     this.models.set(name, {
       name,
       schema,
@@ -2730,6 +2730,295 @@ function register13(registry) {
   registry.register(model13);
 }
 
+// lib/models/shaftcollar/register.tsx
+import { shaftCollarModelDefinitionSchema } from "@tscircuit/modelprinter";
+
+// lib/models/shaftcollar/mesh.ts
+import "@jscad/modeling";
+import {
+  shaftCollarModelPropsSchema,
+  getShaftCollarDimensions
+} from "@tscircuit/modelprinter";
+
+// lib/mechanical/shaft-mount-geometry.ts
+import jscad4 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) => jscad4.transforms.scale([factor, factor, factor], geometry)
+  );
+  const result = jscad4.booleans.subtract(scaled[0], ...scaled.slice(1));
+  return jscad4.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 = jscad4.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/shaftcollar/mesh.ts
+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 model14 = defineModelRenderer({
+  name: "shaftcollar",
+  schema: shaftCollarModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(ShaftCollar, { ...props }),
+  pads: "none"
+});
+function register14(registry) {
+  registry.register(model14);
+}
+
 // lib/models/sheetmetal/register.tsx
 import { sheetMetalModelDefinitionSchema } from "@tscircuit/modelprinter";
 
@@ -2887,14 +3176,14 @@ function SheetMetal({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/sheetmetal/register.tsx
-var model14 = defineModelRenderer({
+var model15 = defineModelRenderer({
   name: "sheetmetal",
   schema: sheetMetalModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SheetMetal, { ...props }),
   pads: "none"
 });
-function register14(registry) {
-  registry.register(model14);
+function register15(registry) {
+  registry.register(model15);
 }
 
 // lib/models/spurgear/register.tsx
@@ -2909,14 +3198,14 @@ function SpurGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/spurgear/register.tsx
-var model15 = defineModelRenderer({
+var model16 = defineModelRenderer({
   name: "spurgear",
   schema: spurGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SpurGear, { ...props }),
   pads: "none"
 });
-function register15(registry) {
-  registry.register(model15);
+function register16(registry) {
+  registry.register(model16);
 }
 
 // lib/models/tslotextrusion/register.tsx
@@ -3066,14 +3355,74 @@ function TSlotExtrusion({
 }
 
 // lib/models/tslotextrusion/register.tsx
-var model16 = defineModelRenderer({
+var model17 = defineModelRenderer({
   name: "tslotextrusion",
   schema: tSlotExtrusionModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(TSlotExtrusion, { ...props }),
   pads: "none"
 });
-function register16(registry) {
-  registry.register(model16);
+function register17(registry) {
+  registry.register(model17);
+}
+
+// lib/models/tslotgusset/register.tsx
+import { tSlotGussetModelDefinitionSchema } from "@tscircuit/modelprinter";
+
+// lib/models/tslotgusset/mesh.ts
+import {
+  getTSlotGussetMountingSlots,
+  tSlotGussetModelPropsSchema
+} from "@tscircuit/modelprinter";
+function createTSlotGussetMesh(input = {}) {
+  const props = tSlotGussetModelPropsSchema.parse(input);
+  const holes = getTSlotGussetMountingSlots(props).map((slot) => {
+    const radius = slot.width / 2;
+    const halfStraight = (slot.length - slot.width) / 2;
+    const rotate = (u, v) => slot.orientation === 0 ? [slot.center.x + u, slot.center.y + v] : [slot.center.x - v, slot.center.y + u];
+    if (halfStraight === 0)
+      return circularProfile(0, 0, radius).map(([u, v]) => rotate(u, v));
+    const loop = [];
+    for (const side of [1, -1])
+      for (let step = 0; step <= 48; step++) {
+        const angle = -Math.PI / 2 + step * Math.PI / 48 + (side < 0 ? Math.PI : 0);
+        loop.push(
+          rotate(
+            side * halfStraight + radius * Math.cos(angle),
+            radius * Math.sin(angle)
+          )
+        );
+      }
+    return loop;
+  });
+  return extrudePlanarProfile({
+    outer: [
+      [0, 0],
+      [props.width, 0],
+      [0, props.height]
+    ],
+    holes,
+    start: 0,
+    end: props.thickness
+  });
+}
+
+// lib/models/tslotgusset/TSlotGusset.tsx
+function createTSlotGussetGeom(input = {}) {
+  return indexedMeshToGeom3(createTSlotGussetMesh(input));
+}
+function TSlotGusset({ color = "#8995a3", ...props }) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createTSlotGussetGeom(props) }) });
+}
+
+// lib/models/tslotgusset/register.tsx
+var model18 = defineModelRenderer({
+  name: "tslotgusset",
+  schema: tSlotGussetModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(TSlotGusset, { ...props }),
+  pads: "none"
+});
+function register18(registry) {
+  registry.register(model18);
 }
 
 // lib/models/tslotinsidecorner/register.tsx
@@ -3153,14 +3502,14 @@ function TSlotInsideCorner({
 }
 
 // lib/models/tslotinsidecorner/register.tsx
-var model17 = defineModelRenderer({
+var model19 = defineModelRenderer({
   name: "tslotinsidecorner",
   schema: tSlotInsideCornerModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(TSlotInsideCorner, { ...props }),
   pads: "none"
 });
-function register17(registry) {
-  registry.register(model17);
+function register19(registry) {
+  registry.register(model19);
 }
 
 // lib/models/wormgear/register.tsx
@@ -3352,14 +3701,14 @@ function WormGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/wormgear/register.tsx
-var model18 = defineModelRenderer({
+var model20 = defineModelRenderer({
   name: "wormgear",
   schema: wormGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(WormGear, { ...props }),
   pads: "none"
 });
-function register18(registry) {
-  registry.register(model18);
+function register20(registry) {
+  registry.register(model20);
 }
 
 // lib/generated/model-renderers.ts
@@ -3382,6 +3731,8 @@ function registerAllModelRenderers(registry) {
   register16(registry);
   register17(registry);
   register18(registry);
+  register19(registry);
+  register20(registry);
 }
 
 // lib/default-model-registry.ts
@@ -10938,10 +11289,10 @@ var SOT143 = ({ footprint = "sot143" }) => {
 var Footprinter3d = ({ footprint }) => {
   const modelFn = mp3.string(footprint.split("_", 1)[0]).params().fn;
   if (mp3.getModelNames().includes(modelFn)) {
-    const model19 = mp3.string(footprint).json();
-    const renderer = modelRendererRegistry.get(model19.fn);
+    const model21 = mp3.string(footprint).json();
+    const renderer = modelRendererRegistry.get(model21.fn);
     if (renderer) {
-      return renderer.render(model19);
+      return renderer.render(model21);
     }
   }
   let normalizedFootprint = footprint;
@@ -11774,8 +12125,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, jscad6) {
+  const geometries = renderNode(root, void 0, { jscad: jscad6 });
   return {
     geometries: geometries.map(
       (entry) => entry.material ? { ...entry, geom: { ...entry.geom, material: entry.material } } : entry
@@ -11867,24 +12218,24 @@ function convertCSGToThreeGeom(csg) {
 }
 
 // lib/vanilla/index.ts
-function getJscadModelForFootprint(footprint, jscad4) {
+function getJscadModelForFootprint(footprint, jscad6) {
   const vnode = h(Footprinter3d, { footprint });
-  return render(vnode, jscad4);
+  return render(vnode, jscad6);
 }
-function getJscadModelForFootprintWithPads(footprint, jscad4) {
+function getJscadModelForFootprintWithPads(footprint, jscad6) {
   const vnode = h(
     Fragment,
     {},
     h(Footprinter3d, { footprint }),
     h(ExtrudedPads, { footprint })
   );
-  return render(vnode, jscad4);
+  return render(vnode, jscad6);
 }
-function createJSCADRenderer(jscad4) {
+function createJSCADRenderer(jscad6) {
   function createJSCADRoot(container) {
     return {
       render(element) {
-        const { geometries } = render(element, jscad4);
+        const { geometries } = render(element, jscad6);
         container.splice(0, container.length, ...geometries);
       }
     };
@@ -11908,9 +12259,11 @@ export {
   NemaMotor,
   PanScrew,
   PlainBushing,
+  ShaftCollar,
   SheetMetal,
   SpurGear,
   TSlotExtrusion,
+  TSlotGusset,
   TSlotInsideCorner,
   WormGear,
   convertCSGToThreeGeom,
@@ -11937,12 +12290,16 @@ export {
   createPanScrewMesh,
   createPlainBushingGeom,
   createPlainBushingMesh,
+  createShaftCollarGeom,
+  createShaftCollarMesh,
   createSheetMetalGeom,
   createSheetMetalMesh,
   createSpurGearGeom,
   createSpurGearMesh,
   createTSlotExtrusionGeom,
   createTSlotExtrusionMesh,
+  createTSlotGussetGeom,
+  createTSlotGussetMesh,
   createTSlotInsideCornerGeom,
   createTSlotInsideCornerMesh,
   createWormGearGeom,