jscad-electronics 0.0.201 → 0.0.203

package/dist/vanilla.js

@@ -183,24 +183,24 @@ var FootprintPlatedHole = ({
 import { buttonScrewModelDefinitionSchema } from "@tscircuit/modelprinter";
 
 // lib/model-registry.ts
-function defineModelRenderer(model16) {
-  return model16;
+function defineModelRenderer(model18) {
+  return model18;
 }
 var ModelRendererRegistry = class {
   models = /* @__PURE__ */ new Map();
-  register(model16) {
-    if (typeof model16.name !== "string" || !/^[a-z]+$/.test(model16.name)) {
+  register(model18) {
+    if (typeof model18.name !== "string" || !/^[a-z]+$/.test(model18.name)) {
       throw new Error(
         "Model renderer names must contain only lowercase letters"
       );
     }
-    if (this.models.has(model16.name)) {
-      throw new Error(`Model renderer "${model16.name}" is already registered`);
+    if (this.models.has(model18.name)) {
+      throw new Error(`Model renderer "${model18.name}" is already registered`);
     }
-    if (model16.pads !== "none" && model16.pads !== "footprinter") {
+    if (model18.pads !== "none" && model18.pads !== "footprinter") {
       throw new Error('Model renderer pads must be "none" or "footprinter"');
     }
-    const { name, schema, render: render2, pads } = model16;
+    const { name, schema, render: render2, pads } = model18;
     this.models.set(name, {
       name,
       schema,
@@ -454,6 +454,219 @@ function register2(registry) {
   registry.register(model2);
 }
 
+// lib/models/compressionspring/register.tsx
+import { compressionSpringModelDefinitionSchema } from "@tscircuit/modelprinter";
+
+// lib/models/compressionspring/mesh.ts
+import {
+  compressionSpringModelPropsSchema,
+  getCompressionSpringCenterlinePoint,
+  getCompressionSpringDimensions
+} from "@tscircuit/modelprinter";
+
+// lib/mechanical/clip-mesh-to-z-range.ts
+import earcut from "earcut";
+function clipMeshToZRange(mesh, lower, upper) {
+  const originals = [];
+  const tolerance = 32 * Number.EPSILON * (upper - lower);
+  for (let index = 0; index < mesh.positions.length / 3; index++)
+    originals.push({
+      key: `v${index}`,
+      coordinates: [
+        mesh.positions[index * 3],
+        mesh.positions[index * 3 + 1],
+        Math.abs(mesh.positions[index * 3 + 2] - lower) <= tolerance ? lower : Math.abs(mesh.positions[index * 3 + 2] - upper) <= tolerance ? upper : mesh.positions[index * 3 + 2]
+      ]
+    });
+  const intersections = /* @__PURE__ */ new Map();
+  const crossing = (a, b, plane) => {
+    if (a.coordinates[2] === plane) return a;
+    if (b.coordinates[2] === plane) return b;
+    const [first, second] = a.key < b.key ? [a, b] : [b, a];
+    const key = `${plane}:${first.key}:${second.key}`;
+    let point = intersections.get(key);
+    if (!point) {
+      const fraction = (plane - first.coordinates[2]) / (second.coordinates[2] - first.coordinates[2]);
+      point = {
+        key,
+        coordinates: [
+          first.coordinates[0] + fraction * (second.coordinates[0] - first.coordinates[0]),
+          first.coordinates[1] + fraction * (second.coordinates[1] - first.coordinates[1]),
+          plane
+        ]
+      };
+      intersections.set(key, point);
+    }
+    return point;
+  };
+  const clip = (polygon, plane, keepAbove) => {
+    const result = [];
+    const inside = (point) => keepAbove ? point.coordinates[2] >= plane : point.coordinates[2] <= plane;
+    for (let index = 0; index < polygon.length; index++) {
+      const a = polygon[index];
+      const b = polygon[(index + 1) % polygon.length];
+      if (inside(a)) result.push(a);
+      if (inside(a) !== inside(b)) result.push(crossing(a, b, plane));
+    }
+    return result.filter(
+      (point, index) => point.key !== result[(index + result.length - 1) % result.length]?.key
+    );
+  };
+  const positions = [];
+  const indices = [];
+  const pointIndices = /* @__PURE__ */ new Map();
+  const vertex = (point) => {
+    let index = pointIndices.get(point.key);
+    if (index === void 0) {
+      index = positions.length / 3;
+      positions.push(...point.coordinates);
+      pointIndices.set(point.key, index);
+    }
+    return index;
+  };
+  for (let index = 0; index < mesh.indices.length; index += 3) {
+    const triangle = mesh.indices.slice(index, index + 3).map((i) => originals[i]);
+    const polygon = clip(clip(triangle, lower, true), upper, false);
+    for (let corner = 1; corner + 1 < polygon.length; corner++) {
+      const points = [polygon[0], polygon[corner], polygon[corner + 1]];
+      if (new Set(points.map((point) => point.key)).size === 3)
+        indices.push(...points.map(vertex));
+    }
+  }
+  const edges = /* @__PURE__ */ new Map();
+  for (let index = 0; index < indices.length; index += 3)
+    for (let side = 0; side < 3; side++) {
+      const from = indices[index + side];
+      const to = indices[index + (side + 1) % 3];
+      const key = `${Math.min(from, to)},${Math.max(from, to)}`;
+      const prior = edges.get(key);
+      if (prior) prior.count++;
+      else edges.set(key, { from, to, count: 1 });
+    }
+  const boundary = [...edges.values()].filter((edge) => edge.count === 1);
+  const outgoing = new Map(boundary.map(({ from, to }) => [from, to]));
+  if (outgoing.size !== boundary.length)
+    throw new Error("Ground clipping produced an ambiguous boundary");
+  while (outgoing.size > 0) {
+    const start = outgoing.keys().next().value;
+    const loop = [];
+    let current = start;
+    do {
+      loop.push(current);
+      const next = outgoing.get(current);
+      if (next === void 0)
+        throw new Error("Ground clipping produced an open boundary");
+      outgoing.delete(current);
+      current = next;
+    } while (current !== start);
+    const plane = positions[3 * start + 2];
+    if (plane !== lower && plane !== upper || loop.some((i) => positions[3 * i + 2] !== plane))
+      throw new Error("Ground clipping boundary must lie on an end plane");
+    const coordinates = loop.flatMap((i) => [
+      positions[3 * i],
+      positions[3 * i + 1]
+    ]);
+    const cap = earcut(coordinates);
+    for (let index = 0; index < cap.length; index += 3) {
+      const a = loop[cap[index]];
+      let b = loop[cap[index + 1]];
+      let c = loop[cap[index + 2]];
+      const cross = (positions[b * 3] - positions[a * 3]) * (positions[c * 3 + 1] - positions[a * 3 + 1]) - (positions[b * 3 + 1] - positions[a * 3 + 1]) * (positions[c * 3] - positions[a * 3]);
+      if (plane === lower && cross > 0 || plane === upper && cross < 0)
+        [b, c] = [c, b];
+      indices.push(a, b, c);
+    }
+  }
+  return { positions, indices };
+}
+
+// lib/models/compressionspring/mesh.ts
+function createCompressionSpringMesh(input, options = {}) {
+  const props = compressionSpringModelPropsSchema.parse(input);
+  const dimensions = getCompressionSpringDimensions(props);
+  const segmentsPerTurn = options.segmentsPerTurn ?? 64;
+  const wireSegments = options.wireSegments ?? 24;
+  for (const [name, value, minimum, maximum] of [
+    ["segmentsPerTurn", segmentsPerTurn, 16, 256],
+    ["wireSegments", wireSegments, 8, 64]
+  ])
+    if (!Number.isInteger(value) || value < minimum || value > maximum || value % 4 !== 0)
+      throw new Error(
+        `${name} must be a multiple of four in [${minimum},${maximum}]`
+      );
+  const steps = props.totalTurns * segmentsPerTurn;
+  if (!Number.isSafeInteger(steps) || (steps + 1) * wireSegments > 25e4)
+    throw new Error("Spring exceeds mesh resolution limit (250000 vertices)");
+  const scale = Math.max(props.outerDiameter, props.freeLength);
+  if (dimensions.activePitch - props.wireDiameter <= scale * 1e-10 || props.wireDiameter <= scale * 1e-10 || dimensions.insideDiameter <= scale * 1e-10)
+    throw new Error("Spring clearance exceeds mesh resolution limit");
+  const positions = [];
+  const indices = [];
+  const wireRadius = props.wireDiameter / 2;
+  for (let step = 0; step <= steps; step++) {
+    const center = getCompressionSpringCenterlinePoint(
+      props,
+      step / segmentsPerTurn
+    );
+    const meanRadius = Math.hypot(center.x, center.y);
+    for (let sample = 0; sample < wireSegments; sample++) {
+      const angle = sample * 2 * Math.PI / wireSegments;
+      const cosine = sample === wireSegments / 4 || sample === 3 * wireSegments / 4 ? 0 : Math.cos(angle);
+      const sine = sample === 0 || sample === wireSegments / 2 ? 0 : Math.sin(angle);
+      const radialOffset = wireRadius * cosine;
+      positions.push(
+        center.x + radialOffset * center.x / meanRadius,
+        center.y + radialOffset * center.y / meanRadius,
+        center.z + wireRadius * sine
+      );
+    }
+  }
+  const triangle = (a, b, c) => {
+    if (props.hand === "left") indices.push(a, c, b);
+    else indices.push(a, b, c);
+  };
+  for (let step = 0; step < steps; step++)
+    for (let sample = 0; sample < wireSegments; sample++) {
+      const next = (sample + 1) % wireSegments;
+      const a = step * wireSegments;
+      const b = (step + 1) * wireSegments;
+      triangle(a + sample, b + sample, b + next);
+      triangle(a + sample, b + next, a + next);
+    }
+  for (let corner = 1; corner + 1 < wireSegments; corner++) {
+    triangle(0, corner, corner + 1);
+    const end = steps * wireSegments;
+    triangle(end, end + corner + 1, end + corner);
+  }
+  return clipMeshToZRange(
+    { positions, indices },
+    dimensions.lowerBearingZ,
+    dimensions.upperBearingZ
+  );
+}
+
+// lib/models/compressionspring/CompressionSpring.tsx
+function createCompressionSpringGeom(input) {
+  return indexedMeshToGeom3(createCompressionSpringMesh(input));
+}
+function CompressionSpring({
+  color = "#737e8f",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createCompressionSpringGeom(props) }) });
+}
+
+// lib/models/compressionspring/register.tsx
+var model3 = defineModelRenderer({
+  name: "compressionspring",
+  schema: compressionSpringModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(CompressionSpring, { ...props }),
+  pads: "none"
+});
+function register3(registry) {
+  registry.register(model3);
+}
+
 // lib/models/flangedbushing/register.tsx
 import { flangedBushingModelDefinitionSchema } from "@tscircuit/modelprinter";
 
@@ -507,14 +720,14 @@ function FlangedBushing({
 }
 
 // lib/models/flangedbushing/register.tsx
-var model3 = defineModelRenderer({
+var model4 = defineModelRenderer({
   name: "flangedbushing",
   schema: flangedBushingModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlangedBushing, { ...props }),
   pads: "none"
 });
-function register3(registry) {
-  registry.register(model3);
+function register4(registry) {
+  registry.register(model4);
 }
 
 // lib/models/flatheadscrew/register.tsx
@@ -647,14 +860,14 @@ function FlatHeadScrew({
 }
 
 // lib/models/flatheadscrew/register.tsx
-var model4 = defineModelRenderer({
+var model5 = defineModelRenderer({
   name: "flatheadscrew",
   schema: flatHeadScrewModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlatHeadScrew, { ...props }),
   pads: "none"
 });
-function register4(registry) {
-  registry.register(model4);
+function register5(registry) {
+  registry.register(model5);
 }
 
 // lib/models/flexscreen/register.tsx
@@ -1332,14 +1545,14 @@ var FlexScreen = (props) => {
 };
 
 // lib/models/flexscreen/register.tsx
-var model5 = defineModelRenderer({
+var model6 = defineModelRenderer({
   name: "flexscreen",
   schema: flexScreenModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlexScreen, { ...props }),
   pads: "footprinter"
 });
-function register5(registry) {
-  registry.register(model5);
+function register6(registry) {
+  registry.register(model6);
 }
 
 // lib/models/helicalgear/register.tsx
@@ -1356,7 +1569,7 @@ import {
   getSpurGearDimensions,
   spurGearModelPropsSchema
 } from "@tscircuit/modelprinter";
-import earcut from "earcut";
+import earcut2 from "earcut";
 function createSpurGearMesh(input) {
   return createTwistedSpurGearMesh(input);
 }
@@ -1462,7 +1675,7 @@ function createTwistedSpurGearMesh(input, twist = 0, segmentsPerTurn = 32) {
   };
   const cap = (outer, outerStart, upward, inner) => {
     const points = inner ? [...outer, ...inner.points] : outer;
-    const triangles = earcut(
+    const triangles = earcut2(
       points.flatMap(([x, y]) => [x, y]),
       inner ? [outer.length] : []
     );
@@ -1545,14 +1758,14 @@ function HelicalGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/helicalgear/register.tsx
-var model6 = defineModelRenderer({
+var model7 = defineModelRenderer({
   name: "helicalgear",
   schema: helicalGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HelicalGear, { ...props }),
   pads: "none"
 });
-function register6(registry) {
-  registry.register(model6);
+function register7(registry) {
+  registry.register(model7);
 }
 
 // lib/models/hexbolt/register.tsx
@@ -1693,14 +1906,14 @@ function HexBolt({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/hexbolt/register.tsx
-var model7 = defineModelRenderer({
+var model8 = defineModelRenderer({
   name: "hexbolt",
   schema: hexBoltModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexBolt, { ...props }),
   pads: "none"
 });
-function register7(registry) {
-  registry.register(model7);
+function register8(registry) {
+  registry.register(model8);
 }
 
 // lib/models/hexnut/register.tsx
@@ -1823,14 +2036,14 @@ function HexNut({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/hexnut/register.tsx
-var model8 = defineModelRenderer({
+var model9 = defineModelRenderer({
   name: "hexnut",
   schema: hexNutModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexNut, { ...props }),
   pads: "none"
 });
-function register8(registry) {
-  registry.register(model8);
+function register9(registry) {
+  registry.register(model9);
 }
 
 // lib/models/hexsocketbolt/register.tsx
@@ -1942,14 +2155,14 @@ function HexSocketBolt({
 }
 
 // lib/models/hexsocketbolt/register.tsx
-var model9 = defineModelRenderer({
+var model10 = defineModelRenderer({
   name: "hexsocketbolt",
   schema: hexSocketBoltModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexSocketBolt, { ...props }),
   pads: "none"
 });
-function register9(registry) {
-  registry.register(model9);
+function register10(registry) {
+  registry.register(model10);
 }
 
 // lib/models/nema/register.tsx
@@ -2218,14 +2431,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 model10 = defineModelRenderer({
+var model11 = defineModelRenderer({
   name: "nema",
   schema: nemaMotorModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(NemaMotor, { ...props }),
   pads: "none"
 });
-function register10(registry) {
-  registry.register(model10);
+function register11(registry) {
+  registry.register(model11);
 }
 
 // lib/models/panscrew/register.tsx
@@ -2437,14 +2650,14 @@ function PanScrew({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/panscrew/register.tsx
-var model11 = defineModelRenderer({
+var model12 = defineModelRenderer({
   name: "panscrew",
   schema: panScrewModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(PanScrew, { ...props }),
   pads: "none"
 });
-function register11(registry) {
-  registry.register(model11);
+function register12(registry) {
+  registry.register(model12);
 }
 
 // lib/models/plainbushing/register.tsx
@@ -2507,21 +2720,21 @@ function PlainBushing({
 }
 
 // lib/models/plainbushing/register.tsx
-var model12 = defineModelRenderer({
+var model13 = defineModelRenderer({
   name: "plainbushing",
   schema: plainBushingModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(PlainBushing, { ...props }),
   pads: "none"
 });
-function register12(registry) {
-  registry.register(model12);
+function register13(registry) {
+  registry.register(model13);
 }
 
 // lib/models/sheetmetal/register.tsx
 import { sheetMetalModelDefinitionSchema } from "@tscircuit/modelprinter";
 
 // lib/mechanical/sheet-metal-mesh.ts
-import earcut2 from "earcut";
+import earcut3 from "earcut";
 import {
   sheetMetalModelPropsSchema
 } from "@tscircuit/modelprinter";
@@ -2589,7 +2802,7 @@ function createSheetMetalMesh(input) {
     const loops = [outline, ...holes.map((hole) => [...hole].reverse())];
     const points = loops.flat();
     const starts = holes.map((_, i) => 4 + i * 64);
-    const triangles = earcut2(
+    const triangles = earcut3(
       points.flatMap((p) => [p.u, p.v]),
       starts
     );
@@ -2674,14 +2887,14 @@ function SheetMetal({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/sheetmetal/register.tsx
-var model13 = defineModelRenderer({
+var model14 = defineModelRenderer({
   name: "sheetmetal",
   schema: sheetMetalModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SheetMetal, { ...props }),
   pads: "none"
 });
-function register13(registry) {
-  registry.register(model13);
+function register14(registry) {
+  registry.register(model14);
 }
 
 // lib/models/spurgear/register.tsx
@@ -2696,14 +2909,152 @@ function SpurGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/spurgear/register.tsx
-var model14 = defineModelRenderer({
+var model15 = defineModelRenderer({
   name: "spurgear",
   schema: spurGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SpurGear, { ...props }),
   pads: "none"
 });
-function register14(registry) {
-  registry.register(model14);
+function register15(registry) {
+  registry.register(model15);
+}
+
+// lib/models/tslotextrusion/register.tsx
+import { tSlotExtrusionModelDefinitionSchema } from "@tscircuit/modelprinter";
+
+// lib/models/tslotextrusion/mesh.ts
+import {
+  tSlotExtrusionModelPropsSchema
+} from "@tscircuit/modelprinter";
+
+// lib/mechanical/extrude-planar-profile.ts
+import earcut4 from "earcut";
+function extrudePlanarProfile({
+  outer,
+  holes = [],
+  start,
+  end,
+  project = (u, v, depth) => [u, v, depth],
+  reverse = false,
+  skipWall = () => false
+}) {
+  const oriented = (loop, clockwise) => {
+    loop = loop.filter((point, index) => {
+      const previous = loop[(index + loop.length - 1) % loop.length];
+      return point[0] !== previous[0] || point[1] !== previous[1];
+    });
+    const area = loop.reduce((sum, a, index) => {
+      const b = loop[(index + 1) % loop.length];
+      return sum + a[0] * b[1] - a[1] * b[0];
+    }, 0);
+    if (!Number.isFinite(area) || area === 0)
+      throw new Error("Profile exceeds mesh resolution limits");
+    return area < 0 === clockwise ? loop : [...loop].reverse();
+  };
+  const loops = [oriented(outer, false), ...holes.map((h2) => oriented(h2, true))];
+  const points = loops.flat();
+  const holeStarts = [];
+  let count = loops[0].length;
+  for (const hole of loops.slice(1)) {
+    holeStarts.push(count);
+    count += hole.length;
+  }
+  const faces = earcut4(points.flat(), holeStarts);
+  const positions = [start, end].flatMap(
+    (depth) => points.flatMap(([u, v]) => project(u, v, depth))
+  );
+  const indices = [];
+  for (let i = 0; i < faces.length; i += 3) {
+    const [a, b, c] = faces.slice(i, i + 3);
+    indices.push(a, c, b, a + count, b + count, c + count);
+  }
+  let offset = 0;
+  for (const [loopIndex, loop] of loops.entries()) {
+    for (let i = 0; i < loop.length; i++) {
+      const next = (i + 1) % loop.length;
+      if (loopIndex === 0 && skipWall(loop[i], loop[next])) continue;
+      const a = offset + i;
+      const b = offset + next;
+      indices.push(a, b, b + count, a, b + count, a + count);
+    }
+    offset += loop.length;
+  }
+  if (reverse)
+    for (let i = 0; i < indices.length; i += 3)
+      [indices[i + 1], indices[i + 2]] = [indices[i + 2], indices[i + 1]];
+  return { positions, indices };
+}
+function circularProfile(x, y, radius, segments = 96) {
+  return Array.from({ length: segments }, (_, index) => {
+    const angle = index * 2 * Math.PI / segments;
+    return [x + radius * Math.cos(angle), y + radius * Math.sin(angle)];
+  });
+}
+
+// lib/models/tslotextrusion/mesh.ts
+function createTSlotExtrusionMesh(input = {}) {
+  const props = tSlotExtrusionModelPropsSchema.parse(input);
+  const { width: width10, height: height10, length, cornerRadius, lipThickness, pocketDepth } = props;
+  const slot = props.slotWidth / 2;
+  const pocket = props.pocketWidth / 2;
+  const depth = lipThickness + pocketDepth;
+  const outer = [];
+  for (let face2 = 0; face2 < 4; face2++) {
+    const span = (face2 % 2 === 0 ? width10 : height10) / 2;
+    const extent = (face2 % 2 === 0 ? height10 : width10) / 2;
+    const local = [
+      [-span + cornerRadius, -extent],
+      [-slot, -extent],
+      [-slot, -extent + lipThickness],
+      [-pocket, -extent + lipThickness],
+      [-pocket, -extent + depth],
+      [pocket, -extent + depth],
+      [pocket, -extent + lipThickness],
+      [slot, -extent + lipThickness],
+      [slot, -extent],
+      [span - cornerRadius, -extent]
+    ];
+    if (cornerRadius > 0)
+      for (let step = 1; step < 24; step++) {
+        const angle = -Math.PI / 2 + step * Math.PI / 48;
+        local.push([
+          span - cornerRadius + cornerRadius * Math.cos(angle),
+          -extent + cornerRadius + cornerRadius * Math.sin(angle)
+        ]);
+      }
+    for (const [u, v] of local)
+      outer.push(
+        face2 === 0 ? [u, v] : face2 === 1 ? [-v, u] : face2 === 2 ? [-u, -v] : [v, -u]
+      );
+  }
+  return extrudePlanarProfile({
+    outer,
+    holes: props.boreDiameter > 0 ? [circularProfile(0, 0, props.boreDiameter / 2)] : [],
+    start: 0,
+    end: length
+  });
+}
+
+// lib/models/tslotextrusion/TSlotExtrusion.tsx
+function createTSlotExtrusionGeom(input = {}) {
+  return indexedMeshToGeom3(createTSlotExtrusionMesh(input));
+}
+function TSlotExtrusion({
+  color = "#8995a3",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createTSlotExtrusionGeom(props) }) });
+}
+
+// lib/models/tslotextrusion/register.tsx
+var model16 = defineModelRenderer({
+  name: "tslotextrusion",
+  schema: tSlotExtrusionModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(TSlotExtrusion, { ...props }),
+  pads: "none"
+});
+function register16(registry) {
+  registry.register(model16);
 }
 
 // lib/models/wormgear/register.tsx
@@ -2714,7 +3065,7 @@ import {
   getWormGearDimensions,
   wormGearModelPropsSchema
 } from "@tscircuit/modelprinter";
-import earcut3 from "earcut";
+import earcut5 from "earcut";
 var createWormGearMesh = (input) => {
   const props = wormGearModelPropsSchema.parse(input);
   const { outsideDiameter, rootDiameter, axialPitch, lead, toothThickness } = getWormGearDimensions(props);
@@ -2867,7 +3218,7 @@ var createWormGearMesh = (input) => {
         positions[vertex * 3],
         positions[vertex * 3 + 1]
       ]);
-      const triangles = earcut3(flat, [count], 2);
+      const triangles = earcut5(flat, [count], 2);
       for (let index = 0; index < triangles.length; index += 3) {
         const a = vertices[triangles[index]];
         const b = vertices[triangles[index + 1]];
@@ -2895,14 +3246,14 @@ function WormGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/wormgear/register.tsx
-var model15 = defineModelRenderer({
+var model17 = defineModelRenderer({
   name: "wormgear",
   schema: wormGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(WormGear, { ...props }),
   pads: "none"
 });
-function register15(registry) {
-  registry.register(model15);
+function register17(registry) {
+  registry.register(model17);
 }
 
 // lib/generated/model-renderers.ts
@@ -2922,6 +3273,8 @@ function registerAllModelRenderers(registry) {
   register13(registry);
   register14(registry);
   register15(registry);
+  register16(registry);
+  register17(registry);
 }
 
 // lib/default-model-registry.ts
@@ -10478,10 +10831,10 @@ var SOT143 = ({ footprint = "sot143" }) => {
 var Footprinter3d = ({ footprint }) => {
   const modelFn = mp3.string(footprint.split("_", 1)[0]).params().fn;
   if (mp3.getModelNames().includes(modelFn)) {
-    const model16 = mp3.string(footprint).json();
-    const renderer = modelRendererRegistry.get(model16.fn);
+    const model18 = mp3.string(footprint).json();
+    const renderer = modelRendererRegistry.get(model18.fn);
     if (renderer) {
-      return renderer.render(model16);
+      return renderer.render(model18);
     }
   }
   let normalizedFootprint = footprint;
@@ -11434,6 +11787,7 @@ function createJSCADRenderer(jscad4) {
 export {
   ButtonScrew,
   CableGrommet,
+  CompressionSpring,
   FlangedBushing,
   FlatHeadScrew,
   Fragment,
@@ -11449,12 +11803,15 @@ export {
   PlainBushing,
   SheetMetal,
   SpurGear,
+  TSlotExtrusion,
   WormGear,
   convertCSGToThreeGeom,
   createButtonScrewGeom,
   createButtonScrewMesh,
   createCableGrommetGeom,
   createCableGrommetMesh,
+  createCompressionSpringGeom,
+  createCompressionSpringMesh,
   createFlangedBushingGeom,
   createFlangedBushingMesh,
   createFlatHeadScrewGeom,
@@ -11476,6 +11833,8 @@ export {
   createSheetMetalMesh,
   createSpurGearGeom,
   createSpurGearMesh,
+  createTSlotExtrusionGeom,
+  createTSlotExtrusionMesh,
   createWormGearGeom,
   createWormGearMesh,
   getJscadModelForFootprint,