jscad-electronics 0.0.238 → 0.0.239

package/dist/index.js

@@ -56,6 +56,504 @@ var A01005 = ({ color = "#333" }) => {
   ] });
 };
 
+// lib/named-edges.ts
+import jscad from "@jscad/modeling";
+function listJscadNamedEdges(model108) {
+  return listJscadReferenceFeatures(model108).filter((name) => {
+    const { geometry } = model108.referenceFeatures[name];
+    return jscad.geometries.geom2.isA(geometry) || jscad.geometries.path2.isA(geometry);
+  });
+}
+function listJscadReferenceFeatures(model108) {
+  return Object.keys(model108.referenceFeatures);
+}
+function readJscadReferenceFeature(model108, name) {
+  if (!Object.hasOwn(model108.referenceFeatures, name))
+    throw new Error(`JSCAD model does not define named feature "${name}"`);
+  return model108.referenceFeatures[name];
+}
+function readJscadNamedEdge(model108, name) {
+  const { geometry: feature, matrix } = readJscadReferenceFeature(model108, name);
+  if (matrix.length !== 16 || !matrix.every(Number.isFinite))
+    throw new Error(
+      `Named JSCAD feature "${name}" requires a finite 4x4 matrix`
+    );
+  let points;
+  let closed;
+  if (jscad.geometries.path2.isA(feature)) {
+    const path = jscad.geometries.path2.clone(feature);
+    points = jscad.geometries.path2.toPoints(path);
+    closed = path.isClosed;
+  } else if (jscad.geometries.geom2.isA(feature)) {
+    const outlines = jscad.geometries.geom2.toOutlines(
+      jscad.geometries.geom2.clone(feature)
+    );
+    if (outlines.length !== 1)
+      throw new Error(
+        `Named JSCAD edge "${name}" must identify one contour; name its boundaries separately`
+      );
+    points = outlines[0];
+    closed = true;
+  } else {
+    throw new Error(
+      `Named JSCAD edge "${name}" is not a geom2 or path2 feature`
+    );
+  }
+  if (points.length < 2)
+    throw new Error(`Named JSCAD edge "${name}" has no measurable path`);
+  return {
+    points: points.map(([x, y]) => {
+      const point = jscad.maths.vec3.transform(
+        jscad.maths.vec3.create(),
+        [x, y, 0],
+        matrix
+      );
+      return { x: point[0], y: point[1], z: point[2] };
+    }),
+    closed
+  };
+}
+
+// node_modules/@tscircuit/jscad/lib/cleanup-subtraction.ts
+import insertTjunctions from "@jscad/modeling/src/operations/modifiers/insertTjunctions.js";
+function cleanupSubtraction(kernel, geometry) {
+  const { geom3 } = kernel.geometries;
+  if (!geometry.polygons.length) return geometry;
+  const source = structuredClone(geometry);
+  const polygons = geom3.toPolygons(source);
+  const extent = Math.max(...kernel.measurements.measureDimensions(source));
+  if (!Number.isFinite(extent) || extent <= 0)
+    throw new Error("Subtraction requires finite nonempty geometry");
+  const epsilon = Math.max(extent * 1e-10, 1e-12);
+  source.polygons = polygons.map((polygon4) => ({
+    ...polygon4,
+    vertices: polygon4.vertices.map((point) => {
+      if (!point.every(Number.isFinite))
+        throw new Error("Subtraction requires finite coordinates");
+      return point.map((value) => Math.round(value / epsilon) * epsilon);
+    })
+  }));
+  const triangles = insertTjunctions(source.polygons).flatMap((polygon4) => {
+    if (polygon4.vertices.length === 3) return [polygon4];
+    const center = [0, 0, 0];
+    for (const point of polygon4.vertices)
+      for (let axis = 0; axis < 3; axis++)
+        center[axis] += point[axis] / polygon4.vertices.length;
+    return polygon4.vertices.map((point, index) => {
+      const triangle = kernel.geometries.poly3.create([
+        center,
+        point,
+        polygon4.vertices[(index + 1) % polygon4.vertices.length]
+      ]);
+      if (polygon4.color) triangle.color = polygon4.color;
+      return triangle;
+    });
+  });
+  const cleaned = geom3.create(triangles);
+  return {
+    ...geometry,
+    polygons: cleaned.polygons,
+    transforms: cleaned.transforms
+  };
+}
+
+// node_modules/@tscircuit/jscad/lib/with-references.ts
+import modeling from "@jscad/modeling";
+var metadata = /* @__PURE__ */ Symbol.for("@tscircuit/jscad/references/v1");
+var cache = /* @__PURE__ */ new WeakMap();
+var snapshot = (value) => structuredClone(value);
+var assertName = (name) => {
+  if (typeof name !== "string" || !name.trim())
+    throw new Error("Reference name must be nonempty");
+};
+function withReferences(kernel = modeling) {
+  if (cache.has(kernel)) return cache.get(kernel);
+  const k = kernel;
+  const { mat4 } = k.maths;
+  const identity = () => Array.from(mat4.create());
+  const multiply = (a, b) => Array.from(mat4.multiply(mat4.create(), a, b));
+  const isGeometry = (g) => g && (k.geometries.geom2.isA(g) || k.geometries.path2.isA(g) || k.geometries.geom3.isA(g));
+  const inputs = (args) => args.flat(Infinity).filter(isGeometry);
+  const read = (g) => g?.[metadata] ?? /* @__PURE__ */ Object.create(null);
+  const merge = (geometries9) => {
+    const refs = /* @__PURE__ */ Object.create(null);
+    for (const g of geometries9)
+      for (const [name, ref] of Object.entries(read(g))) {
+        if (Object.hasOwn(refs, name) && refs[name] !== ref)
+          throw new Error(`Duplicate reference: ${name}`);
+        refs[name] = ref;
+      }
+    return refs;
+  };
+  const attach = (g, refs) => {
+    if (!Object.keys(refs).length) return g;
+    if (Array.isArray(g)) return g.map((item) => attach(item, refs));
+    return isGeometry(g) ? Object.assign({}, g, { [metadata]: refs }) : g;
+  };
+  const moved = (refs, matrix) => Object.fromEntries(
+    Object.entries(refs).map(([name, ref]) => [
+      name,
+      { geometry: ref.geometry, matrix: multiply(matrix, ref.matrix) }
+    ])
+  );
+  const add = (refs, name, ref) => {
+    assertName(name);
+    if (Object.hasOwn(refs, name))
+      throw new Error(`Duplicate reference: ${name}`);
+    refs[name] = ref;
+  };
+  const planar = (g) => {
+    if (!k.geometries.geom2.isA(g) && !k.geometries.path2.isA(g))
+      throw new Error("References require native planar geometry");
+  };
+  const references2 = {
+    name(name, geometry) {
+      planar(geometry);
+      const refs = merge([geometry]);
+      add(refs, name, { geometry: snapshot(geometry), matrix: identity() });
+      return attach(geometry, refs);
+    },
+    nameOutlines(geometry, names) {
+      if (!k.geometries.geom2.isA(geometry))
+        throw new Error("nameOutlines requires a native Geom2");
+      const refs = merge([geometry]);
+      const outlines = k.geometries.geom2.toOutlines(
+        snapshot(geometry)
+      );
+      const area = (points) => points.reduce((sum, p, i) => {
+        const q = points[(i + 1) % points.length];
+        return sum + p[0] * q[1] - p[1] * q[0];
+      }, 0);
+      for (const [role, name] of Object.entries(names)) {
+        if (name === void 0) continue;
+        if (role !== "outer" && role !== "hole")
+          throw new Error(`Unknown outline role: ${role}`);
+        const matches = outlines.filter(
+          (points) => role === "outer" ? area(points) > 0 : area(points) < 0
+        );
+        if (matches.length !== 1)
+          throw new Error(
+            `Expected exactly one ${role} outline, found ${matches.length}`
+          );
+        add(refs, name, {
+          geometry: k.geometries.path2.fromPoints({ closed: true }, matches[0]),
+          matrix: identity()
+        });
+      }
+      return attach(geometry, refs);
+    },
+    reference(name, geometry) {
+      return attach(
+        k.geometries.geom3.create(),
+        read(references2.name(name, geometry))
+      );
+    },
+    get(geometry, name) {
+      const ref = read(geometry)[name];
+      if (!Object.hasOwn(read(geometry), name))
+        throw new Error(`Unknown reference: ${name}`);
+      return snapshot(ref);
+    },
+    list(geometry) {
+      return Object.keys(read(geometry));
+    },
+    collect(geometries9) {
+      return snapshot(merge(inputs([geometries9])));
+    }
+  };
+  const wrapped = { ...k, references: references2 };
+  for (const namespace of [
+    "booleans",
+    "hulls",
+    "expansions",
+    "modifiers",
+    "extrusions",
+    "colors"
+  ]) {
+    wrapped[namespace] = { ...k[namespace] };
+    for (const [name, fn] of Object.entries(k[namespace]))
+      if (typeof fn === "function") {
+        wrapped[namespace][name] = (...args) => {
+          const refs = merge(inputs(args));
+          let result = fn(...args);
+          if (namespace === "booleans" && name === "subtract" && k.geometries.geom3.isA(result)) {
+            result = cleanupSubtraction(kernel, result);
+          }
+          return attach(result, refs);
+        };
+      }
+  }
+  const transformResult = (fn, args, offset, boundsBased = false) => {
+    const gs = inputs(args.slice(offset));
+    if (!gs.some((g) => Object.keys(read(g)).length)) return fn(...args);
+    const maps = gs.map((g) => read(g));
+    const before = boundsBased ? gs.map((g) => k.measurements.measureBoundingBox(snapshot(g))[0]) : [];
+    const matrix = boundsBased ? null : fn(...args.slice(0, offset), k.geometries.geom3.create()).transforms;
+    const result = fn(...args);
+    const results = Array.isArray(result) ? result : [result];
+    const output = results.map((g, i) => {
+      let m = matrix;
+      if (boundsBased) {
+        const after = k.measurements.measureBoundingBox(snapshot(g))[0];
+        m = mat4.fromTranslation(
+          mat4.create(),
+          after.map((n, axis) => n - before[i][axis])
+        );
+      }
+      return attach(g, moved(maps[i], Array.from(m)));
+    });
+    return Array.isArray(result) ? output : output[0];
+  };
+  wrapped.transforms = { ...k.transforms };
+  for (const [name, fn] of Object.entries(k.transforms)) {
+    const boundsBased = /^(center|align)/.test(name);
+    const offset = /^center[XYZ]$|^mirror[XYZ]$/.test(name) ? 0 : 1;
+    wrapped.transforms[name] = (...args) => transformResult(fn, args, offset, boundsBased);
+  }
+  wrapped.geometries = { ...k.geometries };
+  for (const ns of ["geom2", "geom3", "path2"]) {
+    wrapped.geometries[ns] = {
+      ...k.geometries[ns],
+      transform: (matrix, g) => attach(k.geometries[ns].transform(matrix, g), moved(read(g), matrix))
+    };
+  }
+  wrapped.extrusions.extrudeLinear = (options, ...objects) => {
+    const gs = inputs(objects);
+    const { topOutlineName, bottomOutlineName } = options ?? {};
+    if (topOutlineName === void 0 && bottomOutlineName === void 0) {
+      const refs2 = gs.map(read);
+      const result = k.extrusions.extrudeLinear(options, ...objects);
+      return Array.isArray(result) ? result.map((g, i) => attach(g, refs2[i])) : attach(result, refs2[0] ?? {});
+    }
+    if (gs.length !== 1)
+      throw new Error("Named extrusion outlines require exactly one profile");
+    const profile5 = gs[0];
+    planar(profile5);
+    if (k.geometries.path2.isA(profile5) && !profile5.isClosed)
+      throw new Error("Named extrusion outlines require a closed path");
+    const { height: height10 = 1, twistAngle = 0, twistSteps = 1 } = options;
+    if (!Number.isFinite(height10) || !Number.isFinite(twistAngle) || !Number.isInteger(twistSteps) || twistSteps < 1)
+      throw new Error(
+        "Invalid named extrusion height, twistAngle or twistSteps"
+      );
+    const refs = merge(gs);
+    const source = snapshot(profile5);
+    const top = multiply(
+      Array.from(mat4.fromTranslation(mat4.create(), [0, 0, height10])),
+      Array.from(mat4.fromZRotation(mat4.create(), twistAngle))
+    );
+    for (const [prefix, matrix] of [
+      [bottomOutlineName, identity()],
+      [topOutlineName, top]
+    ]) {
+      if (prefix === void 0) continue;
+      add(refs, prefix, { geometry: source, matrix });
+      for (const [name, ref] of Object.entries(read(profile5)))
+        add(refs, `${prefix}.${name}`, {
+          geometry: ref.geometry,
+          matrix: multiply(matrix, ref.matrix)
+        });
+    }
+    return attach(k.extrusions.extrudeLinear(options, ...objects), refs);
+  };
+  cache.set(kernel, wrapped);
+  cache.set(wrapped, wrapped);
+  return wrapped;
+}
+
+// node_modules/@tscircuit/jscad/lib/geom3-to-indexed-mesh.ts
+import jscad2 from "@jscad/modeling";
+var edgeKey = (a, b) => a < b ? `${a},${b}` : `${b},${a}`;
+function geom3ToIndexedMesh(input) {
+  const generalize8 = jscad2.modifiers.generalize;
+  input = structuredClone(input);
+  const inputExtent = Math.max(...jscad2.measurements.measureDimensions(input));
+  if (!Number.isFinite(inputExtent) || inputExtent <= 0)
+    throw new Error("Expected finite nonempty geometry");
+  const weldTolerance = Math.max(inputExtent * 1e-10, 1e-12);
+  const cells = /* @__PURE__ */ new Map();
+  const weld = (v) => {
+    if (v.length !== 3 || v.some((value) => !Number.isFinite(value)))
+      throw new Error("Expected finite mesh coordinates");
+    const cell = v.map((value) => Math.floor(value / weldTolerance));
+    for (let x = -1; x <= 1; x++)
+      for (let y = -1; y <= 1; y++)
+        for (let z = -1; z <= 1; z++) {
+          const entries2 = cells.get(
+            `${cell[0] + x},${cell[1] + y},${cell[2] + z}`
+          );
+          const existing = entries2?.find(
+            (point3) => Math.hypot(...v.map((value, axis) => value - point3[axis])) <= weldTolerance
+          );
+          if (existing) return existing;
+        }
+    const point2 = [v[0], v[1], v[2]], key = cell.join(","), entries = cells.get(key);
+    if (entries) entries.push(point2);
+    else cells.set(key, [point2]);
+    return point2;
+  };
+  const welded = jscad2.geometries.geom3.fromPoints(
+    jscad2.geometries.geom3.toPolygons(input).map((poly) => poly.vertices.map(weld))
+  );
+  const geom = generalize8({ snap: true, triangulate: true }, welded);
+  const extent = Math.max(...jscad2.measurements.measureDimensions(geom));
+  if (!Number.isFinite(extent) || extent <= 0)
+    throw new Error("Expected finite nonempty geometry");
+  const epsilon = Math.max(extent * 1e-10, 1e-12);
+  const snapTolerance = Math.max(
+    2 * jscad2.measurements.measureEpsilon(geom),
+    epsilon
+  );
+  const positions = [], indices = [];
+  const lookup = /* @__PURE__ */ new Map();
+  const point = (index) => [
+    positions[index * 3],
+    positions[index * 3 + 1],
+    positions[index * 3 + 2]
+  ];
+  const vertex = (v) => {
+    if (v.length !== 3 || v.some((value) => !Number.isFinite(value)))
+      throw new Error("Expected finite mesh coordinates");
+    const key = v.map((x) => Math.round(x / epsilon)).join(",");
+    let index = lookup.get(key);
+    if (index === void 0) {
+      index = positions.length / 3;
+      positions.push(...v);
+      lookup.set(key, index);
+    }
+    return index;
+  };
+  const area = ([a, b, c]) => {
+    const pa = point(a), pb = point(b), pc = point(c);
+    const u = pb.map((x, i) => x - pa[i]), v = pc.map((x, i) => x - pa[i]);
+    return 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]
+    );
+  };
+  const triangles = [];
+  const edges = /* @__PURE__ */ new Map();
+  for (const poly of jscad2.geometries.geom3.toPolygons(geom)) {
+    for (let i = 1; i < poly.vertices.length - 1; i++) {
+      const triangle = [
+        vertex(poly.vertices[0]),
+        vertex(poly.vertices[i]),
+        vertex(poly.vertices[i + 1])
+      ];
+      if (area(triangle) <= epsilon * epsilon) continue;
+      triangles.push(triangle);
+      triangle.forEach((a, i2) => {
+        const b = triangle[(i2 + 1) % 3], key = edgeKey(a, b), entry = edges.get(key);
+        if (entry) entry.count++;
+        else edges.set(key, { a, b, count: 1 });
+      });
+    }
+  }
+  const unmatched = [...edges.values()].filter(({ count }) => count === 1);
+  const candidates = [...new Set(unmatched.flatMap(({ a, b }) => [a, b]))];
+  const sorted = [0, 1, 2].map(
+    (axis) => [...candidates].sort(
+      (a, b) => positions[a * 3 + axis] - positions[b * 3 + axis]
+    )
+  );
+  const subdivisions = /* @__PURE__ */ new Map();
+  for (const { a, b } of unmatched) {
+    const pa = point(a), pb = point(b), direction = pb.map((x, i) => x - pa[i]), length32 = Math.hypot(...direction);
+    if (length32 <= epsilon) continue;
+    const axis = direction.reduce(
+      (best, x, i) => Math.abs(x) > Math.abs(direction[best]) ? i : best,
+      0
+    );
+    const unit = direction.map((x) => x / length32), low = Math.min(pa[axis], pb[axis]), high = Math.max(pa[axis], pb[axis]);
+    const byAxis = sorted[axis];
+    let left = 0, right = byAxis.length;
+    while (left < right) {
+      const mid = left + right >>> 1;
+      if (positions[byAxis[mid] * 3 + axis] < low) left = mid + 1;
+      else right = mid;
+    }
+    const splits = [];
+    for (let i = left; i < byAxis.length; i++) {
+      const index = byAxis[i], p = point(index);
+      if (p[axis] > high) break;
+      if (index === a || index === b) continue;
+      const delta = p.map((x, j) => x - pa[j]), along = delta.reduce((sum, x, j) => sum + x * unit[j], 0);
+      if (along <= epsilon || along >= length32 - epsilon) continue;
+      const distance2 = Math.hypot(...delta.map((x, j) => x - along * unit[j]));
+      if (distance2 <= snapTolerance) splits.push({ index, t: along / length32 });
+    }
+    if (splits.length)
+      subdivisions.set(
+        edgeKey(a, b),
+        splits.sort((x, y) => x.t - y.t).map(({ index }) => index)
+      );
+  }
+  for (const triangle of triangles) {
+    const boundary = triangle.flatMap((a, i) => {
+      const b = triangle[(i + 1) % 3], splits = subdivisions.get(edgeKey(a, b));
+      if (!splits) return [a];
+      const edge = edges.get(edgeKey(a, b));
+      return [a, ...edge.a === a ? splits : [...splits].reverse()];
+    });
+    if (boundary.length === 3) {
+      indices.push(...triangle);
+      continue;
+    }
+    const origin = point(boundary[0]);
+    const center = origin.map(
+      (value, axis) => value + boundary.reduce(
+        (sum, index) => sum + (point(index)[axis] - value) / boundary.length,
+        0
+      )
+    );
+    const middle = vertex(center);
+    for (let i = 0; i < boundary.length; i++) {
+      const part = [
+        middle,
+        boundary[i],
+        boundary[(i + 1) % boundary.length]
+      ];
+      if (area(part) <= epsilon * epsilon)
+        throw new Error("Unable to preserve a degenerate mesh boundary");
+      indices.push(...part);
+    }
+  }
+  const compactPositions = [], compactIndices = [], remap = /* @__PURE__ */ new Map();
+  for (const original of indices) {
+    let index = remap.get(original);
+    if (index === void 0) {
+      index = compactPositions.length / 3;
+      compactPositions.push(...point(original));
+      remap.set(original, index);
+    }
+    compactIndices.push(index);
+  }
+  if (!compactIndices.length)
+    throw new Error("Expected finite nonempty geometry");
+  return { positions: compactPositions, indices: compactIndices };
+}
+
+// node_modules/@tscircuit/jscad/lib/index.ts
+var jscad3 = withReferences();
+var {
+  booleans,
+  colors,
+  curves,
+  expansions,
+  extrusions,
+  geometries,
+  hulls,
+  maths,
+  measurements,
+  modifiers,
+  primitives,
+  text,
+  transforms,
+  utils,
+  references
+} = jscad3;
+
 // lib/A0201.tsx
 import { Cuboid as Cuboid2 } from "jscad-fiber";
 import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
@@ -12903,7 +13401,7 @@ function getNemaMotorReferencePoints(input) {
     (p.bodyWidth - p.faceCornerChamfer) / (Math.abs(x) + Math.abs(y))
   );
   if (p.nemaSize !== 34 || p.stepped) {
-    const profile6 = p.nemaSize === 34 ? {
+    const profile5 = p.nemaSize === 34 ? {
       width: p.bodyWidth,
       chamfer: p.bodyCornerChamfer,
       stepped: p.stepped,
@@ -12919,7 +13417,7 @@ function getNemaMotorReferencePoints(input) {
     let low = 0, high = p.bodyWidth;
     for (let i = 0; i < 50; i++) {
       const mid = (low + high) / 2;
-      if (isInsideNemaFace(mid * x, mid * y, profile6)) low = mid;
+      if (isInsideNemaFace(mid * x, mid * y, profile5)) low = mid;
       else high = mid;
     }
     radius = low;
@@ -13285,11 +13783,11 @@ var ModelRendererRegistry = class {
 import { Colorize as Colorize7, Custom } from "jscad-fiber";
 
 // lib/models/anglebar/geometry.ts
-import jscad from "@jscad/modeling";
-var { primitives, extrusions, geometries, modifiers, measurements } = jscad;
-var generalize = modifiers.generalize;
-var { rectangle, roundedRectangle, polygon } = primitives;
-var profile = (shape49, height10) => extrusions.extrudeLinear({ height: height10 }, shape49);
+import jscad4 from "@jscad/modeling";
+var { primitives: primitives2, extrusions: extrusions2, geometries: geometries2, modifiers: modifiers2, measurements: measurements2 } = jscad4;
+var generalize = modifiers2.generalize;
+var { rectangle, roundedRectangle, polygon } = primitives2;
+var profile = (shape49, height10) => extrusions2.extrudeLinear({ height: height10 }, shape49);
 function filletProfile(points, radii, width10, height10) {
   const outline = [];
   for (let i = 0; i < points.length; i++) {
@@ -13348,7 +13846,7 @@ function createAngleBarMesh(input) {
     { snap: true, triangulate: true },
     createAngleBarGeom(input)
   );
-  const epsilon = Math.max(...measurements.measureDimensions(geom)) * 1e-10;
+  const epsilon = Math.max(...measurements2.measureDimensions(geom)) * 1e-10;
   const positions = [];
   const indices = [];
   const lookup = /* @__PURE__ */ new Map();
@@ -13362,7 +13860,7 @@ function createAngleBarMesh(input) {
     }
     return index;
   };
-  for (const poly of geometries.geom3.toPolygons(geom)) {
+  for (const poly of geometries2.geom3.toPolygons(geom)) {
     for (let i = 1; i < poly.vertices.length - 1; i++) {
       const a = poly.vertices[0], b = poly.vertices[i], c = poly.vertices[i + 1];
       const u = b.map((x, j) => x - a[j]), v = c.map((x, j) => x - a[j]);
@@ -13400,7 +13898,7 @@ function register55(registry2) {
 import { Colorize as Colorize8, Custom as Custom2 } from "jscad-fiber";
 
 // lib/mechanical/indexedMeshToGeom3.ts
-import jscad2 from "@jscad/modeling";
+import jscad5 from "@jscad/modeling";
 function indexedMeshToGeom3(mesh) {
   const polygons = [];
   for (let i = 0; i < mesh.indices.length; i += 3)
@@ -13411,7 +13909,7 @@ function indexedMeshToGeom3(mesh) {
         mesh.positions[index * 3 + 2]
       ])
     );
-  return jscad2.geometries.geom3.fromPoints(polygons);
+  return jscad5.geometries.geom3.fromPoints(polygons);
 }
 
 // lib/models/ballbearing/mesh.ts
@@ -13540,11 +14038,11 @@ function createBallBearingMesh(input = {}, options = {}) {
       [ri + 0.15 * (ro - ri), 0.5 * t],
       [ro - 0.15 * (ro - ri), 0.5 * t]
     ];
-    const profile6 = sign === -1 ? shape49 : shape49.map(([r, z]) => [r, d.width - z]).reverse();
+    const profile5 = sign === -1 ? shape49 : shape49.map(([r, z]) => [r, d.width - z]).reverse();
     parts.push({
       name: `${face2} ${sign < 0 ? "lower" : "upper"}`,
       color: face2 === "sealed" ? "#252a30" : "#b5bbc3",
-      mesh: revolve(profile6, segments)
+      mesh: revolve(profile5, segments)
     });
   }
   return { ...combine(parts), parts };
@@ -13561,21 +14059,21 @@ function checkPrecision(lengths25) {
       "Bearing dimensions exceed the renderer's numerical resolution"
     );
 }
-function revolve(profile6, segments) {
+function revolve(profile5, segments) {
   const positions = [];
   const indices = [];
-  for (const [radius, z] of profile6)
+  for (const [radius, z] of profile5)
     for (let i = 0; i < segments; i++) {
       const angle = i * Math.PI * 2 / segments;
       const r = typeof radius === "number" ? radius : radius(angle);
       positions.push(r * Math.cos(angle), r * Math.sin(angle), z);
     }
-  for (let j = 0; j < profile6.length; j++)
+  for (let j = 0; j < profile5.length; j++)
     for (let i = 0; i < segments; i++) {
       const a = j * segments + i;
       const b = j * segments + (i + 1) % segments;
-      const c = (j + 1) % profile6.length * segments + (i + 1) % segments;
-      const e = (j + 1) % profile6.length * segments + i;
+      const c = (j + 1) % profile5.length * segments + (i + 1) % segments;
+      const e = (j + 1) % profile5.length * segments + i;
       indices.push(a, b, c, a, c, e);
     }
   return { positions, indices };
@@ -13586,7 +14084,7 @@ function annularSector(inner, outer, z0, z1, start, end, segments) {
     Math.ceil((end - start) / (2 * Math.PI) * segments)
   );
   const count = steps + 1;
-  const profile6 = [
+  const profile5 = [
     [outer, z0],
     [outer, z1],
     [inner, z1],
@@ -13594,7 +14092,7 @@ function annularSector(inner, outer, z0, z1, start, end, segments) {
   ];
   const positions = [];
   const indices = [];
-  for (const [r, z] of profile6)
+  for (const [r, z] of profile5)
     for (let i = 0; i <= steps; i++) {
       const angle = start + (end - start) * i / steps;
       positions.push(r * Math.cos(angle), r * Math.sin(angle), z);
@@ -13790,7 +14288,7 @@ function createBallTransferUnitMesh(input = {}) {
     );
   const segments = 96;
   const latitude = 48;
-  const profile6 = [
+  const profile5 = [
     [d.bodyRadius, 0],
     [d.bodyRadius, d.flangeBottomZ],
     [d.flangeRadius, d.flangeBottomZ],
@@ -13803,12 +14301,12 @@ function createBallTransferUnitMesh(input = {}) {
   for (let j = 1; j < latitude; j++) {
     const angle = j * Math.PI / latitude;
     if ((angle - openingAngle) * d.socketRadius > resolution7)
-      profile6.push([
+      profile5.push([
         d.socketRadius * Math.sin(angle),
         d.ballCenterZ + d.socketRadius * Math.cos(angle)
       ]);
   }
-  profile6.push([0, d.socketBottomZ], [0, 0]);
+  profile5.push([0, d.socketBottomZ], [0, 0]);
   const holes = d.mountingHoles.map(
     ({ x, y, diameter }) => circularProfile(x, y, diameter / 2, segments)
   );
@@ -13816,7 +14314,7 @@ function createBallTransferUnitMesh(input = {}) {
   const housing = joinProfileMeshes([
     // Cap faces are triangulated with all openings, rather than covered by
     // annular triangles and repaired afterward with Boolean subtraction.
-    revolve2(profile6, segments, /* @__PURE__ */ new Set([1, 3])),
+    revolve2(profile5, segments, /* @__PURE__ */ new Set([1, 3])),
     cap(
       flangeOutline,
       [circularProfile(0, 0, d.bodyRadius, segments), ...holes],
@@ -13853,10 +14351,10 @@ function createBallTransferUnitMesh(input = {}) {
   ];
   return { positions, indices, parts };
 }
-function revolve2(profile6, segments, omittedEdges = /* @__PURE__ */ new Set()) {
+function revolve2(profile5, segments, omittedEdges = /* @__PURE__ */ new Set()) {
   const positions = [];
   const indices = [];
-  const rings = profile6.map(([radius, z]) => {
+  const rings = profile5.map(([radius, z]) => {
     const start = positions.length / 3;
     const count = radius === 0 ? 1 : segments;
     for (let i = 0; i < count; i++) {
@@ -14153,11 +14651,11 @@ function register59(registry2) {
 import { Colorize as Colorize12, Custom as Custom6 } from "jscad-fiber";
 
 // lib/models/channelbar/geometry.ts
-import jscad3 from "@jscad/modeling";
-var { primitives: primitives2, extrusions: extrusions2, geometries: geometries2, modifiers: modifiers2, measurements: measurements2 } = jscad3;
-var generalize2 = modifiers2.generalize;
-var { rectangle: rectangle2, roundedRectangle: roundedRectangle2, polygon: polygon2 } = primitives2;
-var profile2 = (shape49, height10) => extrusions2.extrudeLinear({ height: height10 }, shape49);
+import jscad6 from "@jscad/modeling";
+var { primitives: primitives3, extrusions: extrusions3, geometries: geometries3, modifiers: modifiers3, measurements: measurements3 } = jscad6;
+var generalize2 = modifiers3.generalize;
+var { rectangle: rectangle2, roundedRectangle: roundedRectangle2, polygon: polygon2 } = primitives3;
+var profile2 = (shape49, height10) => extrusions3.extrudeLinear({ height: height10 }, shape49);
 function filletProfile2(points, radii, width10, height10) {
   const outline = [];
   for (let i = 0; i < points.length; i++) {
@@ -14227,7 +14725,7 @@ function createChannelBarMesh(input) {
     { snap: true, triangulate: true },
     createChannelBarGeom(input)
   );
-  const epsilon = Math.max(...measurements2.measureDimensions(geom)) * 1e-10;
+  const epsilon = Math.max(...measurements3.measureDimensions(geom)) * 1e-10;
   const positions = [];
   const indices = [];
   const lookup = /* @__PURE__ */ new Map();
@@ -14241,7 +14739,7 @@ function createChannelBarMesh(input) {
     }
     return index;
   };
-  for (const poly of geometries2.geom3.toPolygons(geom)) {
+  for (const poly of geometries3.geom3.toPolygons(geom)) {
     for (let i = 1; i < poly.vertices.length - 1; i++) {
       const a = poly.vertices[0], b = poly.vertices[i], c = poly.vertices[i + 1];
       const u = b.map((x, j) => x - a[j]), v = c.map((x, j) => x - a[j]);
@@ -14279,10 +14777,10 @@ function register60(registry2) {
 import { Colorize as Colorize13, Custom as Custom7 } from "jscad-fiber";
 
 // lib/models/clampingshaftcollar/mesh.ts
-import jscad5 from "@jscad/modeling";
+import jscad8 from "@jscad/modeling";
 
 // lib/mechanical/shaft-mount-geometry.ts
-import jscad4 from "@jscad/modeling";
+import jscad7 from "@jscad/modeling";
 var bodySegments = 64;
 var threadSegments = 24;
 var samplesPerTurn = 12;
@@ -14325,22 +14823,22 @@ function createAnnularSleeve({
     [chamfer, boreARadius, true],
     [0, boreARadius + chamfer, true]
   ];
-  const profile6 = raw.filter(
+  const profile5 = 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 profile6)
+  for (const [z, r, isBore] of profile5)
     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 < profile6.length; row++)
+  for (let row = 0; row < profile5.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) % profile6.length * bodySegments + next, d = (row + 1) % profile6.length * bodySegments + i;
+      const c = (row + 1) % profile5.length * bodySegments + next, d = (row + 1) % profile5.length * bodySegments + i;
       indices.push(a, b, c, a, c, d);
     }
   return indexedMeshToGeom3({ positions, indices });
@@ -14398,10 +14896,10 @@ function createMountingHoleCutter(hole) {
 function subtractShaftMountParts(body, ...cutters) {
   const factor = 100;
   const scaled = [body, ...cutters].map(
-    (geometry) => jscad4.transforms.scale([factor, factor, factor], geometry)
+    (geometry) => jscad7.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);
+  const result = jscad7.booleans.subtract(scaled[0], ...scaled.slice(1));
+  return jscad7.transforms.scale([1 / factor, 1 / factor, 1 / factor], result);
 }
 function finishShaftMountMesh(geometry) {
   const positions = [];
@@ -14427,7 +14925,7 @@ function finishShaftMountMesh(geometry) {
     vertices.set(key, [...vertices.get(key) ?? [], index]);
     return index;
   };
-  const polygons = jscad4.geometries.geom3.toPolygons(geometry).map(
+  const polygons = jscad7.geometries.geom3.toPolygons(geometry).map(
     (polygon4) => polygon4.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;
@@ -14450,11 +14948,11 @@ function finishShaftMountMesh(geometry) {
       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 edgeKey2 = (a, b) => `${Math.min(a, b)},${Math.max(a, b)}`;
   const edges = /* @__PURE__ */ new Map();
   for (const polygon4 of polygons)
     for (let i = 0; i < polygon4.length; i++) {
-      const a = polygon4[i], b = polygon4[(i + 1) % polygon4.length], key = edgeKey(a, b);
+      const a = polygon4[i], b = polygon4[(i + 1) % polygon4.length], key = edgeKey2(a, b);
       const edge = edges.get(key) ?? { a, b, count: 0 };
       edge.count++;
       edges.set(key, edge);
@@ -14539,7 +15037,7 @@ function createClampingShaftCollarMesh(input) {
   });
   const s = dimensions5.split;
   const epsilon = 1e-4;
-  const slit = jscad5.primitives.cuboid({
+  const slit = jscad8.primitives.cuboid({
     size: [
       s.xMax - s.xMin + epsilon,
       s.yMax - s.yMin,
@@ -15139,7 +15637,7 @@ function createFlangedBushingMesh(input) {
   const ri = d.innerDiameter / 2;
   const ro = d.outerDiameter / 2;
   const rf = d.flangeDiameter / 2;
-  const profile6 = [
+  const profile5 = [
     [rf, 0],
     [rf, d.shoulderZ],
     [ro, d.shoulderZ],
@@ -15150,14 +15648,14 @@ function createFlangedBushingMesh(input) {
   const segments = 96;
   const positions = [];
   const indices = [];
-  for (const [radius, z] of profile6)
+  for (const [radius, z] of profile5)
     for (let i = 0; i < segments; i++) {
       const angle = i * Math.PI * 2 / segments;
       positions.push(radius * Math.cos(angle), radius * Math.sin(angle), z);
     }
-  for (let ring = 0; ring < profile6.length; ring++) {
+  for (let ring = 0; ring < profile5.length; ring++) {
     const a = ring * segments;
-    const b = (ring + 1) % profile6.length * segments;
+    const b = (ring + 1) % profile5.length * segments;
     for (let i = 0; i < segments; i++) {
       const next = (i + 1) % segments;
       indices.push(a + i, a + next, b + next, a + i, b + next, b + i);
@@ -15312,15 +15810,15 @@ function register67(registry2) {
 import { Colorize as Colorize20, Custom as Custom14 } from "jscad-fiber";
 
 // lib/models/flatcableclip/geometry.ts
-import jscad6 from "@jscad/modeling";
+import jscad9 from "@jscad/modeling";
 var {
-  primitives: primitives3,
-  extrusions: extrusions3,
-  transforms,
-  booleans,
-  geometries: geometries3,
-  measurements: measurements3
-} = jscad6;
+  primitives: primitives4,
+  extrusions: extrusions4,
+  transforms: transforms2,
+  booleans: booleans2,
+  geometries: geometries4,
+  measurements: measurements4
+} = jscad9;
 function createFlatCableClipSolid(input) {
   const p = flatCableClipModelPropsSchema.parse(input);
   const legOuter = p.innerWidth / 2 + p.thickness, half = legOuter + p.footLength;
@@ -15338,25 +15836,25 @@ function createFlatCableClipSolid(input) {
     [-legOuter, p.thickness],
     [-half, p.thickness]
   ];
-  const bridge = transforms.translate(
+  const bridge = transforms2.translate(
     [0, p.depth / 2, 0],
-    transforms.rotateX(
+    transforms2.rotateX(
       Math.PI / 2,
-      extrusions3.extrudeLinear(
+      extrusions4.extrudeLinear(
         { height: p.depth },
-        primitives3.polygon({ points })
+        primitives4.polygon({ points })
       )
     )
   );
   const bores = [-1, 1].map(
-    (sign) => primitives3.cylinder({
+    (sign) => primitives4.cylinder({
       radius: p.holeDiameter / 2,
       height: p.thickness + 2,
       center: [sign * p.holePitch / 2, 0, p.thickness / 2],
       segments: 96
     })
   );
-  return booleans.subtract(bridge, ...bores);
+  return booleans2.subtract(bridge, ...bores);
 }
 function createFlatCableClipMesh(input) {
   const p = flatCableClipModelPropsSchema.parse(input);
@@ -15367,8 +15865,8 @@ function createFlatCableClipMesh(input) {
     [0, p.thickness, p.innerHeight, p.innerHeight + p.thickness]
   ];
   const geom = createFlatCableClipSolid(p);
-  const tolerance = Math.max(...measurements3.measureDimensions(geom)) * 1e-5;
-  const polygons = geometries3.geom3.toPolygons(geom).map(
+  const tolerance = Math.max(...measurements4.measureDimensions(geom)) * 1e-5;
+  const polygons = geometries4.geom3.toPolygons(geom).map(
     (poly) => poly.vertices.map(
       (point) => point.map((value, axis) => {
         const nearest = planes[axis].reduce(
@@ -15378,7 +15876,7 @@ function createFlatCableClipMesh(input) {
       })
     )
   );
-  return finishShaftMountMesh(geometries3.geom3.fromPoints(polygons));
+  return finishShaftMountMesh(geometries4.geom3.fromPoints(polygons));
 }
 function createFlatCableClipGeom(input) {
   return indexedMeshToGeom3(createFlatCableClipMesh(input));
@@ -17349,7 +17847,7 @@ function register79(registry2) {
 }
 
 // lib/utils/nemaMotorAssemblyGeometry.ts
-import jscad7 from "@jscad/modeling";
+import jscad10 from "@jscad/modeling";
 function nema34AssemblyCenters(p) {
   const edge = p.bodyWidth / 2;
   return [-1, 1].flatMap(
@@ -17359,16 +17857,16 @@ function nema34AssemblyCenters(p) {
   );
 }
 function cutNema34FrontRecesses(geometry, p) {
-  return jscad7.booleans.subtract(
+  return jscad10.booleans.subtract(
     geometry,
     ...nema34AssemblyCenters(p).flatMap(([x, y]) => [
-      jscad7.primitives.cylinder({
+      jscad10.primitives.cylinder({
         radius: 1.6,
         height: p.frontCapLength + 0.2,
         center: [x, y, -p.frontCapLength / 2],
         segments: 32
       }),
-      jscad7.primitives.cylinder({
+      jscad10.primitives.cylinder({
         radius: 5,
         height: Math.min(4, p.frontCapLength / 2) + 0.1,
         center: [
@@ -17382,8 +17880,8 @@ function cutNema34FrontRecesses(geometry, p) {
   );
 }
 function createNema34FrontScrews(p) {
-  const head = jscad7.booleans.subtract(
-    jscad7.primitives.ellipsoid({
+  const head = jscad10.booleans.subtract(
+    jscad10.primitives.ellipsoid({
       radius: [3.2, 3.2, 1.5],
       center: [0, 0, -1.8],
       segments: 32
@@ -17392,22 +17890,22 @@ function createNema34FrontScrews(p) {
       [3.7, 0.8, 1.1],
       [0.8, 3.7, 1.1]
     ].map(
-      (size) => jscad7.primitives.cuboid({
+      (size) => jscad10.primitives.cuboid({
         size,
         center: [0, 0, -0.8]
       })
     )
   );
   return nema34AssemblyCenters(p).map(
-    ([x, y]) => jscad7.transforms.translate([x, y, 0], head)
+    ([x, y]) => jscad10.transforms.translate([x, y, 0], head)
   );
 }
 
 // lib/NemaMotor.tsx
-import jscad9 from "@jscad/modeling";
+import jscad12 from "@jscad/modeling";
 
 // lib/utils/nemaMotorWireGeometry.ts
-import jscad8 from "@jscad/modeling";
+import jscad11 from "@jscad/modeling";
 
 // lib/utils/nemaMotorParameters.ts
 var resolveNemaMotorProps = nemaMotorModelPropsSchema.parse.bind(nemaMotorModelPropsSchema);
@@ -17418,12 +17916,12 @@ function createNemaMotorWireGeometry(input) {
   if (p.noWires) return [];
   const { position } = getNemaMotorReferencePoints(p).wireside;
   const angle = p.wireSideAngle * Math.PI / 180;
-  const place = (geometry) => jscad8.transforms.translate(
+  const place = (geometry) => jscad11.transforms.translate(
     [position.x, position.y, position.z],
-    jscad8.transforms.rotateZ(angle, geometry)
+    jscad11.transforms.rotateZ(angle, geometry)
   );
   if (p.wireStubs) {
-    const colors = [
+    const colors2 = [
       "#d53f3f",
       "#2463af",
       "#3b934b",
@@ -17434,17 +17932,17 @@ function createNemaMotorWireGeometry(input) {
       "#803e91"
     ];
     const wires = Array.from({ length: p.wireCount }, (_, i) => ({
-      color: colors[i],
+      color: colors2[i],
       geometry: place(
-        jscad8.transforms.translate(
+        jscad11.transforms.translate(
           [
             (p.wireLength - 0.15) / 2,
             (i - (p.wireCount - 1) / 2) * p.wireDiameter * 1.5,
             0
           ],
-          jscad8.transforms.rotateY(
+          jscad11.transforms.rotateY(
             Math.PI / 2,
-            jscad8.primitives.cylinder({
+            jscad11.primitives.cylinder({
               height: p.wireLength + 0.15,
               radius: p.wireDiameter / 2,
               segments: 24
@@ -17457,7 +17955,7 @@ function createNemaMotorWireGeometry(input) {
       wires.unshift({
         color: "#252830",
         geometry: place(
-          jscad8.primitives.roundedCuboid({
+          jscad11.primitives.roundedCuboid({
             size: [3, p.wireCount * p.wireDiameter * 1.5 + 3, 6],
             center: [0.8, 0, 0],
             roundRadius: 1,
@@ -17472,12 +17970,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 = jscad8.booleans.subtract(
-    jscad8.primitives.cuboid({
+  const shell = jscad11.booleans.subtract(
+    jscad11.primitives.cuboid({
       size: [matingDepth + 0.1, bodyWidth, bodyHeight],
       center: [(matingDepth - 0.1) / 2, 0, 0]
     }),
-    jscad8.primitives.cuboid({
+    jscad11.primitives.cuboid({
       size: [matingDepth - 0.5, bodyWidth - 2 * wall, bodyHeight - 2 * wall],
       center: [matingDepth / 2 + 0.55, 0, 0]
     })
@@ -17487,7 +17985,7 @@ function createNemaMotorWireGeometry(input) {
     ...Array.from({ length: pinCount }, (_, i) => ({
       color: "#b8bec6",
       geometry: place(
-        jscad8.primitives.cuboid({
+        jscad11.primitives.cuboid({
           size: [contactLength, contactSize, contactSize],
           center: [contactLength / 2, (i - (pinCount - 1) / 2) * pitch, 0]
         })
@@ -17631,12 +18129,12 @@ function createNemaMotorSections(input) {
   else {
     const cut = r - p.shaftFlatDepth;
     const angle = Math.acos(cut / r);
-    const profile6 = Array.from({ length: 97 }, (_, i) => {
+    const profile5 = Array.from({ length: 97 }, (_, i) => {
       const a = angle + (2 * Math.PI - 2 * angle) * i / 96;
       return [r * Math.cos(a), r * Math.sin(a)];
     });
     const rotation = p.shaftFlatAngle * Math.PI / 180;
-    const d = profile6.map(([x, y]) => [
+    const d = profile5.map(([x, y]) => [
       x * Math.cos(rotation) - y * Math.sin(rotation),
       x * Math.sin(rotation) + y * Math.cos(rotation)
     ]);
@@ -17649,7 +18147,7 @@ function createNemaMotorSections(input) {
 // lib/NemaMotor.tsx
 import { Colorize as Colorize33, Custom as Custom25 } from "jscad-fiber";
 import { Fragment as Fragment17, jsx as jsx67, jsxs as jsxs17 } from "react/jsx-runtime";
-var generalize3 = jscad9.modifiers.generalize;
+var generalize3 = jscad12.modifiers.generalize;
 function NemaMotor({
   bodyColor = "#242830",
   capColor = "#aeb5bd",
@@ -17658,7 +18156,7 @@ function NemaMotor({
   ...props
 }) {
   const p = resolveNemaMotorProps(props);
-  const screw = p.backFaceScrews ? jscad9.transforms.rotateX(
+  const screw = p.backFaceScrews ? jscad12.transforms.rotateX(
     Math.PI,
     createHexSocketBoltGeom({
       metricSize: p.backFaceScrewSize,
@@ -17670,16 +18168,16 @@ function NemaMotor({
   const halfPitchY = p.backFaceHoleSpacingY / 2;
   return /* @__PURE__ */ jsxs17(Fragment17, { children: [
     createNemaMotorSections(p).map((section, index) => {
-      const outline = jscad9.geometries.geom2.fromPoints(section.outline);
-      const profile6 = section.holes.length ? jscad9.booleans.subtract(
+      const outline = jscad12.geometries.geom2.fromPoints(section.outline);
+      const profile5 = section.holes.length ? jscad12.booleans.subtract(
         outline,
-        ...section.holes.map((h) => jscad9.geometries.geom2.fromPoints(h))
+        ...section.holes.map((h) => jscad12.geometries.geom2.fromPoints(h))
       ) : outline;
-      let geometry = jscad9.transforms.translate(
+      let geometry = jscad12.transforms.translate(
         [0, 0, section.zMin],
-        jscad9.extrusions.extrudeLinear(
+        jscad12.extrusions.extrudeLinear(
           { height: section.zMax - section.zMin },
-          profile6
+          profile5
         )
       );
       if (p.nemaSize === 34 && section.name === "frontCap")
@@ -17721,7 +18219,7 @@ function NemaMotor({
           children: /* @__PURE__ */ jsx67(
             Custom25,
             {
-              geometry: jscad9.transforms.translate(
+              geometry: jscad12.transforms.translate(
                 [x, y, -p.bodyLength],
                 generalize3({ simplify: true }, screw)
               )
@@ -18230,19 +18728,19 @@ function register83(registry2) {
 import { Colorize as Colorize37, Custom as Custom29 } from "jscad-fiber";
 
 // lib/models/perforatedsheet/geometry.ts
-import jscad10 from "@jscad/modeling";
+import jscad13 from "@jscad/modeling";
 var {
-  booleans: booleans2,
-  primitives: primitives4,
-  extrusions: extrusions4,
-  geometries: geometries4,
-  modifiers: modifiers3,
-  measurements: measurements4
-} = jscad10;
-var generalize4 = modifiers3.generalize;
-var { subtract } = booleans2;
-var { rectangle: rectangle3, roundedRectangle: roundedRectangle3, circle: circle2 } = primitives4;
-var profile3 = (shape49, height10) => extrusions4.extrudeLinear({ height: height10 }, shape49);
+  booleans: booleans3,
+  primitives: primitives5,
+  extrusions: extrusions5,
+  geometries: geometries5,
+  modifiers: modifiers4,
+  measurements: measurements5
+} = jscad13;
+var generalize4 = modifiers4.generalize;
+var { subtract } = booleans3;
+var { rectangle: rectangle3, roundedRectangle: roundedRectangle3, circle: circle2 } = primitives5;
+var profile3 = (shape49, height10) => extrusions5.extrudeLinear({ height: height10 }, shape49);
 function perforated(p) {
   const holes = [];
   const rows = Math.floor((p.width - 2 * p.edgeY) / p.pitchY + 1 + 1e-10);
@@ -18273,7 +18771,7 @@ function createPerforatedSheetMesh(input) {
     { snap: true, triangulate: true },
     createPerforatedSheetGeom(input)
   );
-  const epsilon = Math.max(...measurements4.measureDimensions(geom)) * 1e-10;
+  const epsilon = Math.max(...measurements5.measureDimensions(geom)) * 1e-10;
   const positions = [];
   const indices = [];
   const lookup = /* @__PURE__ */ new Map();
@@ -18287,7 +18785,7 @@ function createPerforatedSheetMesh(input) {
     }
     return index;
   };
-  for (const poly of geometries4.geom3.toPolygons(geom)) {
+  for (const poly of geometries5.geom3.toPolygons(geom)) {
     for (let i = 1; i < poly.vertices.length - 1; i++) {
       const a = poly.vertices[0], b = poly.vertices[i], c = poly.vertices[i + 1];
       const u = b.map((x, j) => x - a[j]), v = c.map((x, j) => x - a[j]);
@@ -18334,7 +18832,7 @@ function createPlainBushingMesh(input) {
   const ri = d.innerDiameter / 2;
   const ro = d.outerDiameter / 2;
   const c = props.edgeChamfer;
-  const profile6 = c > 0 ? [
+  const profile5 = c > 0 ? [
     [d.endOuterDiameter / 2, 0],
     [ro, c],
     [ro, d.length - c],
@@ -18352,14 +18850,14 @@ function createPlainBushingMesh(input) {
   const segments = 96;
   const positions = [];
   const indices = [];
-  for (const [radius, z] of profile6)
+  for (const [radius, z] of profile5)
     for (let i = 0; i < segments; i++) {
       const angle = i * Math.PI * 2 / segments;
       positions.push(radius * Math.cos(angle), radius * Math.sin(angle), z);
     }
-  for (let ring = 0; ring < profile6.length; ring++) {
+  for (let ring = 0; ring < profile5.length; ring++) {
     const a = ring * segments;
-    const b = (ring + 1) % profile6.length * segments;
+    const b = (ring + 1) % profile5.length * segments;
     for (let i = 0; i < segments; i++) {
       const next = (i + 1) % segments;
       indices.push(a + i, a + next, b + next, a + i, b + next, b + i);
@@ -18396,13 +18894,13 @@ function register85(registry2) {
 import { Colorize as Colorize39, Custom as Custom31 } from "jscad-fiber";
 
 // lib/models/pushfitplug/geometry.ts
-import jscad11 from "@jscad/modeling";
-var { primitives: primitives5, extrusions: extrusions5, geometries: geometries5, modifiers: modifiers4, measurements: measurements5 } = jscad11;
-var generalize5 = modifiers4.generalize;
-var { rectangle: rectangle4, roundedRectangle: roundedRectangle4, polygon: polygon3 } = primitives5;
+import jscad14 from "@jscad/modeling";
+var { primitives: primitives6, extrusions: extrusions6, geometries: geometries6, modifiers: modifiers5, measurements: measurements6 } = jscad14;
+var generalize5 = modifiers5.generalize;
+var { rectangle: rectangle4, roundedRectangle: roundedRectangle4, polygon: polygon3 } = primitives6;
 function createPushFitPlugGeom(input) {
   const p = pushFitPlugModelPropsSchema.parse(input);
-  return extrusions5.extrudeRotate(
+  return extrusions6.extrudeRotate(
     { segments: 64 },
     polygon3({
       points: [
@@ -18421,7 +18919,7 @@ function createPushFitPlugMesh(input) {
     { snap: true, triangulate: true },
     createPushFitPlugGeom(input)
   );
-  const epsilon = Math.max(...measurements5.measureDimensions(geom)) * 1e-10;
+  const epsilon = Math.max(...measurements6.measureDimensions(geom)) * 1e-10;
   const positions = [];
   const indices = [];
   const lookup = /* @__PURE__ */ new Map();
@@ -18435,7 +18933,7 @@ function createPushFitPlugMesh(input) {
     }
     return index;
   };
-  for (const poly of geometries5.geom3.toPolygons(geom)) {
+  for (const poly of geometries6.geom3.toPolygons(geom)) {
     for (let i = 1; i < poly.vertices.length - 1; i++) {
       const a = poly.vertices[0], b = poly.vertices[i], c = poly.vertices[i + 1];
       const u = b.map((x, j) => x - a[j]), v = c.map((x, j) => x - a[j]);
@@ -18473,11 +18971,11 @@ function register86(registry2) {
 import { Colorize as Colorize40, Custom as Custom32 } from "jscad-fiber";
 
 // lib/models/rectangularbar/geometry.ts
-import jscad12 from "@jscad/modeling";
-var { primitives: primitives6, extrusions: extrusions6, geometries: geometries6, modifiers: modifiers5, measurements: measurements6 } = jscad12;
-var generalize6 = modifiers5.generalize;
-var { rectangle: rectangle5, roundedRectangle: roundedRectangle5 } = primitives6;
-var profile4 = (shape49, height10) => extrusions6.extrudeLinear({ height: height10 }, shape49);
+import jscad15 from "@jscad/modeling";
+var { primitives: primitives7, extrusions: extrusions7, geometries: geometries7, modifiers: modifiers6, measurements: measurements7 } = jscad15;
+var generalize6 = modifiers6.generalize;
+var { rectangle: rectangle5, roundedRectangle: roundedRectangle5 } = primitives7;
+var profile4 = (shape49, height10) => extrusions7.extrudeLinear({ height: height10 }, shape49);
 var roundedRect = (width10, height10, radius) => radius ? roundedRectangle5({
   size: [width10, height10],
   roundRadius: radius,
@@ -18492,7 +18990,7 @@ function createRectangularBarMesh(input) {
     { snap: true, triangulate: true },
     createRectangularBarGeom(input)
   );
-  const epsilon = Math.max(...measurements6.measureDimensions(geom)) * 1e-10;
+  const epsilon = Math.max(...measurements7.measureDimensions(geom)) * 1e-10;
   const positions = [];
   const indices = [];
   const lookup = /* @__PURE__ */ new Map();
@@ -18506,7 +19004,7 @@ function createRectangularBarMesh(input) {
     }
     return index;
   };
-  for (const poly of geometries6.geom3.toPolygons(geom)) {
+  for (const poly of geometries7.geom3.toPolygons(geom)) {
     for (let i = 1; i < poly.vertices.length - 1; i++) {
       const a = poly.vertices[0], b = poly.vertices[i], c = poly.vertices[i + 1];
       const u = b.map((x, j) => x - a[j]), v = c.map((x, j) => x - a[j]);
@@ -18658,83 +19156,63 @@ function register88(registry2) {
 }
 
 // lib/models/rectangulartube/RectangularTube.tsx
-import { Colorize as Colorize42, Custom as Custom34 } from "jscad-fiber";
+import {
+  Colorize as Colorize42,
+  ExtrudeLinear as ExtrudeLinear3,
+  Polygon as Polygon3,
+  Subtract as Subtract5
+} from "jscad-fiber/headless";
 
-// lib/models/rectangulartube/geometry.ts
-import jscad13 from "@jscad/modeling";
-var {
-  booleans: booleans3,
-  primitives: primitives7,
-  extrusions: extrusions7,
-  geometries: geometries7,
-  modifiers: modifiers6,
-  measurements: measurements7
-} = jscad13;
-var generalize7 = modifiers6.generalize;
-var { subtract: subtract2 } = booleans3;
-var { rectangle: rectangle6, roundedRectangle: roundedRectangle6 } = primitives7;
-var profile5 = (shape49, height10) => extrusions7.extrudeLinear({ height: height10 }, shape49);
-var roundedRect2 = (width10, height10, radius) => radius ? roundedRectangle6({
+// lib/models/rectangulartube/profiles.ts
+import jscad16 from "@jscad/modeling";
+var roundedRectangle6 = (width10, height10, radius) => radius ? jscad16.primitives.roundedRectangle({
   size: [width10, height10],
   roundRadius: radius,
   segments: 64
-}) : rectangle6({ size: [width10, height10] });
-function createRectangularTubeGeom(input) {
+}) : jscad16.primitives.rectangle({ size: [width10, height10] });
+function getRectangularTubeProfiles(input) {
   const p = rectangularTubeModelPropsSchema.parse(input);
-  return profile5(
-    subtract2(
-      roundedRect2(p.width, p.height, p.outerRadius),
-      roundedRect2(
+  const points = (geometry) => jscad16.geometries.geom2.toPoints(geometry);
+  return {
+    length: p.length,
+    outerPoints: points(roundedRectangle6(p.width, p.height, p.outerRadius)),
+    innerPoints: points(
+      roundedRectangle6(
         p.width - 2 * p.wallThickness,
         p.height - 2 * p.wallThickness,
         p.innerRadius
       )
-    ),
-    p.length
-  );
-}
-function createRectangularTubeMesh(input) {
-  const geom = generalize7(
-    { snap: true, triangulate: true },
-    createRectangularTubeGeom(input)
-  );
-  const epsilon = Math.max(...measurements7.measureDimensions(geom)) * 1e-10;
-  const positions = [];
-  const indices = [];
-  const lookup = /* @__PURE__ */ new Map();
-  const vertex = (v) => {
-    const key = v.map((x) => Math.round(x / epsilon)).join(",");
-    let index = lookup.get(key);
-    if (index === void 0) {
-      index = positions.length / 3;
-      positions.push(...v);
-      lookup.set(key, index);
-    }
-    return index;
+    )
   };
-  for (const poly of geometries7.geom3.toPolygons(geom)) {
-    for (let i = 1; i < poly.vertices.length - 1; i++) {
-      const a = poly.vertices[0], b = poly.vertices[i], c = poly.vertices[i + 1];
-      const u = b.map((x, j) => x - a[j]), v = c.map((x, j) => x - a[j]);
-      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 > epsilon * epsilon)
-        indices.push(vertex(a), vertex(b), vertex(c));
-    }
-  }
-  return { positions, indices };
 }
 
 // lib/models/rectangulartube/RectangularTube.tsx
-import { jsx as jsx85 } from "react/jsx-runtime";
+import { jsx as jsx85, jsxs as jsxs19 } from "react/jsx-runtime";
 function RectangularTube({
   color = "#929da9",
   ...props
 }) {
-  return /* @__PURE__ */ jsx85(Colorize42, { color, children: /* @__PURE__ */ jsx85(Custom34, { geometry: createRectangularTubeGeom(props) }) });
+  const { length: length32, outerPoints, innerPoints } = getRectangularTubeProfiles(props);
+  return /* @__PURE__ */ jsx85(Colorize42, { color, children: /* @__PURE__ */ jsxs19(Subtract5, { children: [
+    /* @__PURE__ */ jsx85(
+      ExtrudeLinear3,
+      {
+        height: length32,
+        topOutlineName: "outer_top",
+        bottomOutlineName: "outer_bottom",
+        children: /* @__PURE__ */ jsx85(Polygon3, { points: outerPoints })
+      }
+    ),
+    /* @__PURE__ */ jsx85(
+      ExtrudeLinear3,
+      {
+        height: length32,
+        topOutlineName: "inner_top",
+        bottomOutlineName: "inner_bottom",
+        children: /* @__PURE__ */ jsx85(Polygon3, { points: innerPoints })
+      }
+    )
+  ] }) });
 }
 
 // lib/models/rectangulartube/register.tsx
@@ -18750,7 +19228,7 @@ function register89(registry2) {
 }
 
 // lib/models/rigidcoupler/RigidCoupler.tsx
-import { Colorize as Colorize43, Custom as Custom35 } from "jscad-fiber";
+import { Colorize as Colorize43, Custom as Custom34 } from "jscad-fiber";
 
 // lib/models/rigidcoupler/mesh.ts
 import "@jscad/modeling";
@@ -18784,7 +19262,7 @@ function RigidCoupler({
   color = "#737e8f",
   ...props
 }) {
-  return /* @__PURE__ */ jsx87(Colorize43, { color, children: /* @__PURE__ */ jsx87(Custom35, { geometry: createRigidCouplerGeom(props) }) });
+  return /* @__PURE__ */ jsx87(Colorize43, { color, children: /* @__PURE__ */ jsx87(Custom34, { geometry: createRigidCouplerGeom(props) }) });
 }
 
 // lib/models/rigidcoupler/register.tsx
@@ -18800,7 +19278,7 @@ function register90(registry2) {
 }
 
 // lib/models/setscrew/SetScrew.tsx
-import { Colorize as Colorize44, Custom as Custom36 } from "jscad-fiber";
+import { Colorize as Colorize44, Custom as Custom35 } from "jscad-fiber";
 
 // lib/models/setscrew/mesh.ts
 function createSetScrewMesh(input, options = {}) {
@@ -18911,7 +19389,7 @@ function createSetScrewGeom(input, options) {
   return indexedMeshToGeom3(createSetScrewMesh(input, options));
 }
 function SetScrew({ color = "#737e8f", ...props }) {
-  return /* @__PURE__ */ jsx89(Colorize44, { color, children: /* @__PURE__ */ jsx89(Custom36, { geometry: createSetScrewGeom(props) }) });
+  return /* @__PURE__ */ jsx89(Colorize44, { color, children: /* @__PURE__ */ jsx89(Custom35, { geometry: createSetScrewGeom(props) }) });
 }
 
 // lib/models/setscrew/register.tsx
@@ -18927,7 +19405,7 @@ function register91(registry2) {
 }
 
 // lib/models/shaftcollar/ShaftCollar.tsx
-import { Colorize as Colorize45, Custom as Custom37 } from "jscad-fiber";
+import { Colorize as Colorize45, Custom as Custom36 } from "jscad-fiber";
 
 // lib/models/shaftcollar/mesh.ts
 import "@jscad/modeling";
@@ -18956,7 +19434,7 @@ function createShaftCollarGeom(input) {
   return indexedMeshToGeom3(createShaftCollarMesh(input));
 }
 function ShaftCollar({ color = "#737e8f", ...props }) {
-  return /* @__PURE__ */ jsx91(Colorize45, { color, children: /* @__PURE__ */ jsx91(Custom37, { geometry: createShaftCollarGeom(props) }) });
+  return /* @__PURE__ */ jsx91(Colorize45, { color, children: /* @__PURE__ */ jsx91(Custom36, { geometry: createShaftCollarGeom(props) }) });
 }
 
 // lib/models/shaftcollar/register.tsx
@@ -18972,7 +19450,7 @@ function register92(registry2) {
 }
 
 // lib/SheetMetal.tsx
-import { Colorize as Colorize46, Custom as Custom38 } from "jscad-fiber";
+import { Colorize as Colorize46, Custom as Custom37 } from "jscad-fiber";
 
 // lib/mechanical/sheet-metal-mesh.ts
 import earcut5 from "earcut";
@@ -18998,7 +19476,7 @@ function holeOutline(hole) {
 function createSheetMetalMesh(input) {
   const props = sheetMetalModelPropsSchema.parse(input);
   const { width: width10, baseLength, flangeHeight, thickness } = props;
-  const profile6 = props.channel ? "channel" : props.angle ? "angle" : "plate";
+  const profile5 = props.channel ? "channel" : props.angle ? "angle" : "plate";
   const radius = props.insideBendRadius + thickness / 2;
   const positions = [];
   const indices = [];
@@ -19011,10 +19489,10 @@ function createSheetMetalMesh(input) {
     addTriangle([vertices[0], vertices[1], vertices[2]], reverse);
     addTriangle([vertices[0], vertices[2], vertices[3]], reverse);
   };
-  const panels = profile6 === "plate" ? ["base"] : profile6 === "angle" ? ["base", "right"] : ["base", "left", "right"];
+  const panels = profile5 === "plate" ? ["base"] : profile5 === "angle" ? ["base", "right"] : ["base", "left", "right"];
   for (const hole of props.holes) {
     if (!panels.includes(hole.panel))
-      throw new Error(`No ${hole.panel} panel on ${profile6}`);
+      throw new Error(`No ${hole.panel} panel on ${profile5}`);
   }
   for (const panel of panels) {
     const length32 = panel === "base" ? baseLength : flangeHeight;
@@ -19065,7 +19543,7 @@ function createSheetMetalMesh(input) {
     for (const [loopIndex, loop] of loops.entries())
       for (let i = 0; i < loop.length; i++) {
         const a = loop[i], b = loop[(i + 1) % loop.length];
-        if (loopIndex === 0 && a.u === b.u && (panel === "base" && (a.u > 0 && profile6 !== "plate" || a.u < 0 && profile6 === "channel") || panel !== "base" && a.u < 0))
+        if (loopIndex === 0 && a.u === b.u && (panel === "base" && (a.u > 0 && profile5 !== "plate" || a.u < 0 && profile5 === "channel") || panel !== "base" && a.u < 0))
           continue;
         addQuad(
           [
@@ -19078,7 +19556,7 @@ function createSheetMetalMesh(input) {
         );
       }
   }
-  const sides = profile6 === "plate" ? [] : profile6 === "angle" ? [1] : [-1, 1];
+  const sides = profile5 === "plate" ? [] : profile5 === "angle" ? [1] : [-1, 1];
   for (const side of sides) {
     const project = (angle, crossSection) => {
       const r = radius - crossSection.offset;
@@ -19123,7 +19601,7 @@ function createSheetMetalGeom(input) {
   return indexedMeshToGeom3(createSheetMetalMesh(input));
 }
 function SheetMetal({ color = "#737e8f", ...props }) {
-  return /* @__PURE__ */ jsx93(Colorize46, { color, material: componentMaterials.brushedMetal, children: /* @__PURE__ */ jsx93(Custom38, { geometry: createSheetMetalGeom(props) }) });
+  return /* @__PURE__ */ jsx93(Colorize46, { color, material: componentMaterials.brushedMetal, children: /* @__PURE__ */ jsx93(Custom37, { geometry: createSheetMetalGeom(props) }) });
 }
 
 // lib/models/sheetmetal/register.tsx
@@ -19139,7 +19617,7 @@ function register93(registry2) {
 }
 
 // lib/models/slottedchannel/SlottedChannel.tsx
-import { Colorize as Colorize47, Custom as Custom39 } from "jscad-fiber";
+import { Colorize as Colorize47, Custom as Custom38 } from "jscad-fiber";
 
 // lib/models/slottedchannel/mesh.ts
 function quarterBend2(radius, thickness) {
@@ -19267,7 +19745,7 @@ function SlottedChannel({
   color = "#8995a3",
   ...props
 }) {
-  return /* @__PURE__ */ jsx95(Colorize47, { color, children: /* @__PURE__ */ jsx95(Custom39, { geometry: createSlottedChannelGeom(props) }) });
+  return /* @__PURE__ */ jsx95(Colorize47, { color, children: /* @__PURE__ */ jsx95(Custom38, { geometry: createSlottedChannelGeom(props) }) });
 }
 
 // lib/models/slottedchannel/register.tsx
@@ -19283,7 +19761,7 @@ function register94(registry2) {
 }
 
 // lib/models/spacer/Spacer.tsx
-import { Colorize as Colorize48, Custom as Custom40 } from "jscad-fiber";
+import { Colorize as Colorize48, Custom as Custom39 } from "jscad-fiber";
 
 // lib/models/spacer/mesh.ts
 function createSpacerMesh(input) {
@@ -19302,7 +19780,7 @@ function createSpacerGeom(input) {
   return indexedMeshToGeom3(createSpacerMesh(input));
 }
 function Spacer({ color = "#a18450", ...props }) {
-  return /* @__PURE__ */ jsx97(Colorize48, { color, children: /* @__PURE__ */ jsx97(Custom40, { geometry: createSpacerGeom(props) }) });
+  return /* @__PURE__ */ jsx97(Colorize48, { color, children: /* @__PURE__ */ jsx97(Custom39, { geometry: createSpacerGeom(props) }) });
 }
 
 // lib/models/spacer/register.tsx
@@ -19318,7 +19796,7 @@ function register95(registry2) {
 }
 
 // lib/models/splitgrommet/SplitGrommet.tsx
-import { Colorize as Colorize49, Custom as Custom41 } from "jscad-fiber";
+import { Colorize as Colorize49, Custom as Custom40 } from "jscad-fiber";
 
 // lib/models/splitgrommet/geometry.ts
 import earcut6 from "earcut";
@@ -19396,7 +19874,7 @@ function SplitGrommet({
   color = "#394553",
   ...props
 }) {
-  return /* @__PURE__ */ jsx99(Colorize49, { color, children: /* @__PURE__ */ jsx99(Custom41, { geometry: createSplitGrommetGeom(props) }) });
+  return /* @__PURE__ */ jsx99(Colorize49, { color, children: /* @__PURE__ */ jsx99(Custom40, { geometry: createSplitGrommetGeom(props) }) });
 }
 
 // lib/models/splitgrommet/register.tsx
@@ -19412,7 +19890,7 @@ function register96(registry2) {
 }
 
 // lib/models/splitwasher/SplitWasher.tsx
-import { Colorize as Colorize50, Custom as Custom42 } from "jscad-fiber";
+import { Colorize as Colorize50, Custom as Custom41 } from "jscad-fiber";
 
 // lib/models/splitwasher/mesh.ts
 function createSplitWasherMesh(input, options = {}) {
@@ -19471,7 +19949,7 @@ function createSplitWasherGeom(input) {
   return indexedMeshToGeom3(createSplitWasherMesh(input));
 }
 function SplitWasher({ color = "#929ba6", ...props }) {
-  return /* @__PURE__ */ jsx101(Colorize50, { color, children: /* @__PURE__ */ jsx101(Custom42, { geometry: createSplitWasherGeom(props) }) });
+  return /* @__PURE__ */ jsx101(Colorize50, { color, children: /* @__PURE__ */ jsx101(Custom41, { geometry: createSplitWasherGeom(props) }) });
 }
 
 // lib/models/splitwasher/register.tsx
@@ -19487,13 +19965,13 @@ function register97(registry2) {
 }
 
 // lib/SpurGear.tsx
-import { Colorize as Colorize51, Custom as Custom43 } from "jscad-fiber";
+import { Colorize as Colorize51, Custom as Custom42 } from "jscad-fiber";
 import { jsx as jsx103 } from "react/jsx-runtime";
 function createSpurGearGeom(input) {
   return indexedMeshToGeom3(createSpurGearMesh(input));
 }
 function SpurGear({ color = "#737e8f", ...props }) {
-  return /* @__PURE__ */ jsx103(Colorize51, { color, children: /* @__PURE__ */ jsx103(Custom43, { geometry: createSpurGearGeom(props) }) });
+  return /* @__PURE__ */ jsx103(Colorize51, { color, children: /* @__PURE__ */ jsx103(Custom42, { geometry: createSpurGearGeom(props) }) });
 }
 
 // lib/models/spurgear/register.tsx
@@ -19509,7 +19987,7 @@ function register98(registry2) {
 }
 
 // lib/models/threadedrod/ThreadedRod.tsx
-import { Colorize as Colorize52, Custom as Custom44 } from "jscad-fiber";
+import { Colorize as Colorize52, Custom as Custom43 } from "jscad-fiber";
 
 // lib/models/threadedrod/mesh.ts
 function resolution6(options) {
@@ -19595,7 +20073,7 @@ function createThreadedRodGeom(input, resolution7) {
   return indexedMeshToGeom3(createThreadedRodMesh(input, resolution7));
 }
 function ThreadedRod({ color = "#737e8f", ...props }) {
-  return /* @__PURE__ */ jsx105(Colorize52, { color, children: /* @__PURE__ */ jsx105(Custom44, { geometry: createThreadedRodGeom(props) }) });
+  return /* @__PURE__ */ jsx105(Colorize52, { color, children: /* @__PURE__ */ jsx105(Custom43, { geometry: createThreadedRodGeom(props) }) });
 }
 
 // lib/models/threadedrod/register.tsx
@@ -19611,7 +20089,7 @@ function register99(registry2) {
 }
 
 // lib/models/torsionspring/TorsionSpring.tsx
-import { Colorize as Colorize53, Custom as Custom45 } from "jscad-fiber";
+import { Colorize as Colorize53, Custom as Custom44 } from "jscad-fiber";
 
 // lib/models/torsionspring/mesh.ts
 function createTorsionSpringMesh(input, options = {}) {
@@ -19696,7 +20174,7 @@ function TorsionSpring({
   color = "#929ba6",
   ...props
 }) {
-  return /* @__PURE__ */ jsx107(Colorize53, { color, children: /* @__PURE__ */ jsx107(Custom45, { geometry: createTorsionSpringGeom(props) }) });
+  return /* @__PURE__ */ jsx107(Colorize53, { color, children: /* @__PURE__ */ jsx107(Custom44, { geometry: createTorsionSpringGeom(props) }) });
 }
 
 // lib/models/torsionspring/register.tsx
@@ -19712,10 +20190,10 @@ function register100(registry2) {
 }
 
 // lib/models/tslotcoverstrip/TSlotCoverStrip.tsx
-import { Colorize as Colorize54, Custom as Custom46 } from "jscad-fiber";
+import { Colorize as Colorize54, Custom as Custom45 } from "jscad-fiber";
 
 // lib/models/tslotcoverstrip/geometry.ts
-import jscad16 from "@jscad/modeling";
+import jscad19 from "@jscad/modeling";
 var {
   primitives: primitives8,
   extrusions: extrusions8,
@@ -19723,8 +20201,8 @@ var {
   geometries: geometries8,
   modifiers: modifiers7,
   measurements: measurements8
-} = jscad16;
-var generalize8 = modifiers7.generalize;
+} = jscad19;
+var generalize7 = modifiers7.generalize;
 function createTSlotCoverStripGeom(input) {
   const p = tSlotCoverStripModelPropsSchema.parse(input);
   const w = p.width / 2;
@@ -19751,7 +20229,7 @@ function createTSlotCoverStripGeom(input) {
   return extrusions8.extrudeLinear({ height: p.length }, outline);
 }
 function createTSlotCoverStripMesh(input) {
-  const geom = generalize8(
+  const geom = generalize7(
     { snap: false, triangulate: true },
     createTSlotCoverStripGeom(input)
   );
@@ -19791,7 +20269,7 @@ function TSlotCoverStrip({
   color = "#465564",
   ...props
 }) {
-  return /* @__PURE__ */ jsx109(Colorize54, { color, children: /* @__PURE__ */ jsx109(Custom46, { geometry: createTSlotCoverStripGeom(props) }) });
+  return /* @__PURE__ */ jsx109(Colorize54, { color, children: /* @__PURE__ */ jsx109(Custom45, { geometry: createTSlotCoverStripGeom(props) }) });
 }
 
 // lib/models/tslotcoverstrip/register.tsx
@@ -19807,7 +20285,7 @@ function register101(registry2) {
 }
 
 // lib/models/tslotextrusion/TSlotExtrusion.tsx
-import { Colorize as Colorize55, Custom as Custom47 } from "jscad-fiber";
+import { Colorize as Colorize55, Custom as Custom46 } from "jscad-fiber";
 
 // lib/models/tslotextrusion/mesh.ts
 function createTSlotExtrusionMesh(input = {}) {
@@ -19862,7 +20340,7 @@ function TSlotExtrusion({
   color = "#8995a3",
   ...props
 }) {
-  return /* @__PURE__ */ jsx111(Colorize55, { color, children: /* @__PURE__ */ jsx111(Custom47, { geometry: createTSlotExtrusionGeom(props) }) });
+  return /* @__PURE__ */ jsx111(Colorize55, { color, children: /* @__PURE__ */ jsx111(Custom46, { geometry: createTSlotExtrusionGeom(props) }) });
 }
 
 // lib/models/tslotextrusion/register.tsx
@@ -19878,7 +20356,7 @@ function register102(registry2) {
 }
 
 // lib/models/tslotgusset/TSlotGusset.tsx
-import { Colorize as Colorize56, Custom as Custom48 } from "jscad-fiber";
+import { Colorize as Colorize56, Custom as Custom47 } from "jscad-fiber";
 
 // lib/models/tslotgusset/mesh.ts
 function createTSlotGussetMesh(input = {}) {
@@ -19920,7 +20398,7 @@ function createTSlotGussetGeom(input = {}) {
   return indexedMeshToGeom3(createTSlotGussetMesh(input));
 }
 function TSlotGusset({ color = "#8995a3", ...props }) {
-  return /* @__PURE__ */ jsx113(Colorize56, { color, children: /* @__PURE__ */ jsx113(Custom48, { geometry: createTSlotGussetGeom(props) }) });
+  return /* @__PURE__ */ jsx113(Colorize56, { color, children: /* @__PURE__ */ jsx113(Custom47, { geometry: createTSlotGussetGeom(props) }) });
 }
 
 // lib/models/tslotgusset/register.tsx
@@ -19936,7 +20414,7 @@ function register103(registry2) {
 }
 
 // lib/models/tslotinsidecorner/TSlotInsideCorner.tsx
-import { Colorize as Colorize57, Custom as Custom49 } from "jscad-fiber";
+import { Colorize as Colorize57, Custom as Custom48 } from "jscad-fiber";
 
 // lib/models/tslotinsidecorner/mesh.ts
 function createTSlotInsideCornerMesh(input = {}) {
@@ -20006,7 +20484,7 @@ function TSlotInsideCorner({
   color = "#8995a3",
   ...props
 }) {
-  return /* @__PURE__ */ jsx115(Colorize57, { color, children: /* @__PURE__ */ jsx115(Custom49, { geometry: createTSlotInsideCornerGeom(props) }) });
+  return /* @__PURE__ */ jsx115(Colorize57, { color, children: /* @__PURE__ */ jsx115(Custom48, { geometry: createTSlotInsideCornerGeom(props) }) });
 }
 
 // lib/models/tslotinsidecorner/register.tsx
@@ -20022,13 +20500,13 @@ function register104(registry2) {
 }
 
 // lib/models/ufl/Ufl.tsx
-import { Colorize as Colorize58, Custom as Custom50 } from "jscad-fiber";
+import { Colorize as Colorize58, Custom as Custom49 } from "jscad-fiber";
 
 // lib/models/ufl/geometry.ts
-import jscad17 from "@jscad/modeling";
+import jscad20 from "@jscad/modeling";
 function createUflGeometries(input = {}) {
   const d = getUflDimensions(input);
-  const { booleans: booleans5, primitives: primitives9 } = jscad17;
+  const { booleans: booleans5, primitives: primitives9 } = jscad20;
   const silver = "#bcbfc3";
   const dielectric = "#eee9d5";
   const gold = "#d9b45b";
@@ -20121,7 +20599,7 @@ function createUflGeometries(input = {}) {
 // lib/models/ufl/Ufl.tsx
 import { Fragment as Fragment19, jsx as jsx117 } from "react/jsx-runtime";
 function Ufl(props) {
-  return /* @__PURE__ */ jsx117(Fragment19, { children: createUflGeometries(props).map(({ geom, color }, index) => /* @__PURE__ */ jsx117(Colorize58, { color, children: /* @__PURE__ */ jsx117(Custom50, { geometry: geom }) }, index)) });
+  return /* @__PURE__ */ jsx117(Fragment19, { children: createUflGeometries(props).map(({ geom, color }, index) => /* @__PURE__ */ jsx117(Colorize58, { color, children: /* @__PURE__ */ jsx117(Custom49, { geometry: geom }) }, index)) });
 }
 
 // lib/models/ufl/register.tsx
@@ -20137,7 +20615,7 @@ function register105(registry2) {
 }
 
 // lib/WormGear.tsx
-import { Colorize as Colorize59, Custom as Custom51 } from "jscad-fiber";
+import { Colorize as Colorize59, Custom as Custom50 } from "jscad-fiber";
 
 // lib/mechanical/worm-gear-mesh.ts
 import earcut7 from "earcut";
@@ -20190,17 +20668,17 @@ var createWormGearMesh = (input) => {
         fractions.push(fraction);
     }
   }
-  const profile6 = [];
+  const profile5 = [];
   for (let start = 0; start < props.starts; start++) {
     for (const fraction of fractions) {
       const distance2 = Math.min(fraction, 1 - fraction) * axialPitch;
-      profile6.push({
+      profile5.push({
         angle: (start + fraction) * Math.PI * 2 / props.starts,
         radius: distance2 <= tipHalfWidth ? outsideRadius : distance2 >= rootHalfWidth ? rootRadius : pitchRadius + (toothThickness / 2 - distance2) / pressureTangent
       });
     }
   }
-  const count = profile6.length;
+  const count = profile5.length;
   const positions = [];
   const indices = [];
   const phase = props.phase % 360 * Math.PI / 180;
@@ -20208,7 +20686,7 @@ var createWormGearMesh = (input) => {
   const ring = (z) => {
     const first = positions.length / 3;
     const rotation = phase + direction * (z / lead) * Math.PI * 2;
-    for (const sample of profile6) {
+    for (const sample of profile5) {
       const angle = sample.angle + rotation;
       positions.push(
         sample.radius * Math.cos(angle),
@@ -20318,7 +20796,7 @@ function createWormGearGeom(input) {
   return indexedMeshToGeom3(createWormGearMesh(input));
 }
 function WormGear({ color = "#737e8f", ...props }) {
-  return /* @__PURE__ */ jsx119(Colorize59, { color, children: /* @__PURE__ */ jsx119(Custom51, { geometry: createWormGearGeom(props) }) });
+  return /* @__PURE__ */ jsx119(Colorize59, { color, children: /* @__PURE__ */ jsx119(Custom50, { geometry: createWormGearGeom(props) }) });
 }
 
 // lib/models/wormgear/register.tsx
@@ -20334,7 +20812,7 @@ function register106(registry2) {
 }
 
 // lib/models/zeebar/ZeeBar.tsx
-import { Colorize as Colorize60, Custom as Custom52 } from "jscad-fiber";
+import { Colorize as Colorize60, Custom as Custom51 } from "jscad-fiber";
 
 // lib/models/zeebar/mesh.ts
 function filletedOutline2(points, radii) {
@@ -20401,7 +20879,7 @@ function createZeeBarGeom(input) {
   return indexedMeshToGeom3(createZeeBarMesh(input));
 }
 function ZeeBar({ color = "#8995a3", ...props }) {
-  return /* @__PURE__ */ jsx121(Colorize60, { color, children: /* @__PURE__ */ jsx121(Custom52, { geometry: createZeeBarGeom(props) }) });
+  return /* @__PURE__ */ jsx121(Colorize60, { color, children: /* @__PURE__ */ jsx121(Custom51, { geometry: createZeeBarGeom(props) }) });
 }
 
 // lib/models/zeebar/register.tsx
@@ -20478,7 +20956,7 @@ var modelRendererRegistry = new ModelRendererRegistry();
 registerAllModelRenderers(modelRendererRegistry);
 
 // lib/ExtrudedPads.tsx
-import { Fragment as Fragment20, jsx as jsx123, jsxs as jsxs19 } from "react/jsx-runtime";
+import { Fragment as Fragment20, jsx as jsx123, jsxs as jsxs20 } from "react/jsx-runtime";
 var ExtrudedPads = ({
   circuitJson,
   footprint
@@ -20494,7 +20972,7 @@ var ExtrudedPads = ({
   }
   if (!circuitJson)
     throw new Error("No circuit json or footprint provided to ExtrudedPads");
-  return /* @__PURE__ */ jsxs19(Fragment20, { children: [
+  return /* @__PURE__ */ jsxs20(Fragment20, { children: [
     circuitJson.filter((s) => s.type === "pcb_smtpad").map((pad, i) => {
       const isPin1 = pad.port_hints?.includes("1");
       return (
@@ -20518,11 +20996,11 @@ import {
   Cuboid as Cuboid17,
   Cylinder as Cylinder6,
   Hull as Hull5,
-  Subtract as Subtract5,
+  Subtract as Subtract6,
   Translate as Translate9,
   Union as Union3
 } from "jscad-fiber";
-import { Fragment as Fragment21, jsx as jsx124, jsxs as jsxs20 } from "react/jsx-runtime";
+import { Fragment as Fragment21, jsx as jsx124, jsxs as jsxs21 } from "react/jsx-runtime";
 function createDualRowGullWing(p) {
   const {
     pinCount,
@@ -20570,7 +21048,7 @@ function createDualRowGullWing(p) {
     throw new Error("Exposed pad must fit inside the bottom mold face");
   const midZ = standoff + moldHeight / 2;
   const slice = Math.min(2e-3, moldHeight / 100);
-  const body = /* @__PURE__ */ jsxs20(Hull5, { children: [
+  const body = /* @__PURE__ */ jsxs21(Hull5, { children: [
     /* @__PURE__ */ jsx124(Translate9, { z: standoff + slice / 2, children: /* @__PURE__ */ jsx124(
       Cuboid17,
       {
@@ -20613,13 +21091,13 @@ function createDualRowGullWing(p) {
     }
     points.push([root, midZ]);
     const section = ([x, z]) => /* @__PURE__ */ jsx124(Translate9, { offset: { x: side * x, y, z }, children: /* @__PURE__ */ jsx124(Cuboid17, { size: [slice, leadWidth, leadThickness] }) });
-    return /* @__PURE__ */ jsx124(Union3, { children: points.slice(1).map((point, i) => /* @__PURE__ */ jsxs20(Hull5, { children: [
+    return /* @__PURE__ */ jsx124(Union3, { children: points.slice(1).map((point, i) => /* @__PURE__ */ jsxs21(Hull5, { children: [
       section(points[i]),
       section(point)
     ] }, i)) });
   };
-  return /* @__PURE__ */ jsxs20(Fragment21, { children: [
-    /* @__PURE__ */ jsx124(Colorize61, { color: "#353535", children: /* @__PURE__ */ jsxs20(Subtract5, { children: [
+  return /* @__PURE__ */ jsxs21(Fragment21, { children: [
+    /* @__PURE__ */ jsx124(Colorize61, { color: "#353535", children: /* @__PURE__ */ jsxs21(Subtract6, { children: [
       body,
       /* @__PURE__ */ jsx124(
         Translate9,
@@ -20727,7 +21205,7 @@ import { fp as fp10 } from "@tscircuit/footprinter";
 import { Rotate as Rotate24, Translate as Translate46 } from "jscad-fiber";
 
 // lib/DualInlinePackage.tsx
-import { Polygon as Polygon3, ExtrudeLinear as ExtrudeLinear3, Rotate as Rotate5, Translate as Translate10 } from "jscad-fiber";
+import { Polygon as Polygon4, ExtrudeLinear as ExtrudeLinear4, Rotate as Rotate5, Translate as Translate10 } from "jscad-fiber";
 
 // lib/utils/range.ts
 var range = (end) => Array.from({ length: end }, (_, i) => i);
@@ -20792,7 +21270,7 @@ function getExpandedStroke(strokeInput, width10) {
 }
 
 // lib/DualInlinePackage.tsx
-import { Fragment as Fragment22, jsx as jsx126, jsxs as jsxs21 } from "react/jsx-runtime";
+import { Fragment as Fragment22, jsx as jsx126, jsxs as jsxs22 } from "react/jsx-runtime";
 var normalizeOnY = (points) => {
   const minX = Math.min(...points.map((p) => p.x));
   const maxX = Math.max(...points.map((p) => p.x));
@@ -20821,14 +21299,14 @@ var DIP_PIN_HEIGHT = 5.47;
 var heightAboveSurface = 0.5;
 var DipPinLeg = ({ x, y, z }) => {
   const isRotated = x > 0;
-  return /* @__PURE__ */ jsxs21(Fragment22, { children: [
+  return /* @__PURE__ */ jsxs22(Fragment22, { children: [
     /* @__PURE__ */ jsx126(
       Translate10,
       {
         material: componentMaterials.tinnedLead,
         offset: { x: x + 0.25 / 2, y, z },
-        children: /* @__PURE__ */ jsx126(Rotate5, { rotation: ["-90deg", 0, "90deg"], children: /* @__PURE__ */ jsx126(ExtrudeLinear3, { height: 0.25, children: /* @__PURE__ */ jsx126(
-          Polygon3,
+        children: /* @__PURE__ */ jsx126(Rotate5, { rotation: ["-90deg", 0, "90deg"], children: /* @__PURE__ */ jsx126(ExtrudeLinear4, { height: 0.25, children: /* @__PURE__ */ jsx126(
+          Polygon4,
           {
             points: svgPathPoints.slice().reverse().map((p) => [p.x, p.y])
           }
@@ -20843,8 +21321,8 @@ var DipPinLeg = ({ x, y, z }) => {
           y: y + (isRotated ? 1 : -1),
           z
         },
-        children: /* @__PURE__ */ jsx126(Rotate5, { rotation: ["-90deg", "90deg", isRotated ? "180deg" : "0deg"], children: /* @__PURE__ */ jsx126(ExtrudeLinear3, { height: 2, children: /* @__PURE__ */ jsx126(
-          Polygon3,
+        children: /* @__PURE__ */ jsx126(Rotate5, { rotation: ["-90deg", "90deg", isRotated ? "180deg" : "0deg"], children: /* @__PURE__ */ jsx126(ExtrudeLinear4, { height: 2, children: /* @__PURE__ */ jsx126(
+          Polygon4,
           {
             points: getExpandedStroke(
               [
@@ -20869,7 +21347,7 @@ var Dip = ({
   const numPinsOnEachSide = Math.floor(numPins / 2);
   const pinRowSpacing = rowSpacing ?? (bodyWidth >= 7 ? bodyWidth : bodyWidth + 1.22);
   const chipBodyWidth = bodyWidth >= 7 ? pinRowSpacing - 1.22 : bodyWidth;
-  return /* @__PURE__ */ jsxs21(Fragment22, { children: [
+  return /* @__PURE__ */ jsxs22(Fragment22, { children: [
     range(numPins).map((i) => {
       const yRow = i % numPinsOnEachSide;
       const xRow = (Math.floor(i / numPinsOnEachSide) - 0.5) * 2;
@@ -20898,8 +21376,8 @@ var Dip = ({
 
 // lib/SmdChipLead.tsx
 import {
-  Polygon as Polygon4,
-  ExtrudeLinear as ExtrudeLinear4,
+  Polygon as Polygon5,
+  ExtrudeLinear as ExtrudeLinear5,
   Translate as Translate11,
   Rotate as Rotate6,
   Colorize as Colorize62
@@ -20930,11 +21408,11 @@ var SmdChipLead = (props) => {
   const N = 15;
   const points = Array.from({ length: N }).map((_, i) => i / (N - 1) * bodyDistance).map((x) => [x, calculateSCurve(x, props)]);
   const polygon4 = getExpandedStroke(points, thickness);
-  return /* @__PURE__ */ jsx127(Colorize62, { color: "#c4c7ca", material: componentMaterials.tinnedLead, children: /* @__PURE__ */ jsx127(Translate11, { offset: { z: 0, y: 0, x: 0, ...props.position }, children: /* @__PURE__ */ jsx127(Rotate6, { rotation: ["90deg", 0, rotation ?? 0], children: /* @__PURE__ */ jsx127(Translate11, { offset: { x: 0, y: 0, z: -width10 / 2 }, children: /* @__PURE__ */ jsx127(ExtrudeLinear4, { height: width10, children: /* @__PURE__ */ jsx127(Polygon4, { points: polygon4.map((p) => [p.x, p.y]) }) }) }) }) }) });
+  return /* @__PURE__ */ jsx127(Colorize62, { color: "#c4c7ca", material: componentMaterials.tinnedLead, children: /* @__PURE__ */ jsx127(Translate11, { offset: { z: 0, y: 0, x: 0, ...props.position }, children: /* @__PURE__ */ jsx127(Rotate6, { rotation: ["90deg", 0, rotation ?? 0], children: /* @__PURE__ */ jsx127(Translate11, { offset: { x: 0, y: 0, z: -width10 / 2 }, children: /* @__PURE__ */ jsx127(ExtrudeLinear5, { height: width10, children: /* @__PURE__ */ jsx127(Polygon5, { points: polygon4.map((p) => [p.x, p.y]) }) }) }) }) }) });
 };
 
 // lib/Tssop.tsx
-import { Fragment as Fragment23, jsx as jsx128, jsxs as jsxs22 } from "react/jsx-runtime";
+import { Fragment as Fragment23, jsx as jsx128, jsxs as jsxs23 } from "react/jsx-runtime";
 var LegacyTssop = ({
   pinCount,
   leadLength,
@@ -20960,7 +21438,7 @@ var LegacyTssop = ({
     Math.min(bodyVisualWidth, bodyLength10) * 0.12,
     0.45
   );
-  return /* @__PURE__ */ jsxs22(Fragment23, { children: [
+  return /* @__PURE__ */ jsxs23(Fragment23, { children: [
     Array.from({ length: sidePinCount }).map((_, i) => /* @__PURE__ */ jsx128(
       SmdChipLead,
       {
@@ -21016,7 +21494,7 @@ var LegacyTssop = ({
 var Tssop = (props) => "leadSpan" in props ? createDualRowGullWing(props) : LegacyTssop(props);
 
 // lib/MSOP.tsx
-import { Fragment as Fragment24, jsx as jsx129, jsxs as jsxs23 } from "react/jsx-runtime";
+import { Fragment as Fragment24, jsx as jsx129, jsxs as jsxs24 } from "react/jsx-runtime";
 var LegacyMSOP = ({
   pinCount,
   padContactLength = 0.4,
@@ -21027,7 +21505,7 @@ var LegacyMSOP = ({
   const sidePinCount = Math.ceil(pinCount / 2);
   const pinOffsetToCenter = (sidePinCount - 1) * pitch / 2;
   const leadThickness = 0.2;
-  return /* @__PURE__ */ jsxs23(Fragment24, { children: [
+  return /* @__PURE__ */ jsxs24(Fragment24, { children: [
     Array.from({ length: sidePinCount }).map((_, i) => /* @__PURE__ */ jsx129(
       SmdChipLead,
       {
@@ -21079,7 +21557,7 @@ var MSOP = (props) => "leadSpan" in props ? createDualRowGullWing(props) : Legac
 
 // lib/SmdLED.tsx
 import { Colorize as Colorize63, Cuboid as Cuboid18, RoundedCuboid as RoundedCuboid2, Translate as Translate12 } from "jscad-fiber";
-import { Fragment as Fragment25, jsx as jsx130, jsxs as jsxs24 } from "react/jsx-runtime";
+import { Fragment as Fragment25, jsx as jsx130, jsxs as jsxs25 } from "react/jsx-runtime";
 var smdLedDimensions = {
   "0402": { length: 1, width: 0.5, height: 0.5, terminalLength: 0.2 },
   "0603": { length: 1.62, width: 0.8, height: 0.615, terminalLength: 0.21 },
@@ -21091,7 +21569,7 @@ function SmdLED({
 }) {
   const p = smdLedDimensions[footprint];
   if (footprint === "0603")
-    return /* @__PURE__ */ jsxs24(Fragment25, { children: [
+    return /* @__PURE__ */ jsxs25(Fragment25, { children: [
       /* @__PURE__ */ jsx130(Colorize63, { color: "#f0eee7", children: /* @__PURE__ */ jsx130(
         RoundedCuboid2,
         {
@@ -21112,7 +21590,7 @@ function SmdLED({
     ] });
   const terminalThickness = Math.min(0.1, p.height / 4);
   const apertureHeight = 0.02;
-  return /* @__PURE__ */ jsxs24(Fragment25, { children: [
+  return /* @__PURE__ */ jsxs25(Fragment25, { children: [
     /* @__PURE__ */ jsx130(Colorize63, { color: "#f0eee7", children: /* @__PURE__ */ jsx130(Translate12, { z: (p.height + terminalThickness - apertureHeight) / 2, children: /* @__PURE__ */ jsx130(
       Cuboid18,
       {
@@ -21140,7 +21618,7 @@ function SmdLED({
 }
 
 // lib/qfp.tsx
-import { Fragment as Fragment26, jsx as jsx131, jsxs as jsxs25 } from "react/jsx-runtime";
+import { Fragment as Fragment26, jsx as jsx131, jsxs as jsxs26 } from "react/jsx-runtime";
 var QFP = ({
   pinCount,
   pitch,
@@ -21164,7 +21642,7 @@ var QFP = ({
   const bodyDistance = leadReach;
   const fullPadContactLength = leadReach * 0.5;
   const curveLength = leadReach * 0.18;
-  return /* @__PURE__ */ jsxs25(Fragment26, { children: [
+  return /* @__PURE__ */ jsxs26(Fragment26, { children: [
     Array.from({ length: sidePinCount }).map((_, i) => /* @__PURE__ */ jsx131(
       SmdChipLead,
       {
@@ -21299,7 +21777,7 @@ var getLeadWidth = (pinCount, width10) => {
 
 // lib/PinHeader.tsx
 import { Colorize as Colorize64, Cuboid as Cuboid19, Hull as Hull6, Rotate as Rotate7, Translate as Translate13 } from "jscad-fiber";
-import { Fragment as Fragment27, jsx as jsx132, jsxs as jsxs26 } from "react/jsx-runtime";
+import { Fragment as Fragment27, jsx as jsx132, jsxs as jsxs27 } from "react/jsx-runtime";
 var PIN_METAL_COLOR = "#c0c0c0";
 var PinHeader = ({
   x,
@@ -21314,7 +21792,7 @@ var PinHeader = ({
   smd,
   rightangle
 }) => {
-  return /* @__PURE__ */ jsxs26(Fragment27, { children: [
+  return /* @__PURE__ */ jsxs27(Fragment27, { children: [
     /* @__PURE__ */ jsx132(Translate13, { y: rightangle ? -3 : 0, children: /* @__PURE__ */ jsx132(
       Cuboid19,
       {
@@ -21344,7 +21822,7 @@ var PinHeader = ({
             padContactLength: 2,
             bodyDistance: 3
           }
-        ) : /* @__PURE__ */ jsxs26(Hull6, { children: [
+        ) : /* @__PURE__ */ jsxs27(Hull6, { children: [
           /* @__PURE__ */ jsx132(
             Cuboid19,
             {
@@ -21373,7 +21851,7 @@ var PinHeader = ({
       {
         color: PIN_METAL_COLOR,
         material: componentMaterials.goldContact,
-        children: /* @__PURE__ */ jsx132(Translate13, { y: rightangle ? -3.9 : 0, z: rightangle ? 1 : 0, children: /* @__PURE__ */ jsx132(Rotate7, { rotation: rightangle ? [-Math.PI / 2, 0, 0] : [0, 0, 0], children: /* @__PURE__ */ jsxs26(Hull6, { children: [
+        children: /* @__PURE__ */ jsx132(Translate13, { y: rightangle ? -3.9 : 0, z: rightangle ? 1 : 0, children: /* @__PURE__ */ jsx132(Rotate7, { rotation: rightangle ? [-Math.PI / 2, 0, 0] : [0, 0, 0], children: /* @__PURE__ */ jsxs27(Hull6, { children: [
           /* @__PURE__ */ jsx132(
             Cuboid19,
             {
@@ -21444,8 +21922,8 @@ var PinRow = ({
 };
 
 // lib/utils/PhysicalQfn.tsx
-import { Colorize as Colorize65, Cuboid as Cuboid20, Cylinder as Cylinder7, Subtract as Subtract6, Translate as Translate14 } from "jscad-fiber";
-import { Fragment as Fragment29, jsx as jsx134, jsxs as jsxs27 } from "react/jsx-runtime";
+import { Colorize as Colorize65, Cuboid as Cuboid20, Cylinder as Cylinder7, Subtract as Subtract7, Translate as Translate14 } from "jscad-fiber";
+import { Fragment as Fragment29, jsx as jsx134, jsxs as jsxs28 } from "react/jsx-runtime";
 function createPhysicalQfn(p) {
   const {
     num_pins,
@@ -21490,8 +21968,8 @@ function createPhysicalQfn(p) {
     );
   const body = /* @__PURE__ */ jsx134(Translate14, { z: (bodyHeight + standoff) / 2, children: /* @__PURE__ */ jsx134(Cuboid20, { size: [bodyWidth, bodyLength10, bodyHeight - standoff] }) });
   const radius = Math.min(bodyWidth, bodyLength10) * 0.035;
-  return /* @__PURE__ */ jsxs27(Fragment29, { children: [
-    /* @__PURE__ */ jsx134(Colorize65, { color: "#353535", children: /* @__PURE__ */ jsxs27(Subtract6, { children: [
+  return /* @__PURE__ */ jsxs28(Fragment29, { children: [
+    /* @__PURE__ */ jsx134(Colorize65, { color: "#353535", children: /* @__PURE__ */ jsxs28(Subtract7, { children: [
       body,
       /* @__PURE__ */ jsx134(
         Translate14,
@@ -21635,7 +22113,7 @@ var getQuadPinMap = ({
 };
 
 // lib/qfn.tsx
-import { Fragment as Fragment30, jsx as jsx135, jsxs as jsxs28 } from "react/jsx-runtime";
+import { Fragment as Fragment30, jsx as jsx135, jsxs as jsxs29 } from "react/jsx-runtime";
 var LegacyQFN = ({
   num_pins = 16,
   bodyWidth = 9,
@@ -21677,7 +22155,7 @@ var LegacyQFN = ({
     const pn = pin_map[i + 1];
     pinPositions.push({ pn, x, y, pw, pl });
   }
-  return /* @__PURE__ */ jsxs28(Fragment30, { children: [
+  return /* @__PURE__ */ jsxs29(Fragment30, { children: [
     /* @__PURE__ */ jsx135(Colorize66, { material: componentMaterials.tinnedLead, color: "grey", children: /* @__PURE__ */ jsx135(
       Cuboid21,
       {
@@ -21710,7 +22188,7 @@ var QFN = (props) => "bodyHeight" in props ? createPhysicalQfn(props) : LegacyQF
 var qfn_default = QFN;
 
 // lib/SOT-235.tsx
-import { Fragment as Fragment31, jsx as jsx136, jsxs as jsxs29 } from "react/jsx-runtime";
+import { Fragment as Fragment31, jsx as jsx136, jsxs as jsxs30 } from "react/jsx-runtime";
 var SOT235 = () => {
   const fullWidth = 2.8;
   const bodyWidth = 1.6;
@@ -21722,7 +22200,7 @@ var SOT235 = () => {
   const padContactLength = 0.5;
   const padPitch = 0.95;
   const extendedBodyDistance = fullWidth - bodyWidth;
-  return /* @__PURE__ */ jsxs29(Fragment31, { children: [
+  return /* @__PURE__ */ jsxs30(Fragment31, { children: [
     /* @__PURE__ */ jsx136(
       SmdChipLead,
       {
@@ -21819,7 +22297,7 @@ var SOT235 = () => {
 var SOT_235_default = SOT235;
 
 // lib/SOT-23-3P.tsx
-import { Fragment as Fragment32, jsx as jsx137, jsxs as jsxs30 } from "react/jsx-runtime";
+import { Fragment as Fragment32, jsx as jsx137, jsxs as jsxs31 } from "react/jsx-runtime";
 var SOT233P = ({
   fullWidth = 2.9,
   fullLength: fullLength10 = 2.8,
@@ -21834,7 +22312,7 @@ var SOT233P = ({
   const padContactLength = 0.4;
   const padThickness = leadThickness / 2;
   const extendedBodyDistance = (fullWidth - bodyWidth) / 2 + 0.3;
-  return /* @__PURE__ */ jsxs30(Fragment32, { children: [
+  return /* @__PURE__ */ jsxs31(Fragment32, { children: [
     /* @__PURE__ */ jsx137(
       SmdChipLead,
       {
@@ -21898,7 +22376,7 @@ var SOT233P = ({
 };
 
 // lib/SOT-23W.tsx
-import { Fragment as Fragment33, jsx as jsx138, jsxs as jsxs31 } from "react/jsx-runtime";
+import { Fragment as Fragment33, jsx as jsx138, jsxs as jsxs32 } from "react/jsx-runtime";
 var SOT23W = ({ fullWidth = 2.9, fullLength: fullLength10 = 2.8 }) => {
   const bodyWidth = 1.92;
   const bodyLength10 = 2.9;
@@ -21909,7 +22387,7 @@ var SOT23W = ({ fullWidth = 2.9, fullLength: fullLength10 = 2.8 }) => {
   const padContactLength = 0.25;
   const padThickness = leadThickness / 2;
   const extendedBodyDistance = (fullWidth - bodyWidth) / 2 + 0.3;
-  return /* @__PURE__ */ jsxs31(Fragment33, { children: [
+  return /* @__PURE__ */ jsxs32(Fragment33, { children: [
     /* @__PURE__ */ jsx138(
       SmdChipLead,
       {
@@ -21974,8 +22452,8 @@ var SOT23W = ({ fullWidth = 2.9, fullLength: fullLength10 = 2.8 }) => {
 };
 
 // lib/FemaleHeader.tsx
-import { Colorize as Colorize67, Cuboid as Cuboid22, Hull as Hull7, Subtract as Subtract7 } from "jscad-fiber";
-import { Fragment as Fragment34, jsx as jsx139, jsxs as jsxs32 } from "react/jsx-runtime";
+import { Colorize as Colorize67, Cuboid as Cuboid22, Hull as Hull7, Subtract as Subtract8 } from "jscad-fiber";
+import { Fragment as Fragment34, jsx as jsx139, jsxs as jsxs33 } from "react/jsx-runtime";
 var FemaleHeader = ({
   x,
   y,
@@ -21997,8 +22475,8 @@ var FemaleHeader = ({
   const socketCenterZ = flipZ(z + socketDepth / 2);
   const socketEntryBaseZ = z + bodyHeight - socketEntryHeight;
   const gapWidth = pinThickness * 1.6;
-  return /* @__PURE__ */ jsxs32(Fragment34, { children: [
-    /* @__PURE__ */ jsx139(Colorize67, { color: "#1a1a1a", children: /* @__PURE__ */ jsxs32(Subtract7, { children: [
+  return /* @__PURE__ */ jsxs33(Fragment34, { children: [
+    /* @__PURE__ */ jsx139(Colorize67, { color: "#1a1a1a", children: /* @__PURE__ */ jsxs33(Subtract8, { children: [
       /* @__PURE__ */ jsx139(
         Cuboid22,
         {
@@ -22014,7 +22492,7 @@ var FemaleHeader = ({
           center: [x, y, socketCenterZ]
         }
       ),
-      /* @__PURE__ */ jsxs32(Hull7, { children: [
+      /* @__PURE__ */ jsxs33(Hull7, { children: [
         /* @__PURE__ */ jsx139(
           Cuboid22,
           {
@@ -22031,8 +22509,8 @@ var FemaleHeader = ({
         )
       ] })
     ] }) }),
-    /* @__PURE__ */ jsxs32(Colorize67, { color: "silver", children: [
-      /* @__PURE__ */ jsxs32(Hull7, { children: [
+    /* @__PURE__ */ jsxs33(Colorize67, { color: "silver", children: [
+      /* @__PURE__ */ jsxs33(Hull7, { children: [
         /* @__PURE__ */ jsx139(
           Cuboid22,
           {
@@ -22101,13 +22579,13 @@ var FemaleHeaderRow = ({
 import {
   Colorize as Colorize68,
   Cylinder as Cylinder8,
-  ExtrudeLinear as ExtrudeLinear5,
-  Polygon as Polygon5,
+  ExtrudeLinear as ExtrudeLinear6,
+  Polygon as Polygon6,
   Rotate as Rotate8,
   RoundedCuboid as RoundedCuboid3,
   Translate as Translate15
 } from "jscad-fiber";
-import { Fragment as Fragment36, jsx as jsx141, jsxs as jsxs33 } from "react/jsx-runtime";
+import { Fragment as Fragment36, jsx as jsx141, jsxs as jsxs34 } from "react/jsx-runtime";
 var PushButton = ({
   width: width10,
   length: length32,
@@ -22117,7 +22595,7 @@ var PushButton = ({
   const bodyLength10 = length32;
   const bodyHeight = width10 * 0.7;
   const legWidth = innerDiameter / 2.5;
-  return /* @__PURE__ */ jsxs33(Fragment36, { children: [
+  return /* @__PURE__ */ jsxs34(Fragment36, { children: [
     /* @__PURE__ */ jsx141(
       RoundedCuboid3,
       {
@@ -22277,13 +22755,13 @@ var PushButtonLeg = (props) => {
         y: position?.y || 0,
         z: position?.z || 0
       },
-      children: /* @__PURE__ */ jsx141(Rotate8, { rotation: [0, 55, rotation], children: /* @__PURE__ */ jsx141(ExtrudeLinear5, { height: width10, children: /* @__PURE__ */ jsx141(Polygon5, { points: polygon4.map((p) => [p.y, p.x]) }) }) })
+      children: /* @__PURE__ */ jsx141(Rotate8, { rotation: [0, 55, rotation], children: /* @__PURE__ */ jsx141(ExtrudeLinear6, { height: width10, children: /* @__PURE__ */ jsx141(Polygon6, { points: polygon4.map((p) => [p.y, p.x]) }) }) })
     }
   ) });
 };
 
 // lib/SOIC.tsx
-import { Fragment as Fragment37, jsx as jsx142, jsxs as jsxs34 } from "react/jsx-runtime";
+import { Fragment as Fragment37, jsx as jsx142, jsxs as jsxs35 } from "react/jsx-runtime";
 var LegacySOIC = ({
   pinCount,
   leadLength,
@@ -22299,7 +22777,7 @@ var LegacySOIC = ({
   const leadBodyOffset = leadLength * 0;
   const fullLength10 = pitch * (sidePinCount - 1) + leadWidth + 0.2;
   const bodyWidthAdjusted = bodyWidth * 0.55;
-  return /* @__PURE__ */ jsxs34(Fragment37, { children: [
+  return /* @__PURE__ */ jsxs35(Fragment37, { children: [
     Array.from({ length: sidePinCount }).map((_, i) => /* @__PURE__ */ jsx142(
       SmdChipLead,
       {
@@ -22347,7 +22825,7 @@ var LegacySOIC = ({
 var SOIC = (props) => "leadSpan" in props ? createDualRowGullWing(props) : LegacySOIC(props);
 
 // lib/VSSOP.tsx
-import { Fragment as Fragment38, jsx as jsx143, jsxs as jsxs35 } from "react/jsx-runtime";
+import { Fragment as Fragment38, jsx as jsx143, jsxs as jsxs36 } from "react/jsx-runtime";
 var VSSOP = ({
   pinCount,
   pitch,
@@ -22377,7 +22855,7 @@ var VSSOP = ({
   const componentFullWidth = 4.5;
   const leadBodyDistance = (componentFullWidth - _bodyWidth) / 2;
   const padContactLength = leadBodyDistance * 0.5;
-  return /* @__PURE__ */ jsxs35(Fragment38, { children: [
+  return /* @__PURE__ */ jsxs36(Fragment38, { children: [
     Array.from({ length: sidePinCount }).map((_, i) => /* @__PURE__ */ jsx143(
       SmdChipLead,
       {
@@ -22425,7 +22903,7 @@ var VSSOP = ({
 
 // lib/SOD523.tsx
 import { Colorize as Colorize69, Cuboid as Cuboid24, Hull as Hull8, Translate as Translate16, Union as Union5 } from "jscad-fiber";
-import { Fragment as Fragment39, jsx as jsx144, jsxs as jsxs36 } from "react/jsx-runtime";
+import { Fragment as Fragment39, jsx as jsx144, jsxs as jsxs37 } from "react/jsx-runtime";
 var SOD523 = () => {
   const fullWidth = 2.15;
   const bodyLength10 = 0.8;
@@ -22438,7 +22916,7 @@ var SOD523 = () => {
   const rightPadCenterX = bodyWidth / 2 - padLength / 2 + 0.15;
   const taperOffset = 0.2;
   const straightHeight = bodyHeight * 0.5;
-  return /* @__PURE__ */ jsxs36(Fragment39, { children: [
+  return /* @__PURE__ */ jsxs37(Fragment39, { children: [
     /* @__PURE__ */ jsx144(
       Cuboid24,
       {
@@ -22455,9 +22933,9 @@ var SOD523 = () => {
         center: [rightPadCenterX, 0, padThickness / 2]
       }
     ),
-    /* @__PURE__ */ jsx144(Colorize69, { color: "#222", children: /* @__PURE__ */ jsxs36(Union5, { children: [
+    /* @__PURE__ */ jsx144(Colorize69, { color: "#222", children: /* @__PURE__ */ jsxs37(Union5, { children: [
       /* @__PURE__ */ jsx144(Translate16, { z: straightHeight / 2, children: /* @__PURE__ */ jsx144(Cuboid24, { size: [bodyWidth, bodyLength10, straightHeight] }) }),
-      /* @__PURE__ */ jsxs36(Hull8, { children: [
+      /* @__PURE__ */ jsxs37(Hull8, { children: [
         /* @__PURE__ */ jsx144(Translate16, { z: straightHeight, children: /* @__PURE__ */ jsx144(Cuboid24, { size: [bodyWidth, bodyLength10, 0.01] }) }),
         /* @__PURE__ */ jsx144(Translate16, { z: bodyHeight, children: /* @__PURE__ */ jsx144(
           Cuboid24,
@@ -22472,7 +22950,7 @@ var SOD523 = () => {
 
 // lib/SOD882.tsx
 import { Colorize as Colorize70, Cuboid as Cuboid25, Translate as Translate17 } from "jscad-fiber";
-import { Fragment as Fragment40, jsx as jsx145, jsxs as jsxs37 } from "react/jsx-runtime";
+import { Fragment as Fragment40, jsx as jsx145, jsxs as jsxs38 } from "react/jsx-runtime";
 var SOD882 = () => {
   const bodyLength10 = 0.98;
   const bodyHeight = 0.47;
@@ -22483,7 +22961,7 @@ var SOD882 = () => {
   const bodyWidth = 0.58;
   const leftPadCenterX = -pitch / 2;
   const rightPadCenterX = pitch / 2;
-  return /* @__PURE__ */ jsxs37(Fragment40, { children: [
+  return /* @__PURE__ */ jsxs38(Fragment40, { children: [
     /* @__PURE__ */ jsx145(
       Cuboid25,
       {
@@ -22538,7 +23016,7 @@ var SOD882 = () => {
 
 // lib/SMA.tsx
 import { Cuboid as Cuboid26, Colorize as Colorize71, Union as Union7, Hull as Hull10, Translate as Translate18 } from "jscad-fiber";
-import { Fragment as Fragment41, jsx as jsx146, jsxs as jsxs38 } from "react/jsx-runtime";
+import { Fragment as Fragment41, jsx as jsx146, jsxs as jsxs39 } from "react/jsx-runtime";
 var SMA = () => {
   const bodyWidth = 4.4;
   const bodyLength10 = 3.4;
@@ -22549,8 +23027,8 @@ var SMA = () => {
   const leadHeight = 1.14;
   const taperOffset = 0.4;
   const straightHeight = bodyHeight * 0.5;
-  const Body = /* @__PURE__ */ jsx146(Colorize71, { color: "#1a1a1a", children: /* @__PURE__ */ jsxs38(Union7, { children: [
-    /* @__PURE__ */ jsxs38(Hull10, { children: [
+  const Body = /* @__PURE__ */ jsx146(Colorize71, { color: "#1a1a1a", children: /* @__PURE__ */ jsxs39(Union7, { children: [
+    /* @__PURE__ */ jsxs39(Hull10, { children: [
       /* @__PURE__ */ jsx146(Translate18, { z: padThickness + 0.01, children: /* @__PURE__ */ jsx146(
         Cuboid26,
         {
@@ -22559,7 +23037,7 @@ var SMA = () => {
       ) }),
       /* @__PURE__ */ jsx146(Translate18, { z: straightHeight, children: /* @__PURE__ */ jsx146(Cuboid26, { size: [bodyWidth, bodyLength10, 0.01] }) })
     ] }),
-    /* @__PURE__ */ jsxs38(Hull10, { children: [
+    /* @__PURE__ */ jsxs39(Hull10, { children: [
       /* @__PURE__ */ jsx146(Translate18, { z: straightHeight, children: /* @__PURE__ */ jsx146(Cuboid26, { size: [bodyWidth, bodyLength10, 0.01] }) }),
       /* @__PURE__ */ jsx146(Translate18, { z: bodyHeight, children: /* @__PURE__ */ jsx146(
         Cuboid26,
@@ -22577,7 +23055,7 @@ var SMA = () => {
     const bodyEdgeX = xDir * (bodyLength10 / 2 - leadThickness / 2);
     const bridgeLength = Math.abs(bodyEdgeX - verticalLeadX);
     const bridgeCenterX = (verticalLeadX + bodyEdgeX) / 2;
-    return /* @__PURE__ */ jsx146(Colorize71, { color: "#c0c0c0", children: /* @__PURE__ */ jsxs38(Union7, { children: [
+    return /* @__PURE__ */ jsx146(Colorize71, { color: "#c0c0c0", children: /* @__PURE__ */ jsxs39(Union7, { children: [
       /* @__PURE__ */ jsx146(
         Cuboid26,
         {
@@ -22601,7 +23079,7 @@ var SMA = () => {
       )
     ] }) });
   };
-  return /* @__PURE__ */ jsxs38(Fragment41, { children: [
+  return /* @__PURE__ */ jsxs39(Fragment41, { children: [
     /* @__PURE__ */ jsx146(Lead, { xDir: 1 }),
     /* @__PURE__ */ jsx146(Lead, { xDir: -1 }),
     Body
@@ -22610,7 +23088,7 @@ var SMA = () => {
 
 // lib/SMB.tsx
 import { Cuboid as Cuboid27, Colorize as Colorize72, Union as Union8, Hull as Hull11, Translate as Translate19 } from "jscad-fiber";
-import { Fragment as Fragment42, jsx as jsx147, jsxs as jsxs39 } from "react/jsx-runtime";
+import { Fragment as Fragment42, jsx as jsx147, jsxs as jsxs40 } from "react/jsx-runtime";
 var SMB = () => {
   const bodyWidth = 4.6;
   const bodyLength10 = 4;
@@ -22621,8 +23099,8 @@ var SMB = () => {
   const leadHeight = 1.14;
   const taperOffset = 0.4;
   const straightHeight = bodyHeight * 0.5;
-  const Body = /* @__PURE__ */ jsx147(Colorize72, { color: "#1a1a1a", children: /* @__PURE__ */ jsxs39(Union8, { children: [
-    /* @__PURE__ */ jsxs39(Hull11, { children: [
+  const Body = /* @__PURE__ */ jsx147(Colorize72, { color: "#1a1a1a", children: /* @__PURE__ */ jsxs40(Union8, { children: [
+    /* @__PURE__ */ jsxs40(Hull11, { children: [
       /* @__PURE__ */ jsx147(Translate19, { z: padThickness + 0.01, children: /* @__PURE__ */ jsx147(
         Cuboid27,
         {
@@ -22631,7 +23109,7 @@ var SMB = () => {
       ) }),
       /* @__PURE__ */ jsx147(Translate19, { z: straightHeight, children: /* @__PURE__ */ jsx147(Cuboid27, { size: [bodyWidth, bodyLength10, 0.01] }) })
     ] }),
-    /* @__PURE__ */ jsxs39(Hull11, { children: [
+    /* @__PURE__ */ jsxs40(Hull11, { children: [
       /* @__PURE__ */ jsx147(Translate19, { z: straightHeight, children: /* @__PURE__ */ jsx147(Cuboid27, { size: [bodyWidth, bodyLength10, 0.01] }) }),
       /* @__PURE__ */ jsx147(Translate19, { z: bodyHeight, children: /* @__PURE__ */ jsx147(
         Cuboid27,
@@ -22649,7 +23127,7 @@ var SMB = () => {
     const bodyEdgeX = xDir * (bodyLength10 / 2 - leadThickness / 2);
     const bridgeLength = Math.abs(bodyEdgeX - verticalLeadX);
     const bridgeCenterX = (verticalLeadX + bodyEdgeX) / 2;
-    return /* @__PURE__ */ jsx147(Colorize72, { color: "#c0c0c0", children: /* @__PURE__ */ jsxs39(Union8, { children: [
+    return /* @__PURE__ */ jsx147(Colorize72, { color: "#c0c0c0", children: /* @__PURE__ */ jsxs40(Union8, { children: [
       /* @__PURE__ */ jsx147(
         Cuboid27,
         {
@@ -22673,7 +23151,7 @@ var SMB = () => {
       )
     ] }) });
   };
-  return /* @__PURE__ */ jsxs39(Fragment42, { children: [
+  return /* @__PURE__ */ jsxs40(Fragment42, { children: [
     /* @__PURE__ */ jsx147(Lead, { xDir: 1 }),
     /* @__PURE__ */ jsx147(Lead, { xDir: -1 }),
     Body
@@ -22682,7 +23160,7 @@ var SMB = () => {
 
 // lib/SMC.tsx
 import { Cuboid as Cuboid28, Colorize as Colorize73, Union as Union9, Hull as Hull12, Translate as Translate20 } from "jscad-fiber";
-import { Fragment as Fragment43, jsx as jsx148, jsxs as jsxs40 } from "react/jsx-runtime";
+import { Fragment as Fragment43, jsx as jsx148, jsxs as jsxs41 } from "react/jsx-runtime";
 var SMC = () => {
   const bodyWidth = 6.8;
   const bodyLength10 = 6;
@@ -22693,8 +23171,8 @@ var SMC = () => {
   const leadHeight = 1.14;
   const taperOffset = 0.4;
   const straightHeight = bodyHeight * 0.5;
-  const Body = /* @__PURE__ */ jsx148(Colorize73, { color: "#1a1a1a", children: /* @__PURE__ */ jsxs40(Union9, { children: [
-    /* @__PURE__ */ jsxs40(Hull12, { children: [
+  const Body = /* @__PURE__ */ jsx148(Colorize73, { color: "#1a1a1a", children: /* @__PURE__ */ jsxs41(Union9, { children: [
+    /* @__PURE__ */ jsxs41(Hull12, { children: [
       /* @__PURE__ */ jsx148(Translate20, { z: padThickness + 0.01, children: /* @__PURE__ */ jsx148(
         Cuboid28,
         {
@@ -22703,7 +23181,7 @@ var SMC = () => {
       ) }),
       /* @__PURE__ */ jsx148(Translate20, { z: straightHeight, children: /* @__PURE__ */ jsx148(Cuboid28, { size: [bodyWidth, bodyLength10, 0.01] }) })
     ] }),
-    /* @__PURE__ */ jsxs40(Hull12, { children: [
+    /* @__PURE__ */ jsxs41(Hull12, { children: [
       /* @__PURE__ */ jsx148(Translate20, { z: straightHeight, children: /* @__PURE__ */ jsx148(Cuboid28, { size: [bodyWidth, bodyLength10, 0.01] }) }),
       /* @__PURE__ */ jsx148(Translate20, { z: bodyHeight, children: /* @__PURE__ */ jsx148(
         Cuboid28,
@@ -22721,7 +23199,7 @@ var SMC = () => {
     const bodyEdgeX = xDir * (bodyLength10 / 2 - leadThickness / 2);
     const bridgeLength = Math.abs(bodyEdgeX - verticalLeadX);
     const bridgeCenterX = (verticalLeadX + bodyEdgeX) / 2;
-    return /* @__PURE__ */ jsx148(Colorize73, { color: "#c0c0c0", children: /* @__PURE__ */ jsxs40(Union9, { children: [
+    return /* @__PURE__ */ jsx148(Colorize73, { color: "#c0c0c0", children: /* @__PURE__ */ jsxs41(Union9, { children: [
       /* @__PURE__ */ jsx148(
         Cuboid28,
         {
@@ -22745,7 +23223,7 @@ var SMC = () => {
       )
     ] }) });
   };
-  return /* @__PURE__ */ jsxs40(Fragment43, { children: [
+  return /* @__PURE__ */ jsxs41(Fragment43, { children: [
     /* @__PURE__ */ jsx148(Lead, { xDir: 1 }),
     /* @__PURE__ */ jsx148(Lead, { xDir: -1 }),
     Body
@@ -22754,7 +23232,7 @@ var SMC = () => {
 
 // lib/SMF.tsx
 import { Colorize as Colorize74, Cuboid as Cuboid29, Hull as Hull13, Translate as Translate21, Union as Union10 } from "jscad-fiber";
-import { Fragment as Fragment44, jsx as jsx149, jsxs as jsxs41 } from "react/jsx-runtime";
+import { Fragment as Fragment44, jsx as jsx149, jsxs as jsxs42 } from "react/jsx-runtime";
 var SMF = () => {
   const fullWidth = 2.9;
   const bodyLength10 = 1.9;
@@ -22767,9 +23245,9 @@ var SMF = () => {
   const rightPadCenterX = 1.3;
   const taperOffset = 0.2;
   const straightHeight = bodyHeight * 0.5;
-  const Body = /* @__PURE__ */ jsx149(Colorize74, { color: "#222", children: /* @__PURE__ */ jsxs41(Union10, { children: [
+  const Body = /* @__PURE__ */ jsx149(Colorize74, { color: "#222", children: /* @__PURE__ */ jsxs42(Union10, { children: [
     /* @__PURE__ */ jsx149(Translate21, { z: straightHeight / 2, children: /* @__PURE__ */ jsx149(Cuboid29, { size: [bodyWidth, bodyLength10, straightHeight] }) }),
-    /* @__PURE__ */ jsxs41(Hull13, { children: [
+    /* @__PURE__ */ jsxs42(Hull13, { children: [
       /* @__PURE__ */ jsx149(Translate21, { z: straightHeight, children: /* @__PURE__ */ jsx149(Cuboid29, { size: [bodyWidth, bodyLength10, 0.01] }) }),
       /* @__PURE__ */ jsx149(Translate21, { z: bodyHeight, children: /* @__PURE__ */ jsx149(
         Cuboid29,
@@ -22779,7 +23257,7 @@ var SMF = () => {
       ) })
     ] })
   ] }) });
-  return /* @__PURE__ */ jsxs41(Fragment44, { children: [
+  return /* @__PURE__ */ jsxs42(Fragment44, { children: [
     /* @__PURE__ */ jsx149(
       Cuboid29,
       {
@@ -22802,7 +23280,7 @@ var SMF = () => {
 
 // lib/sod-123F.tsx
 import { Colorize as Colorize75, Cuboid as Cuboid30, Hull as Hull14, Translate as Translate22, Union as Union11 } from "jscad-fiber";
-import { Fragment as Fragment45, jsx as jsx150, jsxs as jsxs42 } from "react/jsx-runtime";
+import { Fragment as Fragment45, jsx as jsx150, jsxs as jsxs43 } from "react/jsx-runtime";
 var SOD123F = () => {
   const fullWidth = 2.7;
   const bodyLength10 = 1.6;
@@ -22814,7 +23292,7 @@ var SOD123F = () => {
   const rightPadCenterX = 1.3;
   const taperOffset = 0.2;
   const straightHeight = bodyHeight * 0.5;
-  return /* @__PURE__ */ jsxs42(Fragment45, { children: [
+  return /* @__PURE__ */ jsxs43(Fragment45, { children: [
     /* @__PURE__ */ jsx150(
       Cuboid30,
       {
@@ -22831,9 +23309,9 @@ var SOD123F = () => {
         center: [rightPadCenterX, 0, padThickness / 2]
       }
     ),
-    /* @__PURE__ */ jsx150(Colorize75, { color: "#222", children: /* @__PURE__ */ jsxs42(Union11, { children: [
+    /* @__PURE__ */ jsx150(Colorize75, { color: "#222", children: /* @__PURE__ */ jsxs43(Union11, { children: [
       /* @__PURE__ */ jsx150(Translate22, { z: straightHeight / 2, children: /* @__PURE__ */ jsx150(Cuboid30, { size: [fullWidth, bodyLength10, straightHeight] }) }),
-      /* @__PURE__ */ jsxs42(Hull14, { children: [
+      /* @__PURE__ */ jsxs43(Hull14, { children: [
         /* @__PURE__ */ jsx150(Translate22, { z: straightHeight, children: /* @__PURE__ */ jsx150(Cuboid30, { size: [fullWidth, bodyLength10, 0.01] }) }),
         /* @__PURE__ */ jsx150(Translate22, { z: bodyHeight, children: /* @__PURE__ */ jsx150(
           Cuboid30,
@@ -22848,7 +23326,7 @@ var SOD123F = () => {
 
 // lib/sod-123FL.tsx
 import { Colorize as Colorize76, Cuboid as Cuboid31, Hull as Hull15, Translate as Translate23, Union as Union12 } from "jscad-fiber";
-import { Fragment as Fragment46, jsx as jsx151, jsxs as jsxs43 } from "react/jsx-runtime";
+import { Fragment as Fragment46, jsx as jsx151, jsxs as jsxs44 } from "react/jsx-runtime";
 var SOD123FL = () => {
   const fullWidth = 2.75;
   const bodyLength10 = 1.8;
@@ -22860,7 +23338,7 @@ var SOD123FL = () => {
   const rightPadCenterX = fullWidth / 2 - 0.075;
   const taperOffset = 0.4;
   const straightHeight = bodyHeight * 0.2;
-  return /* @__PURE__ */ jsxs43(Fragment46, { children: [
+  return /* @__PURE__ */ jsxs44(Fragment46, { children: [
     /* @__PURE__ */ jsx151(
       Cuboid31,
       {
@@ -22877,9 +23355,9 @@ var SOD123FL = () => {
         center: [rightPadCenterX, 0, padThickness / 2]
       }
     ),
-    /* @__PURE__ */ jsx151(Colorize76, { color: "#222", children: /* @__PURE__ */ jsxs43(Union12, { children: [
+    /* @__PURE__ */ jsx151(Colorize76, { color: "#222", children: /* @__PURE__ */ jsxs44(Union12, { children: [
       /* @__PURE__ */ jsx151(Translate23, { z: straightHeight / 2, children: /* @__PURE__ */ jsx151(Cuboid31, { size: [fullWidth, bodyLength10, straightHeight] }) }),
-      /* @__PURE__ */ jsxs43(Hull15, { children: [
+      /* @__PURE__ */ jsxs44(Hull15, { children: [
         /* @__PURE__ */ jsx151(Translate23, { z: straightHeight, children: /* @__PURE__ */ jsx151(Cuboid31, { size: [fullWidth, bodyLength10, 0.01] }) }),
         /* @__PURE__ */ jsx151(Translate23, { z: bodyHeight, children: /* @__PURE__ */ jsx151(
           Cuboid31,
@@ -22902,7 +23380,7 @@ var SOD123FL = () => {
 
 // lib/sod-123W.tsx
 import { Colorize as Colorize77, Cuboid as Cuboid32, Hull as Hull16, Translate as Translate24, Union as Union13 } from "jscad-fiber";
-import { Fragment as Fragment47, jsx as jsx152, jsxs as jsxs44 } from "react/jsx-runtime";
+import { Fragment as Fragment47, jsx as jsx152, jsxs as jsxs45 } from "react/jsx-runtime";
 var SOD123W = ({
   bodyWidth = 2.6,
   bodyLength: bodyLength10 = 1.7,
@@ -22917,7 +23395,7 @@ var SOD123W = ({
   const taperOffset = 0.4;
   const lowerTaperOffset = 0.1;
   const straightHeight = bodyHeight * 0.2;
-  return /* @__PURE__ */ jsxs44(Fragment47, { children: [
+  return /* @__PURE__ */ jsxs45(Fragment47, { children: [
     /* @__PURE__ */ jsx152(
       Cuboid32,
       {
@@ -22934,8 +23412,8 @@ var SOD123W = ({
         center: [rightPadCenterX, 0, padThickness / 2]
       }
     ),
-    /* @__PURE__ */ jsx152(Colorize77, { color: "#222", children: /* @__PURE__ */ jsxs44(Union13, { children: [
-      /* @__PURE__ */ jsxs44(Hull16, { children: [
+    /* @__PURE__ */ jsx152(Colorize77, { color: "#222", children: /* @__PURE__ */ jsxs45(Union13, { children: [
+      /* @__PURE__ */ jsxs45(Hull16, { children: [
         /* @__PURE__ */ jsx152(Translate24, { z: straightHeight, children: /* @__PURE__ */ jsx152(
           Cuboid32,
           {
@@ -22957,7 +23435,7 @@ var SOD123W = ({
           }
         ) })
       ] }),
-      /* @__PURE__ */ jsxs44(Hull16, { children: [
+      /* @__PURE__ */ jsxs45(Hull16, { children: [
         /* @__PURE__ */ jsx152(Translate24, { z: straightHeight, children: /* @__PURE__ */ jsx152(Cuboid32, { size: [fullWidth, bodyLength10, 0.01] }) }),
         /* @__PURE__ */ jsx152(Translate24, { z: bodyHeight, children: /* @__PURE__ */ jsx152(
           Cuboid32,
@@ -22980,7 +23458,7 @@ var SOD123W = ({
 
 // lib/sod-123.tsx
 import { Cuboid as Cuboid33 } from "jscad-fiber";
-import { Fragment as Fragment48, jsx as jsx153, jsxs as jsxs45 } from "react/jsx-runtime";
+import { Fragment as Fragment48, jsx as jsx153, jsxs as jsxs46 } from "react/jsx-runtime";
 var SOD123 = ({
   fullWidth = 3.7,
   fullLength: fullLength10 = 1.55
@@ -22996,7 +23474,7 @@ var SOD123 = ({
   const bodyDistance = (fullWidth - bodyWidth) / 2;
   const padContactLength = 0.25;
   const leadCurveLength = 0.2;
-  return /* @__PURE__ */ jsxs45(Fragment48, { children: [
+  return /* @__PURE__ */ jsxs46(Fragment48, { children: [
     /* @__PURE__ */ jsx153(
       SmdChipLead,
       {
@@ -23057,7 +23535,7 @@ var SOD123 = ({
 
 // lib/sod-128.tsx
 import { Colorize as Colorize78, Cuboid as Cuboid34, Hull as Hull17, Translate as Translate25, Union as Union14 } from "jscad-fiber";
-import { Fragment as Fragment49, jsx as jsx154, jsxs as jsxs46 } from "react/jsx-runtime";
+import { Fragment as Fragment49, jsx as jsx154, jsxs as jsxs47 } from "react/jsx-runtime";
 var SOD128 = () => {
   const fullWidth = 3.8;
   const bodyLength10 = 2.5;
@@ -23070,7 +23548,7 @@ var SOD128 = () => {
   const taperOffset = 0.4;
   const lowerTaperOffset = 0.05;
   const straightHeight = bodyHeight * 0.2;
-  return /* @__PURE__ */ jsxs46(Fragment49, { children: [
+  return /* @__PURE__ */ jsxs47(Fragment49, { children: [
     /* @__PURE__ */ jsx154(
       Cuboid34,
       {
@@ -23087,8 +23565,8 @@ var SOD128 = () => {
         center: [rightPadCenterX, 0, padThickness / 2]
       }
     ),
-    /* @__PURE__ */ jsx154(Colorize78, { color: "#222", children: /* @__PURE__ */ jsxs46(Union14, { children: [
-      /* @__PURE__ */ jsxs46(Hull17, { children: [
+    /* @__PURE__ */ jsx154(Colorize78, { color: "#222", children: /* @__PURE__ */ jsxs47(Union14, { children: [
+      /* @__PURE__ */ jsxs47(Hull17, { children: [
         /* @__PURE__ */ jsx154(Translate25, { z: straightHeight, children: /* @__PURE__ */ jsx154(
           Cuboid34,
           {
@@ -23110,7 +23588,7 @@ var SOD128 = () => {
           }
         ) })
       ] }),
-      /* @__PURE__ */ jsxs46(Hull17, { children: [
+      /* @__PURE__ */ jsxs47(Hull17, { children: [
         /* @__PURE__ */ jsx154(Translate25, { z: straightHeight, children: /* @__PURE__ */ jsx154(Cuboid34, { size: [fullWidth, bodyLength10, 0.01] }) }),
         /* @__PURE__ */ jsx154(Translate25, { z: bodyHeight, children: /* @__PURE__ */ jsx154(
           Cuboid34,
@@ -23133,7 +23611,7 @@ var SOD128 = () => {
 
 // lib/SOD-923.tsx
 import { Colorize as Colorize79, Cuboid as Cuboid35, Hull as Hull18, Translate as Translate26, Union as Union15 } from "jscad-fiber";
-import { Fragment as Fragment50, jsx as jsx155, jsxs as jsxs47 } from "react/jsx-runtime";
+import { Fragment as Fragment50, jsx as jsx155, jsxs as jsxs48 } from "react/jsx-runtime";
 var SOD923 = () => {
   const fullWidth = 0.8;
   const bodyLength10 = 0.6;
@@ -23145,7 +23623,7 @@ var SOD923 = () => {
   const rightPadCenterX = fullWidth / 2;
   const taperOffset = 0.1;
   const straightHeight = padThickness;
-  return /* @__PURE__ */ jsxs47(Fragment50, { children: [
+  return /* @__PURE__ */ jsxs48(Fragment50, { children: [
     /* @__PURE__ */ jsx155(
       Cuboid35,
       {
@@ -23162,9 +23640,9 @@ var SOD923 = () => {
         center: [rightPadCenterX, 0, padThickness / 2]
       }
     ),
-    /* @__PURE__ */ jsx155(Colorize79, { color: "#222", children: /* @__PURE__ */ jsxs47(Union15, { children: [
+    /* @__PURE__ */ jsx155(Colorize79, { color: "#222", children: /* @__PURE__ */ jsxs48(Union15, { children: [
       /* @__PURE__ */ jsx155(Translate26, { z: straightHeight / 2, children: /* @__PURE__ */ jsx155(Cuboid35, { size: [fullWidth, bodyLength10, straightHeight] }) }),
-      /* @__PURE__ */ jsxs47(Hull18, { children: [
+      /* @__PURE__ */ jsxs48(Hull18, { children: [
         /* @__PURE__ */ jsx155(Translate26, { z: straightHeight, children: /* @__PURE__ */ jsx155(Cuboid35, { size: [fullWidth, bodyLength10, 0.01] }) }),
         /* @__PURE__ */ jsx155(Translate26, { z: bodyHeight, children: /* @__PURE__ */ jsx155(
           Cuboid35,
@@ -23178,7 +23656,7 @@ var SOD923 = () => {
 };
 
 // lib/SOT-223.tsx
-import { Fragment as Fragment51, jsx as jsx156, jsxs as jsxs48 } from "react/jsx-runtime";
+import { Fragment as Fragment51, jsx as jsx156, jsxs as jsxs49 } from "react/jsx-runtime";
 var SOT223 = ({
   fullWidth = 6.6,
   bodyWidth = 3.5,
@@ -23193,7 +23671,7 @@ var SOT223 = ({
   const leadThickness = 0.25;
   const padContactLength = 0.5;
   const extendedBodyDistance = fullWidth - bodyWidth;
-  return /* @__PURE__ */ jsxs48(Fragment51, { children: [
+  return /* @__PURE__ */ jsxs49(Fragment51, { children: [
     /* @__PURE__ */ jsx156(
       SmdChipLead,
       {
@@ -23275,7 +23753,7 @@ var SOT223 = ({
 };
 
 // lib/tqfp.tsx
-import { Fragment as Fragment52, jsx as jsx157, jsxs as jsxs49 } from "react/jsx-runtime";
+import { Fragment as Fragment52, jsx as jsx157, jsxs as jsxs50 } from "react/jsx-runtime";
 var TQFP = () => {
   const pinCount = 64;
   const pitch = 0.5;
@@ -23290,7 +23768,7 @@ var TQFP = () => {
   const leadHeight = 0.65;
   const leadThickness = 0.25;
   const bodyDistance = (fullWidth - bodyWidth) / 2 + 0.2;
-  return /* @__PURE__ */ jsxs49(Fragment52, { children: [
+  return /* @__PURE__ */ jsxs50(Fragment52, { children: [
     Array.from({ length: sidePinCount }).map((_, i) => /* @__PURE__ */ jsx157(
       SmdChipLead,
       {
@@ -23376,7 +23854,7 @@ var TQFP = () => {
 var tqfp_default = TQFP;
 
 // lib/SOT-323.tsx
-import { Fragment as Fragment53, jsx as jsx158, jsxs as jsxs50 } from "react/jsx-runtime";
+import { Fragment as Fragment53, jsx as jsx158, jsxs as jsxs51 } from "react/jsx-runtime";
 var SOT323 = () => {
   const fullWidth = 2.05;
   const bodyWidth = 1.25;
@@ -23388,7 +23866,7 @@ var SOT323 = () => {
   const padContactLength = 0.2;
   const padPitch = 0.65;
   const extendedBodyDistance = fullWidth - bodyWidth;
-  return /* @__PURE__ */ jsxs50(Fragment53, { children: [
+  return /* @__PURE__ */ jsxs51(Fragment53, { children: [
     /* @__PURE__ */ jsx158(
       SmdChipLead,
       {
@@ -23460,11 +23938,11 @@ import {
   Cuboid as Cuboid36,
   Cylinder as Cylinder9,
   Hull as Hull19,
-  Subtract as Subtract8,
+  Subtract as Subtract9,
   Translate as Translate27,
   Union as Union16
 } from "jscad-fiber";
-import { Fragment as Fragment54, jsx as jsx159, jsxs as jsxs51 } from "react/jsx-runtime";
+import { Fragment as Fragment54, jsx as jsx159, jsxs as jsxs52 } from "react/jsx-runtime";
 function createPhysicalLqfp(p) {
   const {
     pinCount,
@@ -23508,7 +23986,7 @@ function createPhysicalLqfp(p) {
     throw new Error("Invalid mold, lead spacing, or terminal reach");
   const midZ = standoff + moldHeight / 2;
   const slice = Math.min(2e-3, moldHeight / 100);
-  const body = /* @__PURE__ */ jsxs51(Hull19, { children: [
+  const body = /* @__PURE__ */ jsxs52(Hull19, { children: [
     /* @__PURE__ */ jsx159(Translate27, { z: standoff + slice / 2, children: /* @__PURE__ */ jsx159(
       Cuboid36,
       {
@@ -23569,13 +24047,13 @@ function createPhysicalLqfp(p) {
         )
       }
     );
-    return /* @__PURE__ */ jsx159(Union16, { children: points.slice(1).map((point, i) => /* @__PURE__ */ jsxs51(Hull19, { children: [
+    return /* @__PURE__ */ jsx159(Union16, { children: points.slice(1).map((point, i) => /* @__PURE__ */ jsxs52(Hull19, { children: [
       section(points[i]),
       section(point)
     ] }, i)) });
   };
-  return /* @__PURE__ */ jsxs51(Fragment54, { children: [
-    /* @__PURE__ */ jsx159(Colorize80, { color: "#353535", children: /* @__PURE__ */ jsxs51(Subtract8, { children: [
+  return /* @__PURE__ */ jsxs52(Fragment54, { children: [
+    /* @__PURE__ */ jsx159(Colorize80, { color: "#353535", children: /* @__PURE__ */ jsxs52(Subtract9, { children: [
       body,
       /* @__PURE__ */ jsx159(
         Translate27,
@@ -23600,7 +24078,7 @@ function createPhysicalLqfp(p) {
 }
 
 // lib/lqfp.tsx
-import { Fragment as Fragment55, jsx as jsx160, jsxs as jsxs52 } from "react/jsx-runtime";
+import { Fragment as Fragment55, jsx as jsx160, jsxs as jsxs53 } from "react/jsx-runtime";
 var LegacyLQFP = ({
   pinCount,
   pitch,
@@ -23623,7 +24101,7 @@ var LegacyLQFP = ({
   const leadHeight = 0.8;
   const leadThickness = 0.2;
   const bodyDistance = (fullWidth - bodyWidth) / 2 + 0.4;
-  return /* @__PURE__ */ jsxs52(Fragment55, { children: [
+  return /* @__PURE__ */ jsxs53(Fragment55, { children: [
     Array.from({ length: sidePinCount }).map((_, i) => /* @__PURE__ */ jsx160(
       SmdChipLead,
       {
@@ -23715,7 +24193,7 @@ var LQFP = (props) => "leadSpanX" in props ? createPhysicalLqfp(props) : LegacyL
 
 // lib/SOT-723.tsx
 import { Cuboid as Cuboid37, Translate as Translate28, Colorize as Colorize81, Hull as Hull20, Union as Union17 } from "jscad-fiber";
-import { Fragment as Fragment56, jsx as jsx161, jsxs as jsxs53 } from "react/jsx-runtime";
+import { Fragment as Fragment56, jsx as jsx161, jsxs as jsxs54 } from "react/jsx-runtime";
 var SOT723 = () => {
   const bodyWidth = 0.85;
   const bodyLength10 = 1.2;
@@ -23732,8 +24210,8 @@ var SOT723 = () => {
   const leftTopPadCenterY = 0.4;
   const leftBottomPadCenterX = -0.55;
   const leftBottomPadCenterY = -0.4;
-  return /* @__PURE__ */ jsxs53(Fragment56, { children: [
-    /* @__PURE__ */ jsx161(Colorize81, { color: "#222", children: /* @__PURE__ */ jsxs53(Union17, { children: [
+  return /* @__PURE__ */ jsxs54(Fragment56, { children: [
+    /* @__PURE__ */ jsx161(Colorize81, { color: "#222", children: /* @__PURE__ */ jsxs54(Union17, { children: [
       /* @__PURE__ */ jsx161(
         Cuboid37,
         {
@@ -23741,7 +24219,7 @@ var SOT723 = () => {
           center: [0, 0, straightHeight / 2]
         }
       ),
-      /* @__PURE__ */ jsxs53(Hull20, { children: [
+      /* @__PURE__ */ jsxs54(Hull20, { children: [
         /* @__PURE__ */ jsx161(Translate28, { z: straightHeight, children: /* @__PURE__ */ jsx161(Cuboid37, { size: [bodyWidth, bodyLength10, 0.01] }) }),
         /* @__PURE__ */ jsx161(Translate28, { z: bodyHeight, children: /* @__PURE__ */ jsx161(
           Cuboid37,
@@ -23779,8 +24257,8 @@ var SOT723 = () => {
 };
 
 // lib/dfn.tsx
-import { Colorize as Colorize82, Cuboid as Cuboid38, Hull as Hull21, Subtract as Subtract9 } from "jscad-fiber";
-import { Fragment as Fragment57, jsx as jsx162, jsxs as jsxs54 } from "react/jsx-runtime";
+import { Colorize as Colorize82, Cuboid as Cuboid38, Hull as Hull21, Subtract as Subtract10 } from "jscad-fiber";
+import { Fragment as Fragment57, jsx as jsx162, jsxs as jsxs55 } from "react/jsx-runtime";
 var DFN = ({
   num_pins,
   bodyWidth = 5.3,
@@ -23861,13 +24339,13 @@ var DFN = ({
         center: [0, 0, standoff + bodyThickness / 2]
       }
     );
-    return /* @__PURE__ */ jsxs54(Fragment57, { children: [
-      /* @__PURE__ */ jsx162(Colorize82, { material: componentMaterials.moldedPlastic, color: "#25272a", children: pin1MarkWidth > 0 ? /* @__PURE__ */ jsxs54(Subtract9, { children: [
+    return /* @__PURE__ */ jsxs55(Fragment57, { children: [
+      /* @__PURE__ */ jsx162(Colorize82, { material: componentMaterials.moldedPlastic, color: "#25272a", children: pin1MarkWidth > 0 ? /* @__PURE__ */ jsxs55(Subtract10, { children: [
         body,
         stripe
       ] }) : body }),
       /* @__PURE__ */ jsx162(Colorize82, { material: componentMaterials.tinnedLead, color: "#c7c9cd", children: pinPositions.map(
-        (p) => p.pinNumber === 1 && pin1TerminalChamfer > 0 ? /* @__PURE__ */ jsxs54(Hull21, { children: [
+        (p) => p.pinNumber === 1 && pin1TerminalChamfer > 0 ? /* @__PURE__ */ jsxs55(Hull21, { children: [
           /* @__PURE__ */ jsx162(
             Cuboid38,
             {
@@ -23919,7 +24397,7 @@ var DFN = ({
       pin1MarkWidth > 0 && /* @__PURE__ */ jsx162(Colorize82, { color: "#969997", children: stripe })
     ] });
   }
-  return /* @__PURE__ */ jsxs54(Fragment57, { children: [
+  return /* @__PURE__ */ jsxs55(Fragment57, { children: [
     /* @__PURE__ */ jsx162(
       ChipBody,
       {
@@ -23962,7 +24440,7 @@ var DFN = ({
 
 // lib/hc49.tsx
 import { Colorize as Colorize83, Cylinder as Cylinder10, Hull as Hull22, RoundedCylinder } from "jscad-fiber";
-import { Fragment as Fragment58, jsx as jsx163, jsxs as jsxs55 } from "react/jsx-runtime";
+import { Fragment as Fragment58, jsx as jsx163, jsxs as jsxs56 } from "react/jsx-runtime";
 var HC49 = ({
   bodyLength: bodyLength10 = 10.2,
   bodyWidth = 4.65,
@@ -23978,9 +24456,9 @@ var HC49 = ({
   const endCenterX = halfLength - endRadius;
   const leadCenterX = leadSpacing / 2;
   const baseHeight = 0.85;
-  return /* @__PURE__ */ jsxs55(Fragment58, { children: [
-    /* @__PURE__ */ jsxs55(Colorize83, { color, children: [
-      /* @__PURE__ */ jsxs55(Hull22, { children: [
+  return /* @__PURE__ */ jsxs56(Fragment58, { children: [
+    /* @__PURE__ */ jsxs56(Colorize83, { color, children: [
+      /* @__PURE__ */ jsxs56(Hull22, { children: [
         /* @__PURE__ */ jsx163(
           RoundedCylinder,
           {
@@ -24000,7 +24478,7 @@ var HC49 = ({
           }
         )
       ] }),
-      /* @__PURE__ */ jsxs55(Hull22, { children: [
+      /* @__PURE__ */ jsxs56(Hull22, { children: [
         /* @__PURE__ */ jsx163(
           RoundedCylinder,
           {
@@ -24021,7 +24499,7 @@ var HC49 = ({
         )
       ] })
     ] }),
-    /* @__PURE__ */ jsxs55(Colorize83, { color: leadColor, children: [
+    /* @__PURE__ */ jsxs56(Colorize83, { color: leadColor, children: [
       /* @__PURE__ */ jsx163(
         Cylinder10,
         {
@@ -24050,7 +24528,7 @@ import {
   Rotate as Rotate9,
   RoundedCuboid as RoundedCuboid4
 } from "jscad-fiber";
-import { Fragment as Fragment59, jsx as jsx164, jsxs as jsxs56 } from "react/jsx-runtime";
+import { Fragment as Fragment59, jsx as jsx164, jsxs as jsxs57 } from "react/jsx-runtime";
 var MicroMELF = ({
   bodyLength: bodyLength10 = 1.4,
   bodyDiameter = 1.1,
@@ -24059,8 +24537,8 @@ var MicroMELF = ({
   cathodeIdentification = "#111"
 }) => {
   const padLength = 0.2;
-  return /* @__PURE__ */ jsxs56(Fragment59, { children: [
-    /* @__PURE__ */ jsx164(Colorize84, { color, children: /* @__PURE__ */ jsxs56(Rotate9, { rotation: [0, "90deg", 0], children: [
+  return /* @__PURE__ */ jsxs57(Fragment59, { children: [
+    /* @__PURE__ */ jsx164(Colorize84, { color, children: /* @__PURE__ */ jsxs57(Rotate9, { rotation: [0, "90deg", 0], children: [
       /* @__PURE__ */ jsx164(
         RoundedCuboid4,
         {
@@ -24109,7 +24587,7 @@ var MicroMELF = ({
 
 // lib/MINIMELF.tsx
 import { Colorize as Colorize85, Cylinder as Cylinder12, RoundedCylinder as RoundedCylinder3, Rotate as Rotate10 } from "jscad-fiber";
-import { Fragment as Fragment60, jsx as jsx165, jsxs as jsxs57 } from "react/jsx-runtime";
+import { Fragment as Fragment60, jsx as jsx165, jsxs as jsxs58 } from "react/jsx-runtime";
 var MINIMELF = ({
   bodyLength: bodyLength10 = 3.5,
   bodyDiameter = 1.5,
@@ -24123,7 +24601,7 @@ var MINIMELF = ({
   const contactRadius = bodyDiameter / 2 + 0.02;
   const bandLength = 0.14;
   const bandOffset = -bodyLength10 / 2 + contactLength + 0.35;
-  return /* @__PURE__ */ jsxs57(Fragment60, { children: [
+  return /* @__PURE__ */ jsxs58(Fragment60, { children: [
     /* @__PURE__ */ jsx165(Colorize85, { color, children: /* @__PURE__ */ jsx165(Rotate10, { rotation: [0, "90deg", 0], children: /* @__PURE__ */ jsx165(
       RoundedCylinder3,
       {
@@ -24164,7 +24642,7 @@ var MINIMELF = ({
 
 // lib/MELF.tsx
 import { Colorize as Colorize86, RoundedCylinder as RoundedCylinder4, Rotate as Rotate11 } from "jscad-fiber";
-import { Fragment as Fragment61, jsx as jsx166, jsxs as jsxs58 } from "react/jsx-runtime";
+import { Fragment as Fragment61, jsx as jsx166, jsxs as jsxs59 } from "react/jsx-runtime";
 var MELF = ({
   bodyLength: bodyLength10 = 3.9,
   bodyDiameter = 2.5,
@@ -24172,7 +24650,7 @@ var MELF = ({
   contactColor = "#c6c6c6"
 }) => {
   const padLength = 0.55;
-  return /* @__PURE__ */ jsxs58(Fragment61, { children: [
+  return /* @__PURE__ */ jsxs59(Fragment61, { children: [
     /* @__PURE__ */ jsx166(Colorize86, { color, children: /* @__PURE__ */ jsx166(Rotate11, { rotation: [0, "90deg", 0], children: /* @__PURE__ */ jsx166(
       RoundedCylinder4,
       {
@@ -24204,7 +24682,7 @@ var MELF = ({
 };
 
 // lib/ms012.tsx
-import { Fragment as Fragment62, jsx as jsx167, jsxs as jsxs59 } from "react/jsx-runtime";
+import { Fragment as Fragment62, jsx as jsx167, jsxs as jsxs60 } from "react/jsx-runtime";
 var MS012 = ({
   pinCount,
   padContactLength = 0.6,
@@ -24219,7 +24697,7 @@ var MS012 = ({
   const bodyLength10 = 3.9;
   const pinOffsetToCenter = (sidePinCount - 1) * pitch / 2;
   const leadThickness = 0.2;
-  return /* @__PURE__ */ jsxs59(Fragment62, { children: [
+  return /* @__PURE__ */ jsxs60(Fragment62, { children: [
     Array.from({ length: sidePinCount }).map((_, i) => /* @__PURE__ */ jsx167(
       SmdChipLead,
       {
@@ -24273,7 +24751,7 @@ var MS012 = ({
 };
 
 // lib/ms013.tsx
-import { Fragment as Fragment63, jsx as jsx168, jsxs as jsxs60 } from "react/jsx-runtime";
+import { Fragment as Fragment63, jsx as jsx168, jsxs as jsxs61 } from "react/jsx-runtime";
 var MS013 = ({
   pinCount = 16,
   padContactLength = 0.6,
@@ -24288,7 +24766,7 @@ var MS013 = ({
   const bodyLength10 = 10.3;
   const pinOffsetToCenter = (sidePinCount - 1) * pitch / 2;
   const leadThickness = 0.2;
-  return /* @__PURE__ */ jsxs60(Fragment63, { children: [
+  return /* @__PURE__ */ jsxs61(Fragment63, { children: [
     Array.from({ length: sidePinCount }).map((_, i) => /* @__PURE__ */ jsx168(
       SmdChipLead,
       {
@@ -24347,10 +24825,10 @@ import {
   Cuboid as Cuboid40,
   Cylinder as Cylinder13,
   Rotate as Rotate12,
-  Subtract as Subtract10,
+  Subtract as Subtract11,
   Translate as Translate29
 } from "jscad-fiber";
-import { Fragment as Fragment64, jsx as jsx169, jsxs as jsxs61 } from "react/jsx-runtime";
+import { Fragment as Fragment64, jsx as jsx169, jsxs as jsxs62 } from "react/jsx-runtime";
 var TO220_DEFAULT_LEADS = [
   { x: -2.54, y: -1 },
   { x: 0, y: -1 },
@@ -24380,7 +24858,7 @@ var TO220 = ({
   const holeZ = tabTop - Math.max(mountingHoleDiameter * 0.8, 2.6);
   const leadWidth = 0.8;
   const leadThickness = 0.5;
-  return /* @__PURE__ */ jsxs61(Fragment64, { children: [
+  return /* @__PURE__ */ jsxs62(Fragment64, { children: [
     /* @__PURE__ */ jsx169(Colorize87, { color: bodyColor, children: /* @__PURE__ */ jsx169(
       Cuboid40,
       {
@@ -24388,7 +24866,7 @@ var TO220 = ({
         center: [centerX, centerY, bodyBottom + bodyHeight / 2]
       }
     ) }),
-    /* @__PURE__ */ jsx169(Colorize87, { color: mouldedTab ? bodyColor : tabColor, children: /* @__PURE__ */ jsxs61(Subtract10, { children: [
+    /* @__PURE__ */ jsx169(Colorize87, { color: mouldedTab ? bodyColor : tabColor, children: /* @__PURE__ */ jsxs62(Subtract11, { children: [
       /* @__PURE__ */ jsx169(
         Cuboid40,
         {
@@ -24415,7 +24893,7 @@ var TO220 = ({
 };
 
 // lib/SOT-457.tsx
-import { Fragment as Fragment65, jsx as jsx170, jsxs as jsxs62 } from "react/jsx-runtime";
+import { Fragment as Fragment65, jsx as jsx170, jsxs as jsxs63 } from "react/jsx-runtime";
 var SOT457 = () => {
   const fullWidth = 2.8;
   const bodyWidth = 1.6;
@@ -24427,7 +24905,7 @@ var SOT457 = () => {
   const padContactLength = 0.5;
   const padPitch = 0.95;
   const extendedBodyDistance = fullWidth - bodyWidth;
-  return /* @__PURE__ */ jsxs62(Fragment65, { children: [
+  return /* @__PURE__ */ jsxs63(Fragment65, { children: [
     /* @__PURE__ */ jsx170(
       SmdChipLead,
       {
@@ -24548,7 +25026,7 @@ var SOT457 = () => {
 
 // lib/SOT-963.tsx
 import { Cuboid as Cuboid41 } from "jscad-fiber";
-import { Fragment as Fragment66, jsx as jsx171, jsxs as jsxs63 } from "react/jsx-runtime";
+import { Fragment as Fragment66, jsx as jsx171, jsxs as jsxs64 } from "react/jsx-runtime";
 var SOT963 = () => {
   const bodyWidth = 0.8;
   const bodyLength10 = 1;
@@ -24559,7 +25037,7 @@ var SOT963 = () => {
   const pitch = 0.35;
   const pinsPerSide = 3;
   const pinSpan = pitch * (pinsPerSide - 1);
-  return /* @__PURE__ */ jsxs63(Fragment66, { children: [
+  return /* @__PURE__ */ jsxs64(Fragment66, { children: [
     /* @__PURE__ */ jsx171(
       ChipBody,
       {
@@ -24618,9 +25096,9 @@ import {
   Hull as Hull23,
   Translate as Translate30,
   Cylinder as Cylinder14,
-  Subtract as Subtract11
+  Subtract as Subtract12
 } from "jscad-fiber";
-import { Fragment as Fragment67, jsx as jsx172, jsxs as jsxs64 } from "react/jsx-runtime";
+import { Fragment as Fragment67, jsx as jsx172, jsxs as jsxs65 } from "react/jsx-runtime";
 var TO92_DEFAULT_LEADS = [
   { x: -1.27, y: 0.98 },
   { x: 0, y: 2.25 },
@@ -24679,8 +25157,8 @@ var TO92 = ({
     legWidth,
     legThickness
   ];
-  return /* @__PURE__ */ jsxs64(Fragment67, { children: [
-    /* @__PURE__ */ jsx172(Colorize88, { color: bodyColor, children: /* @__PURE__ */ jsxs64(Subtract11, { children: [
+  return /* @__PURE__ */ jsxs65(Fragment67, { children: [
+    /* @__PURE__ */ jsx172(Colorize88, { color: bodyColor, children: /* @__PURE__ */ jsxs65(Subtract12, { children: [
       /* @__PURE__ */ jsx172(
         Translate30,
         {
@@ -24702,8 +25180,8 @@ var TO92 = ({
     ] }) }),
     leads.map((lead, index) => {
       const exit = exitFor(index);
-      return /* @__PURE__ */ jsxs64(Translate30, { center: [0, 0, 0], children: [
-        /* @__PURE__ */ jsxs64(Hull23, { children: [
+      return /* @__PURE__ */ jsxs65(Translate30, { center: [0, 0, 0], children: [
+        /* @__PURE__ */ jsxs65(Hull23, { children: [
           /* @__PURE__ */ jsx172(Translate30, { center: [lead.x, lead.y, 0], children: /* @__PURE__ */ jsx172(Cuboid42, { size: leadSize }) }),
           /* @__PURE__ */ jsx172(Translate30, { center: [exit.x, exit.y, standoff], children: /* @__PURE__ */ jsx172(Cuboid42, { size: leadSize }) })
         ] }),
@@ -24714,7 +25192,7 @@ var TO92 = ({
 };
 
 // lib/SOT-363.tsx
-import { Fragment as Fragment68, jsx as jsx173, jsxs as jsxs65 } from "react/jsx-runtime";
+import { Fragment as Fragment68, jsx as jsx173, jsxs as jsxs66 } from "react/jsx-runtime";
 var SOT363 = () => {
   const fullWidth = 2;
   const bodyWidth = 1.25;
@@ -24725,7 +25203,7 @@ var SOT363 = () => {
   const leadHeight = 0.85;
   const padContactLength = 0.3;
   const extendedBodyDistance = fullWidth - bodyWidth;
-  return /* @__PURE__ */ jsxs65(Fragment68, { children: [
+  return /* @__PURE__ */ jsxs66(Fragment68, { children: [
     /* @__PURE__ */ jsx173(
       SmdChipLead,
       {
@@ -24847,7 +25325,7 @@ var SOT_363_default = SOT363;
 
 // lib/SOT-886.tsx
 import { Cuboid as Cuboid43 } from "jscad-fiber";
-import { Fragment as Fragment69, jsx as jsx174, jsxs as jsxs66 } from "react/jsx-runtime";
+import { Fragment as Fragment69, jsx as jsx174, jsxs as jsxs67 } from "react/jsx-runtime";
 var SOT886 = () => {
   const bodyWidth = 1;
   const bodyLength10 = 1.45;
@@ -24858,7 +25336,7 @@ var SOT886 = () => {
   const pitch = 0.5;
   const pinsPerSide = 3;
   const pinSpan = pitch * (pinsPerSide - 1);
-  return /* @__PURE__ */ jsxs66(Fragment69, { children: [
+  return /* @__PURE__ */ jsxs67(Fragment69, { children: [
     /* @__PURE__ */ jsx174(
       ChipBody,
       {
@@ -24907,7 +25385,7 @@ var SOT886 = () => {
 
 // lib/sod-323.tsx
 import { Colorize as Colorize89, Cuboid as Cuboid44 } from "jscad-fiber";
-import { Fragment as Fragment70, jsx as jsx175, jsxs as jsxs67 } from "react/jsx-runtime";
+import { Fragment as Fragment70, jsx as jsx175, jsxs as jsxs68 } from "react/jsx-runtime";
 var SOD323 = () => {
   const fullWidth = 2.5;
   const bodyLength10 = 1.4;
@@ -24919,7 +25397,7 @@ var SOD323 = () => {
   const padCenterX = bodyWidth / 2;
   const bodyDistance = 0.45;
   const leadHeight = 0.7;
-  return /* @__PURE__ */ jsxs67(Fragment70, { children: [
+  return /* @__PURE__ */ jsxs68(Fragment70, { children: [
     /* @__PURE__ */ jsx175(
       SmdChipLead,
       {
@@ -24979,7 +25457,7 @@ var SOD323 = () => {
 
 // lib/sod-323F.tsx
 import { Colorize as Colorize90, Cuboid as Cuboid45, Hull as Hull25, Translate as Translate32, Union as Union19 } from "jscad-fiber";
-import { Fragment as Fragment71, jsx as jsx176, jsxs as jsxs68 } from "react/jsx-runtime";
+import { Fragment as Fragment71, jsx as jsx176, jsxs as jsxs69 } from "react/jsx-runtime";
 var SOD323F = () => {
   const fullWidth = 1.7;
   const bodyLength10 = 1.25;
@@ -24991,7 +25469,7 @@ var SOD323F = () => {
   const rightPadCenterX = fullWidth / 2 + padLength / 2;
   const taperOffset = 0.2;
   const straightHeight = padThickness;
-  return /* @__PURE__ */ jsxs68(Fragment71, { children: [
+  return /* @__PURE__ */ jsxs69(Fragment71, { children: [
     /* @__PURE__ */ jsx176(
       Cuboid45,
       {
@@ -25008,9 +25486,9 @@ var SOD323F = () => {
         center: [rightPadCenterX, 0, padThickness / 2]
       }
     ),
-    /* @__PURE__ */ jsx176(Colorize90, { color: "#222", children: /* @__PURE__ */ jsxs68(Union19, { children: [
+    /* @__PURE__ */ jsx176(Colorize90, { color: "#222", children: /* @__PURE__ */ jsxs69(Union19, { children: [
       /* @__PURE__ */ jsx176(Translate32, { z: straightHeight / 2, children: /* @__PURE__ */ jsx176(Cuboid45, { size: [fullWidth, bodyLength10, straightHeight] }) }),
-      /* @__PURE__ */ jsxs68(Hull25, { children: [
+      /* @__PURE__ */ jsxs69(Hull25, { children: [
         /* @__PURE__ */ jsx176(Translate32, { z: straightHeight, children: /* @__PURE__ */ jsx176(Cuboid45, { size: [fullWidth, bodyLength10, 0.01] }) }),
         /* @__PURE__ */ jsx176(Translate32, { z: bodyHeight, children: /* @__PURE__ */ jsx176(
           Cuboid45,
@@ -25033,7 +25511,7 @@ var SOD323F = () => {
 
 // lib/sod-323FL.tsx
 import { Colorize as Colorize91, Cuboid as Cuboid46 } from "jscad-fiber";
-import { Fragment as Fragment72, jsx as jsx177, jsxs as jsxs69 } from "react/jsx-runtime";
+import { Fragment as Fragment72, jsx as jsx177, jsxs as jsxs70 } from "react/jsx-runtime";
 var SOD323FL = () => {
   const fullWidth = 1.775;
   const bodyLength10 = 1.25;
@@ -25044,7 +25522,7 @@ var SOD323FL = () => {
   const leftPadCenterX = -fullWidth / 2 - padLength / 2 + 0.04;
   const rightPadCenterX = fullWidth / 2 + padLength / 2 - 0.04;
   const taperOffset = 0.2;
-  return /* @__PURE__ */ jsxs69(Fragment72, { children: [
+  return /* @__PURE__ */ jsxs70(Fragment72, { children: [
     /* @__PURE__ */ jsx177(
       Cuboid46,
       {
@@ -25087,10 +25565,10 @@ var SOD323FL = () => {
 
 // lib/AxialCapacitor.tsx
 import { Colorize as Colorize92, Cylinder as Cylinder15, Rotate as Rotate13, Sphere as Sphere2, Translate as Translate34 } from "jscad-fiber";
-import { Fragment as Fragment73, jsx as jsx178, jsxs as jsxs70 } from "react/jsx-runtime";
+import { Fragment as Fragment73, jsx as jsx178, jsxs as jsxs71 } from "react/jsx-runtime";
 var AxialCapacitor = ({ pitch = 10 }) => {
   const heightToCenterOfCapacitor = 0.5 + 4 / 2;
-  return /* @__PURE__ */ jsxs70(Fragment73, { children: [
+  return /* @__PURE__ */ jsxs71(Fragment73, { children: [
     /* @__PURE__ */ jsx178(Cylinder15, { height: 4, radius: 0.5, center: [-pitch / 2, 0, 0.5] }),
     /* @__PURE__ */ jsx178(
       Sphere2,
@@ -25099,7 +25577,7 @@ var AxialCapacitor = ({ pitch = 10 }) => {
         center: [-pitch / 2, 0, heightToCenterOfCapacitor]
       }
     ),
-    /* @__PURE__ */ jsx178(Translate34, { x: -2.5, y: 0, z: heightToCenterOfCapacitor, children: /* @__PURE__ */ jsxs70(Rotate13, { rotation: [0, Math.PI / 2, 0], children: [
+    /* @__PURE__ */ jsx178(Translate34, { x: -2.5, y: 0, z: heightToCenterOfCapacitor, children: /* @__PURE__ */ jsxs71(Rotate13, { rotation: [0, Math.PI / 2, 0], children: [
       /* @__PURE__ */ jsx178(
         Cylinder15,
         {
@@ -25123,8 +25601,8 @@ var AxialCapacitor = ({ pitch = 10 }) => {
 };
 
 // lib/stampboard.tsx
-import { Colorize as Colorize93, Cuboid as Cuboid47, Cylinder as Cylinder16, Subtract as Subtract12, Union as Union21 } from "jscad-fiber";
-import { Fragment as Fragment74, jsx as jsx179, jsxs as jsxs71 } from "react/jsx-runtime";
+import { Colorize as Colorize93, Cuboid as Cuboid47, Cylinder as Cylinder16, Subtract as Subtract13, Union as Union21 } from "jscad-fiber";
+import { Fragment as Fragment74, jsx as jsx179, jsxs as jsxs72 } from "react/jsx-runtime";
 var StampBoard = ({
   bodyWidth = 21,
   boardThickness = 0.5,
@@ -25222,7 +25700,7 @@ var StampBoard = ({
       }
     }
   }
-  const boardBody = /* @__PURE__ */ jsx179(Colorize93, { color: "#051a0a", children: /* @__PURE__ */ jsxs71(Subtract12, { children: [
+  const boardBody = /* @__PURE__ */ jsx179(Colorize93, { color: "#051a0a", children: /* @__PURE__ */ jsxs72(Subtract13, { children: [
     /* @__PURE__ */ jsx179(
       Cuboid47,
       {
@@ -25257,9 +25735,9 @@ var StampBoard = ({
     },
     index
   ));
-  return /* @__PURE__ */ jsxs71(Fragment74, { children: [
+  return /* @__PURE__ */ jsxs72(Fragment74, { children: [
     boardBody,
-    /* @__PURE__ */ jsx179(Colorize93, { color: "#FFD700", children: innerHoles ? /* @__PURE__ */ jsxs71(Subtract12, { children: [
+    /* @__PURE__ */ jsx179(Colorize93, { color: "#FFD700", children: innerHoles ? /* @__PURE__ */ jsxs72(Subtract13, { children: [
       /* @__PURE__ */ jsx179(Union21, { children: pads.map((pad, index) => /* @__PURE__ */ jsx179(
         Cuboid47,
         {
@@ -25274,8 +25752,8 @@ var StampBoard = ({
 };
 
 // lib/MountedPcbModule.tsx
-import { Colorize as Colorize94, Cuboid as Cuboid48, Cylinder as Cylinder17, Subtract as Subtract13 } from "jscad-fiber";
-import { Fragment as Fragment75, jsx as jsx180, jsxs as jsxs72 } from "react/jsx-runtime";
+import { Colorize as Colorize94, Cuboid as Cuboid48, Cylinder as Cylinder17, Subtract as Subtract14 } from "jscad-fiber";
+import { Fragment as Fragment75, jsx as jsx180, jsxs as jsxs73 } from "react/jsx-runtime";
 var MountedPcbModule = ({
   numPins = 5,
   rows = 1,
@@ -25376,7 +25854,7 @@ var MountedPcbModule = ({
   const shortSidePinLength = 3;
   const boardOffsetZ = nopin || female ? 0 : pinBodyHeight;
   const boardTopZ = boardOffsetZ + boardThickness;
-  const boardBody = /* @__PURE__ */ jsx180(Colorize94, { color: "#008080", children: /* @__PURE__ */ jsxs72(Subtract13, { children: [
+  const boardBody = /* @__PURE__ */ jsx180(Colorize94, { color: "#008080", children: /* @__PURE__ */ jsxs73(Subtract14, { children: [
     /* @__PURE__ */ jsx180(
       Cuboid48,
       {
@@ -25403,7 +25881,7 @@ var MountedPcbModule = ({
       `pin-hole-${index}`
     ))
   ] }) });
-  const platedHoles = pins.map((pin, index) => /* @__PURE__ */ jsx180(Colorize94, { color: "#FFD700", children: /* @__PURE__ */ jsxs72(Subtract13, { children: [
+  const platedHoles = pins.map((pin, index) => /* @__PURE__ */ jsx180(Colorize94, { color: "#FFD700", children: /* @__PURE__ */ jsxs73(Subtract14, { children: [
     /* @__PURE__ */ jsx180(
       Cylinder17,
       {
@@ -25443,7 +25921,7 @@ var MountedPcbModule = ({
     },
     `female-pin-3d-${index}`
   ));
-  return /* @__PURE__ */ jsxs72(Fragment75, { children: [
+  return /* @__PURE__ */ jsxs73(Fragment75, { children: [
     boardBody,
     platedHoles,
     !female && !nopin && headerPins,
@@ -25465,7 +25943,7 @@ var MountedPcbModule = ({
 
 // lib/SOD723.tsx
 import { Colorize as Colorize95, Cuboid as Cuboid49, Hull as Hull27, Translate as Translate35, Union as Union22 } from "jscad-fiber";
-import { Fragment as Fragment76, jsx as jsx181, jsxs as jsxs73 } from "react/jsx-runtime";
+import { Fragment as Fragment76, jsx as jsx181, jsxs as jsxs74 } from "react/jsx-runtime";
 var SOD723 = () => {
   const fullWidth = 1.4;
   const bodyLength10 = 0.6;
@@ -25478,7 +25956,7 @@ var SOD723 = () => {
   const rightPadCenterX = bodyWidth / 2 - padLength / 2 + 0.15;
   const taperOffset = 0.2;
   const straightHeight = bodyHeight * 0.24;
-  return /* @__PURE__ */ jsxs73(Fragment76, { children: [
+  return /* @__PURE__ */ jsxs74(Fragment76, { children: [
     /* @__PURE__ */ jsx181(
       Cuboid49,
       {
@@ -25495,9 +25973,9 @@ var SOD723 = () => {
         center: [rightPadCenterX, 0, padThickness / 2]
       }
     ),
-    /* @__PURE__ */ jsx181(Colorize95, { color: "#222", children: /* @__PURE__ */ jsxs73(Union22, { children: [
+    /* @__PURE__ */ jsx181(Colorize95, { color: "#222", children: /* @__PURE__ */ jsxs74(Union22, { children: [
       /* @__PURE__ */ jsx181(Translate35, { z: straightHeight / 2, children: /* @__PURE__ */ jsx181(Cuboid49, { size: [bodyWidth, bodyLength10, straightHeight] }) }),
-      /* @__PURE__ */ jsxs73(Hull27, { children: [
+      /* @__PURE__ */ jsxs74(Hull27, { children: [
         /* @__PURE__ */ jsx181(Translate35, { z: straightHeight, children: /* @__PURE__ */ jsx181(Cuboid49, { size: [bodyWidth, bodyLength10, 0.01] }) }),
         /* @__PURE__ */ jsx181(Translate35, { z: bodyHeight, children: /* @__PURE__ */ jsx181(
           Cuboid49,
@@ -25525,10 +26003,10 @@ import {
   Cuboid as Cuboid50,
   Cylinder as Cylinder18,
   Rotate as Rotate14,
-  Subtract as Subtract14,
+  Subtract as Subtract15,
   Translate as Translate36
 } from "jscad-fiber";
-import { Fragment as Fragment77, jsx as jsx182, jsxs as jsxs74 } from "react/jsx-runtime";
+import { Fragment as Fragment77, jsx as jsx182, jsxs as jsxs75 } from "react/jsx-runtime";
 var JSTZH1_5mm = ({
   numPins = 7,
   showPins = true,
@@ -25544,13 +26022,13 @@ var JSTZH1_5mm = ({
   const pinLength = 6;
   const bodyWidth = (numPins - 1) * pitch + 4;
   const startX = -((numPins - 1) * pitch) / 2;
-  return /* @__PURE__ */ jsxs74(Fragment77, { children: [
+  return /* @__PURE__ */ jsxs75(Fragment77, { children: [
     /* @__PURE__ */ jsx182(Translate36, { offset: [0, 0, bodyHeight], children: /* @__PURE__ */ jsx182(Rotate14, { angles: [Math.PI, 0, 0], children: /* @__PURE__ */ jsx182(
       Colorize96,
       {
         material: componentMaterials.moldedPlastic,
         color: bodyColor,
-        children: /* @__PURE__ */ jsxs74(Subtract14, { children: [
+        children: /* @__PURE__ */ jsxs75(Subtract15, { children: [
           /* @__PURE__ */ jsx182(
             Cuboid50,
             {
@@ -25702,10 +26180,10 @@ import {
   Cuboid as Cuboid51,
   Cylinder as Cylinder19,
   Rotate as Rotate15,
-  Subtract as Subtract15,
+  Subtract as Subtract16,
   Translate as Translate37
 } from "jscad-fiber";
-import { Fragment as Fragment78, jsx as jsx183, jsxs as jsxs75 } from "react/jsx-runtime";
+import { Fragment as Fragment78, jsx as jsx183, jsxs as jsxs76 } from "react/jsx-runtime";
 var JSTPH2_0mm = ({
   numPins = 2,
   showPins = true,
@@ -25729,13 +26207,13 @@ var JSTPH2_0mm = ({
   const latchWindowInset = 0.7;
   const topReliefWidth = 0.8;
   const topReliefDepth = 0.65;
-  return /* @__PURE__ */ jsxs75(Fragment78, { children: [
+  return /* @__PURE__ */ jsxs76(Fragment78, { children: [
     /* @__PURE__ */ jsx183(Translate37, { offset: [0, 0, bodyHeight], children: /* @__PURE__ */ jsx183(Rotate15, { angles: [Math.PI, 0, 0], children: /* @__PURE__ */ jsx183(
       Colorize97,
       {
         color: bodyColor,
         material: componentMaterials.moldedPlastic,
-        children: /* @__PURE__ */ jsxs75(Subtract15, { children: [
+        children: /* @__PURE__ */ jsxs76(Subtract16, { children: [
           /* @__PURE__ */ jsx183(
             Cuboid51,
             {
@@ -25903,9 +26381,9 @@ var JSTPH2_0mm = ({
 };
 
 // lib/JSTXH2_5mm.tsx
-import { Colorize as Colorize98, Cuboid as Cuboid52, Subtract as Subtract16, Translate as Translate38 } from "jscad-fiber";
+import { Colorize as Colorize98, Cuboid as Cuboid52, Subtract as Subtract17, Translate as Translate38 } from "jscad-fiber";
 import { fp as fp3 } from "@tscircuit/footprinter";
-import { Fragment as Fragment79, jsx as jsx184, jsxs as jsxs76 } from "react/jsx-runtime";
+import { Fragment as Fragment79, jsx as jsx184, jsxs as jsxs77 } from "react/jsx-runtime";
 var JSTXH2_5mm = ({
   numPins = 4,
   showPins = true,
@@ -25933,8 +26411,8 @@ var JSTXH2_5mm = ({
     Math.max(3, (numPins - 1) * pitch * 0.4 + 2.2)
   );
   const lockNotchHeight = 2.4;
-  return /* @__PURE__ */ jsxs76(Fragment79, { children: [
-    /* @__PURE__ */ jsx184(Translate38, { offset: [0, 0, bodyHeight / 2], children: /* @__PURE__ */ jsx184(Colorize98, { material: componentMaterials.moldedPlastic, color: bodyColor, children: /* @__PURE__ */ jsxs76(Subtract16, { children: [
+  return /* @__PURE__ */ jsxs77(Fragment79, { children: [
+    /* @__PURE__ */ jsx184(Translate38, { offset: [0, 0, bodyHeight / 2], children: /* @__PURE__ */ jsx184(Colorize98, { material: componentMaterials.moldedPlastic, color: bodyColor, children: /* @__PURE__ */ jsxs77(Subtract17, { children: [
       /* @__PURE__ */ jsx184(Cuboid52, { size: [bodyWidth, bodyDepth, bodyHeight] }),
       /* @__PURE__ */ jsx184(Translate38, { offset: [0, 0, (bodyHeight - hollowHeight) / 2 + 0.1], children: /* @__PURE__ */ jsx184(
         Cuboid52,
@@ -26067,8 +26545,8 @@ var mm2 = (n) => {
 };
 
 // lib/JstSh.tsx
-import { Colorize as Colorize99, Cuboid as Cuboid53, Rotate as Rotate16, Subtract as Subtract17, Union as Union23 } from "jscad-fiber";
-import { jsx as jsx185, jsxs as jsxs77 } from "react/jsx-runtime";
+import { Colorize as Colorize99, Cuboid as Cuboid53, Rotate as Rotate16, Subtract as Subtract18, Union as Union23 } from "jscad-fiber";
+import { jsx as jsx185, jsxs as jsxs78 } from "react/jsx-runtime";
 function isJstShFootprint(footprint) {
   const p = fp4.string(footprint).json();
   if (p.fn !== "jst") return false;
@@ -26096,8 +26574,8 @@ var JstSh = ({ footprint = "jst6_sh" }) => {
   const direction = mounts[0].y > rowY ? 1 : -1;
   const y = rowY + direction * 1.8, width10 = n + 2, depth = 2.9, height10 = 4.2;
   const pinY = y - direction * 0.25;
-  return /* @__PURE__ */ jsxs77(Rotate16, { rotation: [0, 0, angle], children: [
-    /* @__PURE__ */ jsx185(Colorize99, { material: componentMaterials.moldedPlastic, color: "#e4e1d6", children: /* @__PURE__ */ jsxs77(Subtract17, { children: [
+  return /* @__PURE__ */ jsxs78(Rotate16, { rotation: [0, 0, angle], children: [
+    /* @__PURE__ */ jsx185(Colorize99, { material: componentMaterials.moldedPlastic, color: "#e4e1d6", children: /* @__PURE__ */ jsxs78(Subtract18, { children: [
       /* @__PURE__ */ jsx185(
         Cuboid53,
         {
@@ -26133,10 +26611,10 @@ var JstSh = ({ footprint = "jst6_sh" }) => {
         side
       ))
     ] }) }),
-    /* @__PURE__ */ jsxs77(Colorize99, { material: componentMaterials.tinnedLead, color: "#c6c7c9", children: [
+    /* @__PURE__ */ jsxs78(Colorize99, { material: componentMaterials.tinnedLead, color: "#c6c7c9", children: [
       signals.map((pad, i) => {
         const tailY = pad.y - direction * pad.height * 0.4;
-        return /* @__PURE__ */ jsxs77(Union23, { children: [
+        return /* @__PURE__ */ jsxs78(Union23, { children: [
           /* @__PURE__ */ jsx185(
             Cuboid53,
             {
@@ -26147,7 +26625,7 @@ var JstSh = ({ footprint = "jst6_sh" }) => {
           /* @__PURE__ */ jsx185(Cuboid53, { size: [0.2, 0.2, 3.45], center: [pad.x, pinY, 1.725] })
         ] }, i);
       }),
-      mounts.map((pad, i) => /* @__PURE__ */ jsxs77(Union23, { children: [
+      mounts.map((pad, i) => /* @__PURE__ */ jsxs78(Union23, { children: [
         /* @__PURE__ */ jsx185(
           Cuboid53,
           {
@@ -26174,10 +26652,10 @@ import {
   Cylinder as Cylinder20,
   Rotate as Rotate17,
   RoundedCuboid as RoundedCuboid5,
-  Subtract as Subtract18,
+  Subtract as Subtract19,
   Translate as Translate39
 } from "jscad-fiber";
-import { Fragment as Fragment80, jsx as jsx186, jsxs as jsxs78 } from "react/jsx-runtime";
+import { Fragment as Fragment80, jsx as jsx186, jsxs as jsxs79 } from "react/jsx-runtime";
 var HOUSING_COLOR = "#303339";
 var HOUSING_SHADOW = "#1f2227";
 var ACTUATOR_COLOR = "#eee8d8";
@@ -26264,7 +26742,7 @@ var FPC = ({
   const clipCapX = bodyWidth / 2 - 0.23;
   const sideBossX = bodyWidth / 2 - 0.32;
   const sideBossWidth = 0.68;
-  return /* @__PURE__ */ jsxs78(Fragment80, { children: [
+  return /* @__PURE__ */ jsxs79(Fragment80, { children: [
     [-1, 1].map((direction) => /* @__PURE__ */ jsx186(
       Cuboid54,
       {
@@ -26292,7 +26770,7 @@ var FPC = ({
         roundRadius: 0.1
       }
     ),
-    /* @__PURE__ */ jsx186(Colorize100, { color: HOUSING_COLOR, children: /* @__PURE__ */ jsxs78(Subtract18, { children: [
+    /* @__PURE__ */ jsx186(Colorize100, { color: HOUSING_COLOR, children: /* @__PURE__ */ jsxs79(Subtract19, { children: [
       /* @__PURE__ */ jsx186(
         RoundedCuboid5,
         {
@@ -26444,7 +26922,7 @@ var FPC = ({
 
 // lib/SmdPinHeader.tsx
 import { Colorize as Colorize101, Cuboid as Cuboid55, Hull as Hull28, Translate as Translate40 } from "jscad-fiber";
-import { Fragment as Fragment81, jsx as jsx187, jsxs as jsxs79 } from "react/jsx-runtime";
+import { Fragment as Fragment81, jsx as jsx187, jsxs as jsxs80 } from "react/jsx-runtime";
 var SmdPinHeader = ({
   numberOfPins,
   pitch = 2.54,
@@ -26464,7 +26942,7 @@ var SmdPinHeader = ({
     const tailDirection = index % 2 === 0 ? 1 : -1;
     const postBodyLength = matingPinLength - tipChamferHeight;
     const verticalTailLength = standoffHeight - pinThickness / 2;
-    return /* @__PURE__ */ jsxs79(Translate40, { x, children: [
+    return /* @__PURE__ */ jsxs80(Translate40, { x, children: [
       /* @__PURE__ */ jsx187(
         Cuboid55,
         {
@@ -26473,7 +26951,7 @@ var SmdPinHeader = ({
           center: [0, 0, standoffHeight + bodyHeight / 2]
         }
       ),
-      /* @__PURE__ */ jsxs79(Colorize101, { color: "#d4af37", children: [
+      /* @__PURE__ */ jsxs80(Colorize101, { color: "#d4af37", children: [
         /* @__PURE__ */ jsx187(
           Cuboid55,
           {
@@ -26495,7 +26973,7 @@ var SmdPinHeader = ({
             center: [0, 0, bodyTop + postBodyLength / 2]
           }
         ),
-        /* @__PURE__ */ jsxs79(Hull28, { children: [
+        /* @__PURE__ */ jsxs80(Hull28, { children: [
           /* @__PURE__ */ jsx187(
             Cuboid55,
             {
@@ -26545,7 +27023,7 @@ var getSmtPadRects = (footprint) => {
 };
 
 // lib/GullWingBody.tsx
-import { Fragment as Fragment82, jsx as jsx188, jsxs as jsxs80 } from "react/jsx-runtime";
+import { Fragment as Fragment82, jsx as jsx188, jsxs as jsxs81 } from "react/jsx-runtime";
 var GullWingBody = ({
   bodyWidth,
   bodyLength: bodyLength10,
@@ -26557,7 +27035,7 @@ var GullWingBody = ({
   const centerX = pads.reduce((sum, pad) => sum + pad.x, 0) / (pads.length || 1);
   const centerY = pads.reduce((sum, pad) => sum + pad.y, 0) / (pads.length || 1);
   const leadHeight = bodyHeight * leadHeightRatio;
-  return /* @__PURE__ */ jsxs80(Fragment82, { children: [
+  return /* @__PURE__ */ jsxs81(Fragment82, { children: [
     /* @__PURE__ */ jsx188(
       ChipBody,
       {
@@ -26597,7 +27075,7 @@ var GullWingBody = ({
 
 // lib/ParametricChip.tsx
 import { Cuboid as Cuboid56 } from "jscad-fiber";
-import { Fragment as Fragment83, jsx as jsx189, jsxs as jsxs81 } from "react/jsx-runtime";
+import { Fragment as Fragment83, jsx as jsx189, jsxs as jsxs82 } from "react/jsx-runtime";
 var ParametricChip = ({
   padPitch,
   padHeight,
@@ -26608,7 +27086,7 @@ var ParametricChip = ({
   const height10 = width10;
   const terminatorWidth9 = fullLength10 * 0.2;
   const bodyLength10 = fullLength10 - terminatorWidth9 * 2;
-  return /* @__PURE__ */ jsxs81(Fragment83, { children: [
+  return /* @__PURE__ */ jsxs82(Fragment83, { children: [
     /* @__PURE__ */ jsx189(
       Cuboid56,
       {
@@ -26645,10 +27123,10 @@ import {
   Cuboid as Cuboid57,
   Cylinder as Cylinder21,
   Rotate as Rotate18,
-  Subtract as Subtract19,
+  Subtract as Subtract20,
   Translate as Translate41
 } from "jscad-fiber";
-import { Fragment as Fragment84, jsx as jsx190, jsxs as jsxs82 } from "react/jsx-runtime";
+import { Fragment as Fragment84, jsx as jsx190, jsxs as jsxs83 } from "react/jsx-runtime";
 var Led5050 = ({
   color = "#ffff00",
   bodyColor = "#ffffff",
@@ -26669,7 +27147,7 @@ var Led5050 = ({
   const cornerCutDepth = 0.3;
   const leadYPositions = [-1.7, 0, 1.7];
   const leadSides = [-1, 1];
-  return /* @__PURE__ */ jsxs82(Fragment84, { children: [
+  return /* @__PURE__ */ jsxs83(Fragment84, { children: [
     leadYPositions.flatMap(
       (y) => leadSides.map((side) => /* @__PURE__ */ jsx190(
         Cuboid57,
@@ -26681,7 +27159,7 @@ var Led5050 = ({
         `${side}-${y}`
       ))
     ),
-    /* @__PURE__ */ jsx190(Colorize102, { color: bodyColor, children: /* @__PURE__ */ jsxs82(Subtract19, { children: [
+    /* @__PURE__ */ jsx190(Colorize102, { color: bodyColor, children: /* @__PURE__ */ jsxs83(Subtract20, { children: [
       /* @__PURE__ */ jsx190(
         ChipBody,
         {
@@ -26730,7 +27208,7 @@ var Led5050 = ({
 
 // lib/Led2835.tsx
 import { Colorize as Colorize103, Cuboid as Cuboid58 } from "jscad-fiber";
-import { Fragment as Fragment85, jsx as jsx191, jsxs as jsxs83 } from "react/jsx-runtime";
+import { Fragment as Fragment85, jsx as jsx191, jsxs as jsxs84 } from "react/jsx-runtime";
 var Led2835 = ({
   bodyWidth = 3.5,
   bodyLength: bodyLength10 = 2.8,
@@ -26749,7 +27227,7 @@ var Led2835 = ({
   const bodyCenterX = (pad1X + pad2X) / 2;
   const lensWidth = bodyWidth * 0.55;
   const lensLength = bodyLength10 * 0.55;
-  return /* @__PURE__ */ jsxs83(Fragment85, { children: [
+  return /* @__PURE__ */ jsxs84(Fragment85, { children: [
     [
       { x: pad1X, w: pad1Width, key: "pad-1" },
       { x: pad2X, w: pad2Width, key: "pad-2" }
@@ -26788,10 +27266,10 @@ import {
   Cylinder as Cylinder22,
   Rotate as Rotate19,
   RoundedCuboid as RoundedCuboid6,
-  Subtract as Subtract20,
+  Subtract as Subtract21,
   Translate as Translate42
 } from "jscad-fiber";
-import { Fragment as Fragment86, jsx as jsx192, jsxs as jsxs84 } from "react/jsx-runtime";
+import { Fragment as Fragment86, jsx as jsx192, jsxs as jsxs85 } from "react/jsx-runtime";
 var range2 = (length32) => Array.from({ length: length32 }, (_, index) => index);
 var RJ45 = ({
   bodyWidth = 16.26,
@@ -26849,9 +27327,9 @@ var RJ45 = ({
   const contactY = frontY - frontDirection * Math.max(cavityDepth * 0.48, 1.2);
   const contactZ = openingCenterZ + openingHeight * 0.18;
   const frontLipY = frontY + frontDirection * shellThickness * 0.2;
-  return /* @__PURE__ */ jsxs84(Fragment86, { children: [
-    /* @__PURE__ */ jsxs84(Colorize104, { color: shellColor, children: [
-      /* @__PURE__ */ jsxs84(Subtract20, { children: [
+  return /* @__PURE__ */ jsxs85(Fragment86, { children: [
+    /* @__PURE__ */ jsxs85(Colorize104, { color: shellColor, children: [
+      /* @__PURE__ */ jsxs85(Subtract21, { children: [
         /* @__PURE__ */ jsx192(
           Cuboid59,
           {
@@ -26903,8 +27381,8 @@ var RJ45 = ({
         `top-seam:${direction}`
       ))
     ] }),
-    /* @__PURE__ */ jsxs84(Colorize104, { color: housingColor, children: [
-      /* @__PURE__ */ jsxs84(Subtract20, { children: [
+    /* @__PURE__ */ jsxs85(Colorize104, { color: housingColor, children: [
+      /* @__PURE__ */ jsxs85(Subtract21, { children: [
         /* @__PURE__ */ jsx192(
           RoundedCuboid6,
           {
@@ -26958,7 +27436,7 @@ var RJ45 = ({
         `locator:${direction}`
       ))
     ] }),
-    /* @__PURE__ */ jsxs84(Colorize104, { color: contactColor, children: [
+    /* @__PURE__ */ jsxs85(Colorize104, { color: contactColor, children: [
       signalPinPositions.map(({ x, y }, index) => /* @__PURE__ */ jsx192(
         Cylinder22,
         {
@@ -26996,7 +27474,7 @@ var RJ45 = ({
         `led-lead:${index}`
       ))
     ] }),
-    ledPins && /* @__PURE__ */ jsxs84(Fragment86, { children: [
+    ledPins && /* @__PURE__ */ jsxs85(Fragment86, { children: [
       /* @__PURE__ */ jsx192(
         RoundedCuboid6,
         {
@@ -27029,7 +27507,7 @@ var RJ45 = ({
 
 // lib/DPAK.tsx
 import { Colorize as Colorize105, Cuboid as Cuboid60, Hull as Hull29 } from "jscad-fiber";
-import { Fragment as Fragment87, jsx as jsx193, jsxs as jsxs85 } from "react/jsx-runtime";
+import { Fragment as Fragment87, jsx as jsx193, jsxs as jsxs86 } from "react/jsx-runtime";
 var DPAK = ({
   bodyWidth = 6.1,
   bodyLength: bodyLength10 = 6.5,
@@ -27051,7 +27529,7 @@ var DPAK = ({
   const bodyFrontX = bodyCenterX - bodyWidth / 2;
   const leadZ = tabThickness / 2;
   const leadThickness = 0.4;
-  return /* @__PURE__ */ jsxs85(Fragment87, { children: [
+  return /* @__PURE__ */ jsxs86(Fragment87, { children: [
     /* @__PURE__ */ jsx193(Colorize105, { material: componentMaterials.tinnedLead, color: tabColor, children: /* @__PURE__ */ jsx193(
       Cuboid60,
       {
@@ -27067,7 +27545,7 @@ var DPAK = ({
       }
     ) }),
     [-1, 1].map((side) => {
-      return /* @__PURE__ */ jsxs85(
+      return /* @__PURE__ */ jsxs86(
         Colorize105,
         {
           material: componentMaterials.tinnedLead,
@@ -27084,7 +27562,7 @@ var DPAK = ({
                 ]
               }
             ),
-            /* @__PURE__ */ jsxs85(Hull29, { children: [
+            /* @__PURE__ */ jsxs86(Hull29, { children: [
               /* @__PURE__ */ jsx193(
                 Cuboid60,
                 {
@@ -27118,9 +27596,9 @@ import {
   Cuboid as Cuboid61,
   Cylinder as Cylinder23,
   RoundedCylinder as RoundedCylinder5,
-  Subtract as Subtract21
+  Subtract as Subtract22
 } from "jscad-fiber";
-import { Fragment as Fragment88, jsx as jsx194, jsxs as jsxs86 } from "react/jsx-runtime";
+import { Fragment as Fragment88, jsx as jsx194, jsxs as jsxs87 } from "react/jsx-runtime";
 var ElectrolyticCapacitor = ({
   diameter = 6.3,
   heightToDiameterRatio = 1.4,
@@ -27138,7 +27616,7 @@ var ElectrolyticCapacitor = ({
   const canTop = canBottom + canHeight;
   const grooveWidth = Math.max(diameter * 0.06, 0.2);
   const grooveDepth = 0.3;
-  return /* @__PURE__ */ jsxs86(Fragment88, { children: [
+  return /* @__PURE__ */ jsxs87(Fragment88, { children: [
     /* @__PURE__ */ jsx194(Colorize106, { color: baseColor, material: componentMaterials.rubber, children: /* @__PURE__ */ jsx194(
       Cylinder23,
       {
@@ -27147,7 +27625,7 @@ var ElectrolyticCapacitor = ({
         center: [0, 0, baseHeight / 2]
       }
     ) }),
-    /* @__PURE__ */ jsx194(Colorize106, { color: sleeveColor, material: componentMaterials.sleeve, children: /* @__PURE__ */ jsxs86(Subtract21, { children: [
+    /* @__PURE__ */ jsx194(Colorize106, { color: sleeveColor, material: componentMaterials.sleeve, children: /* @__PURE__ */ jsxs87(Subtract22, { children: [
       /* @__PURE__ */ jsx194(
         RoundedCylinder5,
         {
@@ -27192,8 +27670,8 @@ var ElectrolyticCapacitor = ({
 };
 
 // lib/Potentiometer.tsx
-import { Colorize as Colorize107, Cuboid as Cuboid62, Cylinder as Cylinder24, Subtract as Subtract22 } from "jscad-fiber";
-import { Fragment as Fragment89, jsx as jsx195, jsxs as jsxs87 } from "react/jsx-runtime";
+import { Colorize as Colorize107, Cuboid as Cuboid62, Cylinder as Cylinder24, Subtract as Subtract23 } from "jscad-fiber";
+import { Fragment as Fragment89, jsx as jsx195, jsxs as jsxs88 } from "react/jsx-runtime";
 var Potentiometer = ({
   bodyWidth = 5.35,
   bodyLength: bodyLength10 = 14,
@@ -27211,7 +27689,7 @@ var Potentiometer = ({
   const adjusterHeight = 0.8;
   const adjusterZ = bodyHeight + adjusterHeight / 2;
   const slotWidth = Math.max(adjusterDiameter * 0.16, 0.3);
-  return /* @__PURE__ */ jsxs87(Fragment89, { children: [
+  return /* @__PURE__ */ jsxs88(Fragment89, { children: [
     /* @__PURE__ */ jsx195(Colorize107, { color: bodyColor, children: /* @__PURE__ */ jsx195(
       Cuboid62,
       {
@@ -27219,7 +27697,7 @@ var Potentiometer = ({
         center: [bodyCenterX, 0, bodyHeight / 2]
       }
     ) }),
-    /* @__PURE__ */ jsx195(Colorize107, { color: adjusterColor, children: /* @__PURE__ */ jsxs87(Subtract22, { children: [
+    /* @__PURE__ */ jsx195(Colorize107, { color: adjusterColor, children: /* @__PURE__ */ jsxs88(Subtract23, { children: [
       /* @__PURE__ */ jsx195(
         Cylinder24,
         {
@@ -27257,7 +27735,7 @@ var Potentiometer = ({
 
 // lib/SmdPushButton.tsx
 import { Colorize as Colorize108, Cuboid as Cuboid63, Cylinder as Cylinder25 } from "jscad-fiber";
-import { Fragment as Fragment90, jsx as jsx196, jsxs as jsxs88 } from "react/jsx-runtime";
+import { Fragment as Fragment90, jsx as jsx196, jsxs as jsxs89 } from "react/jsx-runtime";
 var SmdPushButton = ({
   bodyWidth = 2.9,
   bodyLength: bodyLength10 = 3,
@@ -27273,7 +27751,7 @@ var SmdPushButton = ({
   leadColor = "#cccccc"
 }) => {
   const leadThickness = 0.15;
-  return /* @__PURE__ */ jsxs88(Fragment90, { children: [
+  return /* @__PURE__ */ jsxs89(Fragment90, { children: [
     /* @__PURE__ */ jsx196(Colorize108, { color: bodyColor, children: /* @__PURE__ */ jsx196(
       Cuboid63,
       {
@@ -27307,8 +27785,8 @@ var SmdPushButton = ({
 
 // lib/SmdSlideSwitch.tsx
 import { fp as fp7 } from "@tscircuit/footprinter";
-import { Colorize as Colorize109, Cuboid as Cuboid64, Cylinder as Cylinder26, Rotate as Rotate20, Subtract as Subtract23 } from "jscad-fiber";
-import { jsx as jsx197, jsxs as jsxs89 } from "react/jsx-runtime";
+import { Colorize as Colorize109, Cuboid as Cuboid64, Cylinder as Cylinder26, Rotate as Rotate20, Subtract as Subtract24 } from "jscad-fiber";
+import { jsx as jsx197, jsxs as jsxs90 } from "react/jsx-runtime";
 var SmdSlideSwitch = ({
   footprint = "smdslideswitch7",
   position = 0
@@ -27326,8 +27804,8 @@ var SmdSlideSwitch = ({
     throw new Error("SmdSlideSwitch needs signal pads and four mounting pads");
   const angle = Math.atan2(target[1].y - target[0].y, target[1].x - target[0].x) - Math.atan2(pads[1].y - pads[0].y, pads[1].x - pads[0].x);
   const width10 = params.mpx - 0.5, depth = 2.7, height10 = params.mpx > 6 ? 1.5 : 1.4, y = params.mounty;
-  return /* @__PURE__ */ jsxs89(Rotate20, { rotation: [0, 0, angle], children: [
-    /* @__PURE__ */ jsx197(Colorize109, { color: "#aeb4ba", children: /* @__PURE__ */ jsxs89(Subtract23, { children: [
+  return /* @__PURE__ */ jsxs90(Rotate20, { rotation: [0, 0, angle], children: [
+    /* @__PURE__ */ jsx197(Colorize109, { color: "#aeb4ba", children: /* @__PURE__ */ jsxs90(Subtract24, { children: [
       /* @__PURE__ */ jsx197(Cuboid64, { size: [width10, depth, height10], center: [0, y, height10 / 2] }),
       /* @__PURE__ */ jsx197(
         Cuboid64,
@@ -27338,7 +27816,7 @@ var SmdSlideSwitch = ({
       ),
       /* @__PURE__ */ jsx197(Cuboid64, { size: [2.7, 0.5, 0.9], center: [0, y - depth / 2, 0.65] })
     ] }) }),
-    /* @__PURE__ */ jsxs89(Colorize109, { color: "#28292c", children: [
+    /* @__PURE__ */ jsxs90(Colorize109, { color: "#28292c", children: [
       /* @__PURE__ */ jsx197(
         Cuboid64,
         {
@@ -27387,7 +27865,7 @@ var SmdSlideSwitch = ({
 
 // lib/SOT-563.tsx
 import { Cuboid as Cuboid65, Translate as Translate44, Rotate as Rotate21, Colorize as Colorize110 } from "jscad-fiber";
-import { Fragment as Fragment91, jsx as jsx198, jsxs as jsxs90 } from "react/jsx-runtime";
+import { Fragment as Fragment91, jsx as jsx198, jsxs as jsxs91 } from "react/jsx-runtime";
 var SOT563 = ({ fullWidth = 1.94, fullLength: fullLength10 = 1.6 }) => {
   const bodyWidth = 1.2;
   const bodyLength10 = 1.6;
@@ -27397,7 +27875,7 @@ var SOT563 = ({ fullWidth = 1.94, fullLength: fullLength10 = 1.6 }) => {
   const leadHeight = 0.13;
   const leadSpacing = 0.5;
   const bodyZOffset = -0.4;
-  return /* @__PURE__ */ jsxs90(Fragment91, { children: [
+  return /* @__PURE__ */ jsxs91(Fragment91, { children: [
     /* @__PURE__ */ jsx198(Rotate21, { rotation: [45 * Math.PI, 0, 0], children: /* @__PURE__ */ jsx198(Translate44, { center: [0, 0, bodyZOffset], children: /* @__PURE__ */ jsx198(Colorize110, { color: "grey", children: /* @__PURE__ */ jsx198(Cuboid65, { size: [bodyWidth, bodyLength10, bodyHeight] }) }) }) }),
     [-1, 0, 1].flatMap((yOffset, index) => [
       // Left lead
@@ -27434,10 +27912,10 @@ import {
   Cylinder as Cylinder27,
   Hull as Hull30,
   Rotate as Rotate22,
-  Subtract as Subtract24,
+  Subtract as Subtract25,
   Translate as Translate45
 } from "jscad-fiber";
-import { jsx as jsx199, jsxs as jsxs91 } from "react/jsx-runtime";
+import { jsx as jsx199, jsxs as jsxs92 } from "react/jsx-runtime";
 var Capsule = ({
   width: width10,
   height: height10,
@@ -27465,8 +27943,8 @@ var UsbCMidmount = ({
       "UsbCMidmount requires four mounting slots and a positive body depth"
     );
   const tabBottom = -0.9, tabTop = centerZ + 0.1;
-  return /* @__PURE__ */ jsxs91(Rotate22, { rotation: [0, 0, angle], children: [
-    /* @__PURE__ */ jsx199(Colorize111, { color: "#b8bdc4", material: componentMaterials.brushedMetal, children: /* @__PURE__ */ jsx199(Translate45, { offset: [0, centerY, centerZ], children: /* @__PURE__ */ jsxs91(Subtract24, { children: [
+  return /* @__PURE__ */ jsxs92(Rotate22, { rotation: [0, 0, angle], children: [
+    /* @__PURE__ */ jsx199(Colorize111, { color: "#b8bdc4", material: componentMaterials.brushedMetal, children: /* @__PURE__ */ jsx199(Translate45, { offset: [0, centerY, centerZ], children: /* @__PURE__ */ jsxs92(Subtract25, { children: [
       /* @__PURE__ */ jsx199(Capsule, { width: width10, height: height10, depth }),
       /* @__PURE__ */ jsx199(
         Capsule,
@@ -27477,7 +27955,7 @@ var UsbCMidmount = ({
         }
       )
     ] }) }) }),
-    /* @__PURE__ */ jsxs91(Colorize111, { color: "#242529", material: componentMaterials.moldedPlastic, children: [
+    /* @__PURE__ */ jsxs92(Colorize111, { color: "#242529", material: componentMaterials.moldedPlastic, children: [
       /* @__PURE__ */ jsx199(
         Cuboid66,
         {
@@ -27498,7 +27976,7 @@ var UsbCMidmount = ({
         ) : null
       )
     ] }),
-    /* @__PURE__ */ jsxs91(Colorize111, { color: "#d3ad57", material: componentMaterials.goldContact, children: [
+    /* @__PURE__ */ jsxs92(Colorize111, { color: "#d3ad57", material: componentMaterials.goldContact, children: [
       [-1, 1].flatMap(
         (side) => [-2.75, -2.25, -1.25, -0.25, 0.25, 1.25, 2.25, 2.75].map((x) => /* @__PURE__ */ jsx199(
           Cuboid66,
@@ -27540,7 +28018,7 @@ var UsbCMidmount = ({
 // lib/SOT143.tsx
 import { fp as fp9 } from "@tscircuit/footprinter";
 import { Rotate as Rotate23 } from "jscad-fiber";
-import { jsx as jsx200, jsxs as jsxs92 } from "react/jsx-runtime";
+import { jsx as jsx200, jsxs as jsxs93 } from "react/jsx-runtime";
 var getPads = (footprint) => fp9.string(footprint).circuitJson().filter(
   (element) => element.type === "pcb_smtpad" && (element.shape === "rect" || element.shape === "rotated_rect")
 ).map((pad) => ({ x: pad.x, y: pad.y, pin: pad.port_hints?.[0] }));
@@ -27559,7 +28037,7 @@ var SOT143 = ({ footprint = "sot143" }) => {
     x: pad.x * Math.cos(angle) + pad.y * Math.sin(angle),
     y: -pad.x * Math.sin(angle) + pad.y * Math.cos(angle)
   }));
-  return /* @__PURE__ */ jsxs92(Rotate23, { rotation: [0, 0, angle], children: [
+  return /* @__PURE__ */ jsxs93(Rotate23, { rotation: [0, 0, angle], children: [
     /* @__PURE__ */ jsx200(
       ChipBody,
       {
@@ -28264,8 +28742,8 @@ var Footprinter3d = ({ footprint }) => {
 };
 
 // lib/utils/FlatLeadDiode.tsx
-import { Colorize as Colorize112, Cuboid as Cuboid67, Hull as Hull31, Subtract as Subtract25 } from "jscad-fiber";
-import { Fragment as Fragment93, jsx as jsx202, jsxs as jsxs93 } from "react/jsx-runtime";
+import { Colorize as Colorize112, Cuboid as Cuboid67, Hull as Hull31, Subtract as Subtract26 } from "jscad-fiber";
+import { Fragment as Fragment93, jsx as jsx202, jsxs as jsxs94 } from "react/jsx-runtime";
 function createFlatLeadDiode(p) {
   const dimensions5 = [
     "bodyLength",
@@ -28293,7 +28771,7 @@ function createFlatLeadDiode(p) {
       "Diode dimensions leave disconnected terminals or an invalid mold"
     );
   const slice = Math.min(p.bodyHeight - p.standoff, p.bodyWidth) / 100;
-  const body = /* @__PURE__ */ jsxs93(Hull31, { children: [
+  const body = /* @__PURE__ */ jsxs94(Hull31, { children: [
     /* @__PURE__ */ jsx202(
       Cuboid67,
       {
@@ -28324,12 +28802,12 @@ function createFlatLeadDiode(p) {
       ]
     }
   );
-  return /* @__PURE__ */ jsxs93(Fragment93, { children: [
-    /* @__PURE__ */ jsx202(Colorize112, { color: "#25272a", children: p.markingWidth > 0 ? /* @__PURE__ */ jsxs93(Subtract25, { children: [
+  return /* @__PURE__ */ jsxs94(Fragment93, { children: [
+    /* @__PURE__ */ jsx202(Colorize112, { color: "#25272a", children: p.markingWidth > 0 ? /* @__PURE__ */ jsxs94(Subtract26, { children: [
       body,
       stripe
     ] }) : body }),
-    /* @__PURE__ */ jsxs93(Colorize112, { color: "#c7c9cd", children: [
+    /* @__PURE__ */ jsxs94(Colorize112, { color: "#c7c9cd", children: [
       /* @__PURE__ */ jsx202(
         Cuboid67,
         {
@@ -28393,7 +28871,7 @@ var SOD323HE = (props) => createFlatLeadDiode({
 
 // lib/SOT89.tsx
 import { Colorize as Colorize113, Cuboid as Cuboid68, Translate as Translate47, Hull as Hull32, Union as Union24 } from "jscad-fiber";
-import { Fragment as Fragment94, jsx as jsx203, jsxs as jsxs94 } from "react/jsx-runtime";
+import { Fragment as Fragment94, jsx as jsx203, jsxs as jsxs95 } from "react/jsx-runtime";
 function SOT89(p) {
   for (const k of [
     "bodyWidth",
@@ -28415,8 +28893,8 @@ function SOT89(p) {
   const front = -p.bodyWidth / 2, rear = p.bodyWidth / 2 + p.rearExtension, tabFront = rear - p.tabLength;
   const slice = Math.min(2e-3, (p.bodyHeight - p.standoff) / 100);
   const block = (x, y, length32, width10) => /* @__PURE__ */ jsx203(Translate47, { offset: [x, y, p.terminalThickness / 2], children: /* @__PURE__ */ jsx203(Cuboid68, { size: [length32, width10, p.terminalThickness] }) });
-  return /* @__PURE__ */ jsxs94(Fragment94, { children: [
-    /* @__PURE__ */ jsx203(Colorize113, { color: "#353535", children: /* @__PURE__ */ jsxs94(Hull32, { children: [
+  return /* @__PURE__ */ jsxs95(Fragment94, { children: [
+    /* @__PURE__ */ jsx203(Colorize113, { color: "#353535", children: /* @__PURE__ */ jsxs95(Hull32, { children: [
       /* @__PURE__ */ jsx203(Translate47, { z: p.standoff + slice / 2, children: /* @__PURE__ */ jsx203(Cuboid68, { size: [p.bodyWidth, p.bodyLength, slice] }) }),
       /* @__PURE__ */ jsx203(Translate47, { z: p.bodyHeight - slice / 2, children: /* @__PURE__ */ jsx203(
         Cuboid68,
@@ -28437,7 +28915,7 @@ function SOT89(p) {
         p.leadWidth
       )
     ) }),
-    /* @__PURE__ */ jsx203(Colorize113, { color: "#bfc1c4", children: /* @__PURE__ */ jsxs94(Union24, { children: [
+    /* @__PURE__ */ jsx203(Colorize113, { color: "#bfc1c4", children: /* @__PURE__ */ jsxs95(Union24, { children: [
       block(
         (front - p.leadLength + tabFront + 0.15) / 2,
         0,
@@ -28451,7 +28929,7 @@ function SOT89(p) {
 
 // lib/TO277.tsx
 import { Colorize as Colorize114, Cuboid as Cuboid69, Translate as Translate48, Union as Union25 } from "jscad-fiber";
-import { Fragment as Fragment95, jsx as jsx204, jsxs as jsxs95 } from "react/jsx-runtime";
+import { Fragment as Fragment95, jsx as jsx204, jsxs as jsxs96 } from "react/jsx-runtime";
 function TO277(p) {
   for (const k of [
     "bodyWidth",
@@ -28475,7 +28953,7 @@ function TO277(p) {
   if (p.terminalThickness >= p.bodyHeight || p.terminalSpan < p.bodyWidth || p.pitch + p.leadWidth >= p.bodyLength || p.leadWidth >= p.pitch || front + p.leadLength >= tabFront || front + p.leadLength <= -p.bodyWidth / 2 || tabFront >= p.bodyWidth / 2 || p.tabNeckWidth > p.tabWidth || p.tabWidth > p.bodyLength || p.tabBarWidth < p.tabWidth || p.tabNeckLength + p.tabBarLength >= p.tabLength)
     throw new Error("Invalid TO-277 terminal geometry or clearance");
   const block = (x, y, length32, width10) => /* @__PURE__ */ jsx204(Translate48, { offset: [x, y, p.terminalThickness / 2], children: /* @__PURE__ */ jsx204(Cuboid69, { size: [length32, width10, p.terminalThickness] }) });
-  return /* @__PURE__ */ jsxs95(Fragment95, { children: [
+  return /* @__PURE__ */ jsxs96(Fragment95, { children: [
     /* @__PURE__ */ jsx204(Colorize114, { color: "#353535", children: /* @__PURE__ */ jsx204(Translate48, { z: (p.bodyHeight + p.terminalThickness / 2) / 2, children: /* @__PURE__ */ jsx204(
       Cuboid69,
       {
@@ -28494,7 +28972,7 @@ function TO277(p) {
         p.leadWidth
       )
     ) }),
-    /* @__PURE__ */ jsx204(Colorize114, { color: "#bfc1c4", children: /* @__PURE__ */ jsxs95(Union25, { children: [
+    /* @__PURE__ */ jsx204(Colorize114, { color: "#bfc1c4", children: /* @__PURE__ */ jsxs96(Union25, { children: [
       block(
         tabFront + (p.tabLength - p.tabNeckLength) / 2,
         0,
@@ -28520,7 +28998,7 @@ function TO277(p) {
 // lib/TantalumCapacitor.tsx
 import { fp as fp11 } from "@tscircuit/footprinter";
 import { Colorize as Colorize115, Cuboid as Cuboid70, Hull as Hull33, Rotate as Rotate25, Translate as Translate49, Union as Union26 } from "jscad-fiber";
-import { jsx as jsx205, jsxs as jsxs96 } from "react/jsx-runtime";
+import { jsx as jsx205, jsxs as jsxs97 } from "react/jsx-runtime";
 var tantalumCases = {
   A: [3.2, 1.6, 1.6, 1.2, 0.8],
   B: [3.5, 2.8, 1.9, 2.2, 0.8],
@@ -28540,8 +29018,8 @@ var TantalumCapacitor = ({
   if (pads.length !== 2) throw new Error("TantalumCapacitor requires two pads");
   const [a, b] = pads;
   const angle = Math.atan2(b.y - a.y, b.x - a.x);
-  return /* @__PURE__ */ jsx205(Translate49, { offset: [(a.x + b.x) / 2, (a.y + b.y) / 2, 0], children: /* @__PURE__ */ jsxs96(Rotate25, { rotation: [0, 0, angle], children: [
-    /* @__PURE__ */ jsx205(Colorize115, { color: "#d5a64e", children: /* @__PURE__ */ jsxs96(Hull33, { children: [
+  return /* @__PURE__ */ jsx205(Translate49, { offset: [(a.x + b.x) / 2, (a.y + b.y) / 2, 0], children: /* @__PURE__ */ jsxs97(Rotate25, { rotation: [0, 0, angle], children: [
+    /* @__PURE__ */ jsx205(Colorize115, { color: "#d5a64e", children: /* @__PURE__ */ jsxs97(Hull33, { children: [
       /* @__PURE__ */ jsx205(Cuboid70, { size: [length32 - 0.1, width10, 0.02], center: [0, 0, 0.21] }),
       /* @__PURE__ */ jsx205(
         Cuboid70,
@@ -28551,7 +29029,7 @@ var TantalumCapacitor = ({
         }
       )
     ] }) }),
-    /* @__PURE__ */ jsx205(Colorize115, { color: "#c5c8cb", children: [-1, 1].map((side) => /* @__PURE__ */ jsxs96(Union26, { children: [
+    /* @__PURE__ */ jsx205(Colorize115, { color: "#c5c8cb", children: [-1, 1].map((side) => /* @__PURE__ */ jsxs97(Union26, { children: [
       /* @__PURE__ */ jsx205(
         Cuboid70,
         {
@@ -28581,7 +29059,7 @@ var TantalumCapacitor = ({
 // lib/TwoPadCrystal.tsx
 import { fp as fp12 } from "@tscircuit/footprinter";
 import { Colorize as Colorize116, Cuboid as Cuboid71, RoundedCuboid as RoundedCuboid7, Rotate as Rotate26, Translate as Translate50 } from "jscad-fiber";
-import { jsx as jsx206, jsxs as jsxs97 } from "react/jsx-runtime";
+import { jsx as jsx206, jsxs as jsxs98 } from "react/jsx-runtime";
 var twoPadCrystalPackages = {
   FC135: [3.2, 1.5, 0.9, 0.7],
   FC12M: [2.05, 1.2, 0.6, 0.5],
@@ -28601,7 +29079,7 @@ var TwoPadCrystal = ({
   if (pads.length !== 2) throw new Error("TwoPadCrystal requires two pads");
   const [a, b] = pads;
   const angle = Math.atan2(b.y - a.y, b.x - a.x);
-  return /* @__PURE__ */ jsx206(Translate50, { offset: [(a.x + b.x) / 2, (a.y + b.y) / 2, 0], children: /* @__PURE__ */ jsxs97(Rotate26, { rotation: [0, 0, angle], children: [
+  return /* @__PURE__ */ jsx206(Translate50, { offset: [(a.x + b.x) / 2, (a.y + b.y) / 2, 0], children: /* @__PURE__ */ jsxs98(Rotate26, { rotation: [0, 0, angle], children: [
     /* @__PURE__ */ jsx206(Colorize116, { color: "#e0dcca", children: /* @__PURE__ */ jsx206(Cuboid71, { size: [length32, width10, 0.2], center: [0, 0, 0.13] }) }),
     /* @__PURE__ */ jsx206(Colorize116, { color: "#acb1b8", children: /* @__PURE__ */ jsx206(
       RoundedCuboid7,
@@ -28625,7 +29103,7 @@ var TwoPadCrystal = ({
 // lib/CeramicChipAntenna.tsx
 import { fp as fp13 } from "@tscircuit/footprinter";
 import { Colorize as Colorize117, Cuboid as Cuboid72, Rotate as Rotate27, Translate as Translate51 } from "jscad-fiber";
-import { jsx as jsx207, jsxs as jsxs98 } from "react/jsx-runtime";
+import { jsx as jsx207, jsxs as jsxs99 } from "react/jsx-runtime";
 var CeramicChipAntenna = ({
   footprint = "smdpads2_p5.4mm_pw1mm_ph2mm"
 }) => {
@@ -28635,7 +29113,7 @@ var CeramicChipAntenna = ({
   if (pads.length !== 2) throw new Error("CeramicChipAntenna requires two pads");
   const [a, b] = pads;
   const angle = Math.atan2(b.y - a.y, b.x - a.x);
-  return /* @__PURE__ */ jsx207(Translate51, { offset: [(a.x + b.x) / 2, (a.y + b.y) / 2, 0], children: /* @__PURE__ */ jsxs98(Rotate27, { rotation: [0, 0, angle], children: [
+  return /* @__PURE__ */ jsx207(Translate51, { offset: [(a.x + b.x) / 2, (a.y + b.y) / 2, 0], children: /* @__PURE__ */ jsxs99(Rotate27, { rotation: [0, 0, angle], children: [
     /* @__PURE__ */ jsx207(
       Cuboid72,
       {
@@ -28667,7 +29145,7 @@ var CeramicChipAntenna = ({
 // lib/MelfResistor.tsx
 import { fp as fp14 } from "@tscircuit/footprinter";
 import { Colorize as Colorize118, Cylinder as Cylinder28, Rotate as Rotate28, Translate as Translate52 } from "jscad-fiber";
-import { jsx as jsx208, jsxs as jsxs99 } from "react/jsx-runtime";
+import { jsx as jsx208, jsxs as jsxs100 } from "react/jsx-runtime";
 var melfResistorSizes = {
   "0102": [2.2, 1.1, 0.4],
   "0204": [3.6, 1.4, 0.75],
@@ -28686,7 +29164,7 @@ var MelfResistor = ({
   if (pads.length !== 2) throw new Error("MelfResistor requires two pads");
   const [a, b] = pads;
   const angle = Math.atan2(b.y - a.y, b.x - a.x);
-  return /* @__PURE__ */ jsx208(Translate52, { offset: [(a.x + b.x) / 2, (a.y + b.y) / 2, diameter / 2], children: /* @__PURE__ */ jsx208(Rotate28, { rotation: [0, 0, angle], children: /* @__PURE__ */ jsxs99(Rotate28, { rotation: [0, Math.PI / 2, 0], children: [
+  return /* @__PURE__ */ jsx208(Translate52, { offset: [(a.x + b.x) / 2, (a.y + b.y) / 2, diameter / 2], children: /* @__PURE__ */ jsx208(Rotate28, { rotation: [0, 0, angle], children: /* @__PURE__ */ jsxs100(Rotate28, { rotation: [0, Math.PI / 2, 0], children: [
     /* @__PURE__ */ jsx208(Colorize118, { color: "#426d63", children: /* @__PURE__ */ jsx208(
       Cylinder28,
       {
@@ -28705,6 +29183,29 @@ var MelfResistor = ({
     )) })
   ] }) }) });
 };
+
+// lib/models/rectangulartube/model.tsx
+import jscad21 from "@jscad/modeling";
+import { renderToJscadModel } from "jscad-fiber/model";
+import { jsx as jsx209 } from "react/jsx-runtime";
+function createRectangularTubeModel(input) {
+  const model108 = renderToJscadModel(
+    /* @__PURE__ */ jsx209(RectangularTube, { ...input }),
+    jscad21
+  );
+  if (model108.geometries.length !== 1 || !jscad21.geometries.geom3.isA(model108.geometries[0]))
+    throw new Error("RectangularTube must render exactly one native solid");
+  return model108;
+}
+
+// lib/models/rectangulartube/geometry.ts
+function createRectangularTubeGeom(input) {
+  const model108 = createRectangularTubeModel(input);
+  return model108.geometries[0];
+}
+function createRectangularTubeMesh(input) {
+  return geom3ToIndexedMesh(createRectangularTubeGeom(input));
+}
 export {
   A01005,
   A0201,
@@ -28928,6 +29429,7 @@ export {
   createRectangularGasketMesh,
   createRectangularTubeGeom,
   createRectangularTubeMesh,
+  createRectangularTubeModel,
   createRigidCouplerGeom,
   createRigidCouplerMesh,
   createSetScrewGeom,
@@ -28963,8 +29465,13 @@ export {
   createWormGearMesh,
   createZeeBarGeom,
   createZeeBarMesh,
+  geom3ToIndexedMesh,
   isJstShFootprint,
+  listJscadNamedEdges,
+  listJscadReferenceFeatures,
   melfResistorSizes,
+  readJscadNamedEdge,
+  readJscadReferenceFeature,
   resolveFlexScreenSize,
   smdLedDimensions,
   tantalumCases,