jscad-electronics 0.0.237 → 0.0.239

package/dist/vanilla.js

@@ -24,7 +24,7 @@ function h(type, props, ...restChildren) {
   };
 }
 
-// .model-contracts/generations/e80fbad5260b66fd00b4ab7513941eadd9b0b17b-v2/node_modules/zod/v3/external.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/node_modules/zod/v3/external.js
 var external_exports = {};
 __export(external_exports, {
   BRAND: () => BRAND,
@@ -136,7 +136,7 @@ __export(external_exports, {
   void: () => voidType
 });
 
-// .model-contracts/generations/e80fbad5260b66fd00b4ab7513941eadd9b0b17b-v2/node_modules/zod/v3/helpers/util.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/node_modules/zod/v3/helpers/util.js
 var util;
 (function(util2) {
   util2.assertEqual = (_) => {
@@ -270,7 +270,7 @@ var getParsedType = (data) => {
   }
 };
 
-// .model-contracts/generations/e80fbad5260b66fd00b4ab7513941eadd9b0b17b-v2/node_modules/zod/v3/ZodError.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/node_modules/zod/v3/ZodError.js
 var ZodIssueCode = util.arrayToEnum([
   "invalid_type",
   "invalid_literal",
@@ -388,7 +388,7 @@ ZodError.create = (issues) => {
   return error;
 };
 
-// .model-contracts/generations/e80fbad5260b66fd00b4ab7513941eadd9b0b17b-v2/node_modules/zod/v3/locales/en.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/node_modules/zod/v3/locales/en.js
 var errorMap = (issue, _ctx) => {
   let message;
   switch (issue.code) {
@@ -491,7 +491,7 @@ var errorMap = (issue, _ctx) => {
 };
 var en_default = errorMap;
 
-// .model-contracts/generations/e80fbad5260b66fd00b4ab7513941eadd9b0b17b-v2/node_modules/zod/v3/errors.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/node_modules/zod/v3/errors.js
 var overrideErrorMap = en_default;
 function setErrorMap(map) {
   overrideErrorMap = map;
@@ -500,7 +500,7 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 
-// .model-contracts/generations/e80fbad5260b66fd00b4ab7513941eadd9b0b17b-v2/node_modules/zod/v3/helpers/parseUtil.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
   const { data, path, errorMaps, issueData } = params;
   const fullPath = [...path, ...issueData.path || []];
@@ -610,14 +610,14 @@ var isDirty = (x) => x.status === "dirty";
 var isValid = (x) => x.status === "valid";
 var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
 
-// .model-contracts/generations/e80fbad5260b66fd00b4ab7513941eadd9b0b17b-v2/node_modules/zod/v3/helpers/errorUtil.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/node_modules/zod/v3/helpers/errorUtil.js
 var errorUtil;
 (function(errorUtil2) {
   errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
   errorUtil2.toString = (message) => typeof message === "string" ? message : message?.message;
 })(errorUtil || (errorUtil = {}));
 
-// .model-contracts/generations/e80fbad5260b66fd00b4ab7513941eadd9b0b17b-v2/node_modules/zod/v3/types.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
   constructor(parent, value, path, key) {
     this._cachedPath = [];
@@ -4065,7 +4065,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// .model-contracts/generations/e80fbad5260b66fd00b4ab7513941eadd9b0b17b-v2/node_modules/@tscircuit/mm/dist/index.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/node_modules/@tscircuit/mm/dist/index.js
 var unitToMm = {
   in: 25.4,
   inch: 25.4,
@@ -4092,7 +4092,7 @@ var mm = (n) => {
   throw new Error(`Unsupported unit: ${unit}`);
 };
 
-// .model-contracts/generations/e80fbad5260b66fd00b4ab7513941eadd9b0b17b-v2/index.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/index.js
 function normalizeNemaMotorModelString(value) {
   if (!/^nema(?:8|17|23|34)(?:_|$)/i.test(value)) return value;
   return value.replace(/(^|_)jst([0-9]+)_(ph|sh)(?=_|$)/gi, "$1jst$3$2").replace(/(^|_)jst[_-](ph|sh)[_-]([0-9]+)(?=_|$)/gi, "$1jst$2$3").replace(/(^|_)none(?=_|$)/gi, "$1nowires").replace(/(^|_)stubs(?=_|$)/gi, "$1wirestubs");
@@ -4647,6 +4647,76 @@ var jstMotorWireConnectionSchema = external_exports.string().refine((value) => {
   const connector = getJstMotorConnector(value);
   return connector !== void 0 && connector.pinCount >= 2 && connector.pinCount <= connector.maxPinCount;
 }, "Expected jst-ph-N (2\u201316 pins) or jst-sh-N (2\u201315 pins)");
+function isInsideNemaFace(x, y, p) {
+  const h2 = p.width / 2;
+  x = Math.abs(x);
+  y = Math.abs(y);
+  if (x > h2 || y > h2) return false;
+  const chamfer = p.chamfer;
+  if (!p.stepped) return x + y <= 2 * h2 - chamfer;
+  const c = chamfer / Math.SQRT2;
+  if (c === 0) return true;
+  const recess = p.recessRadius;
+  const fillet = p.filletRadius;
+  const k = h2 - c + recess;
+  if (x > h2 - c && y > h2 - c)
+    return x <= k && y <= k && Math.hypot(x - k, y - k) >= recess;
+  if (y > h2 - fillet && x > h2 - c - fillet)
+    return Math.hypot(x - (h2 - c - fillet), y - (h2 - fillet)) <= fillet;
+  if (x > h2 - fillet && y > h2 - c - fillet)
+    return Math.hypot(x - (h2 - fillet), y - (h2 - c - fillet)) <= fillet;
+  return true;
+}
+var segmentDistance = (x, y, ax, ay, bx, by) => {
+  const dx = bx - ax;
+  const dy = by - ay;
+  const t = Math.max(
+    0,
+    Math.min(1, ((x - ax) * dx + (y - ay) * dy) / (dx * dx + dy * dy || 1))
+  );
+  return Math.hypot(x - ax - t * dx, y - ay - t * dy);
+};
+var arcDistance = (x, y, cx, cy, r, start, end) => {
+  const angle = (Math.atan2(y - cy, x - cx) + 2 * Math.PI) % (2 * Math.PI);
+  if (angle >= start && angle <= end)
+    return Math.abs(Math.hypot(x - cx, y - cy) - r);
+  return Math.min(
+    Math.hypot(x - cx - r * Math.cos(start), y - cy - r * Math.sin(start)),
+    Math.hypot(x - cx - r * Math.cos(end), y - cy - r * Math.sin(end))
+  );
+};
+var boundaryDistance = (x, y, p) => {
+  const h2 = p.width / 2;
+  x = Math.abs(x);
+  y = Math.abs(y);
+  const chamfer = p.chamfer;
+  if (!p.stepped || chamfer === 0)
+    return Math.min(
+      Math.abs(h2 - x),
+      Math.abs(h2 - y),
+      Math.abs(2 * h2 - chamfer - x - y) / Math.SQRT2
+    );
+  const c = chamfer / Math.SQRT2;
+  const recess = p.recessRadius;
+  const fillet = p.filletRadius;
+  const a = h2 - c - fillet;
+  const k = h2 - c + recess;
+  return Math.min(
+    segmentDistance(x, y, -a, h2, a, h2),
+    segmentDistance(x, y, h2, -a, h2, a),
+    segmentDistance(x, y, h2 - c, h2 - fillet, h2 - c, k),
+    segmentDistance(x, y, k, h2 - c, h2 - fillet, h2 - c),
+    arcDistance(x, y, a, h2 - fillet, fillet, 0, Math.PI / 2),
+    arcDistance(x, y, k, k, recess, Math.PI, 3 * Math.PI / 2),
+    arcDistance(x, y, h2 - fillet, a, fillet, 0, Math.PI / 2)
+  );
+};
+function fitsNemaCircle(x, y, radius, p) {
+  return isInsideNemaFace(x, y, p) && boundaryDistance(x, y, p) > radius;
+}
+function clearsNemaCircle(x, y, radius, p) {
+  return !isInsideNemaFace(x, y, p) && boundaryDistance(x, y, p) > radius;
+}
 var hexSocketBoltDimensions = {
   M2: {
     diameter: 2,
@@ -4797,7 +4867,15 @@ var nemaMotorDimensions = {
     bodyCornerChamfer: 6
   },
   23: {
-    backFaceScrewSize: "M4",
+    // Representative side-tab rear pattern from STEPPERONLINE's ST-M10 adapter.
+    // The adapter's R5/R2.5 profile is a visual reference, not a frame guarantee:
+    // https://www.omc-stepperonline.com/image/catalog/dimensions/ST-M10_Dimension.svg
+    backFaceHoleSpacing: 50,
+    backFaceHoleSpacingY: 32,
+    rearCornerChamfer: 9 * Math.SQRT2,
+    rearCornerRecessRadius: 5,
+    rearCornerFilletRadius: 2.5,
+    backFaceScrewSize: "M3",
     backFaceHoleDepth: 4.5,
     bodyWidth: 56.4,
     bodyLength: 51,
@@ -4817,7 +4895,10 @@ var nemaMotorDimensions = {
     frontCapLength: 5,
     rearCapLength: 5,
     faceCornerChamfer: 2,
-    bodyCornerChamfer: 15
+    bodyCornerChamfer: 9 * Math.SQRT2,
+    bodyCornerRecessRadius: 5,
+    bodyCornerFilletRadius: 2.5,
+    chamferedBodyCornerChamfer: 15
   },
   34: {
     // Illustrative rear details; independent of the mounting flange.
@@ -4853,6 +4934,9 @@ var shape3 = {
   backFaceHoles: external_exports.boolean().optional(),
   backFaceScrews: external_exports.boolean().optional(),
   backFaceHoleSpacing: positiveModelLengthSchema.optional(),
+  /** Axis overrides; the legacy scalar still sets a square pattern when supplied. */
+  backFaceHoleSpacingX: positiveModelLengthSchema.optional(),
+  backFaceHoleSpacingY: positiveModelLengthSchema.optional(),
   backFaceHoleDiameter: positiveModelLengthSchema.optional(),
   backFaceHoleDepth: positiveModelLengthSchema.optional(),
   backFaceScrewSize: metricBoltSizeSchema.optional(),
@@ -4889,8 +4973,14 @@ var shape3 = {
   rearCapLength: positiveModelLengthSchema.optional(),
   faceCornerChamfer: nonnegativeModelLengthSchema.optional(),
   bodyCornerChamfer: nonnegativeModelLengthSchema.optional(),
+  bodyCornerRecessRadius: nonnegativeModelLengthSchema.optional(),
+  bodyCornerFilletRadius: nonnegativeModelLengthSchema.optional(),
   /** Rear outline is independent of the front mounting flange. */
   rearCornerChamfer: nonnegativeModelLengthSchema.optional(),
+  rearCornerRecessRadius: nonnegativeModelLengthSchema.optional(),
+  rearCornerFilletRadius: nonnegativeModelLengthSchema.optional(),
+  rearChamfered: external_exports.boolean().optional(),
+  rearStepped: external_exports.boolean().optional(),
   chamfered: external_exports.boolean().optional(),
   stepped: external_exports.boolean().optional()
 };
@@ -4915,7 +5005,11 @@ var resolve = (p, ctx) => {
   );
   const corner = select(
     ["chamfered", "stepped"],
-    p.nemaSize === 34 ? "stepped" : "chamfered"
+    p.nemaSize === 23 || p.nemaSize === 34 ? "stepped" : "chamfered"
+  );
+  const rearCorner = select(
+    ["rearChamfered", "rearStepped"],
+    p.chamfered === true ? "rearChamfered" : p.nemaSize === 23 || corner === "stepped" ? "rearStepped" : "rearChamfered"
   );
   const wireSpecified = p.noWires !== void 0 || p.wireStubs !== void 0 || p.wireConnection !== void 0;
   const wireSelections = Number(p.noWires === true) + Number(p.wireStubs === true) + Number(p.wireConnection !== void 0);
@@ -4925,8 +5019,13 @@ var resolve = (p, ctx) => {
       message: "Select exactly one of noWires, wireStubs or a JST wireConnection"
     });
   const d = nemaMotorDimensions[p.nemaSize];
+  const bodyCornerChamfer = p.bodyCornerChamfer ?? (corner === "chamfered" && "chamferedBodyCornerChamfer" in d ? d.chamferedBodyCornerChamfer : d.bodyCornerChamfer);
+  const defaultBodyRadius = Math.min(4, bodyCornerChamfer / Math.SQRT2 / 4);
   const backFaceScrewSize = p.backFaceScrewSize ?? d.backFaceScrewSize;
   const screw = hexSocketBoltDimensions[backFaceScrewSize];
+  const backFaceHoleSpacing = p.backFaceHoleSpacing ?? ("backFaceHoleSpacing" in d ? d.backFaceHoleSpacing : p.mountingHoleSpacing ?? d.mountingHoleSpacing);
+  const rearCornerChamfer = p.rearCornerChamfer ?? (p.nemaSize === 23 && rearCorner === "rearChamfered" ? p.faceCornerChamfer ?? d.faceCornerChamfer : "rearCornerChamfer" in d ? d.rearCornerChamfer : back === "backFacePlain" && (p.mountingHoleThrough ?? d.mountingHoleThrough) ? p.bodyCornerChamfer ?? d.bodyCornerChamfer : p.faceCornerChamfer ?? d.faceCornerChamfer);
+  const defaultRearRadius = Math.min(4, rearCornerChamfer / Math.SQRT2 / 4);
   return {
     nemaSize: p.nemaSize,
     noWires: p.noWires === true,
@@ -4939,7 +5038,9 @@ var resolve = (p, ctx) => {
     backFacePlain: back === "backFacePlain",
     backFaceHoles: back === "backFaceHoles",
     backFaceScrews: back === "backFaceScrews",
-    backFaceHoleSpacing: p.backFaceHoleSpacing ?? ("backFaceHoleSpacing" in d ? d.backFaceHoleSpacing : p.mountingHoleSpacing ?? d.mountingHoleSpacing),
+    backFaceHoleSpacing,
+    backFaceHoleSpacingX: p.backFaceHoleSpacingX ?? backFaceHoleSpacing,
+    backFaceHoleSpacingY: p.backFaceHoleSpacingY ?? p.backFaceHoleSpacing ?? ("backFaceHoleSpacingY" in d ? d.backFaceHoleSpacingY : backFaceHoleSpacing),
     backFaceHoleDiameter: p.backFaceHoleDiameter ?? screw.diameter,
     backFaceHoleDepth: p.backFaceHoleDepth ?? d.backFaceHoleDepth,
     backFaceScrewSize,
@@ -4961,24 +5062,43 @@ var resolve = (p, ctx) => {
     frontCapLength: p.frontCapLength ?? d.frontCapLength,
     rearCapLength: p.rearCapLength ?? d.rearCapLength,
     faceCornerChamfer: p.faceCornerChamfer ?? d.faceCornerChamfer,
-    bodyCornerChamfer: p.bodyCornerChamfer ?? d.bodyCornerChamfer,
+    bodyCornerChamfer,
+    bodyCornerRecessRadius: p.bodyCornerRecessRadius ?? ("bodyCornerRecessRadius" in d ? d.bodyCornerRecessRadius : defaultBodyRadius),
+    bodyCornerFilletRadius: p.bodyCornerFilletRadius ?? ("bodyCornerFilletRadius" in d ? d.bodyCornerFilletRadius : defaultBodyRadius),
     chamfered: corner === "chamfered",
     stepped: corner === "stepped",
-    ..."rearCornerChamfer" in d || p.rearCornerChamfer !== void 0 ? {
-      rearCornerChamfer: p.rearCornerChamfer ?? ("rearCornerChamfer" in d ? d.rearCornerChamfer : p.faceCornerChamfer ?? d.faceCornerChamfer)
-    } : {}
+    rearCornerChamfer,
+    rearStepped: rearCorner === "rearStepped",
+    rearChamfered: rearCorner === "rearChamfered",
+    rearCornerRecessRadius: p.rearCornerRecessRadius ?? ("rearCornerRecessRadius" in d ? d.rearCornerRecessRadius : defaultRearRadius),
+    rearCornerFilletRadius: p.rearCornerFilletRadius ?? ("rearCornerFilletRadius" in d ? d.rearCornerFilletRadius : defaultRearRadius)
   };
 };
 var validate3 = (p, ctx) => {
   const issue = (message) => ctx.addIssue({ code: "custom", message });
+  if (p.stepped && p.bodyCornerRecessRadius + p.bodyCornerFilletRadius > p.bodyCornerChamfer / Math.SQRT2)
+    issue("Body recess and fillet radii must fit within the corner shoulder");
   const rearChamfer = p.rearCornerChamfer ?? (p.backFacePlain && p.mountingHoleThrough ? p.bodyCornerChamfer : p.faceCornerChamfer);
-  const rearEdge = p.stepped ? rearChamfer / Math.SQRT2 : rearChamfer;
+  const rearEdge = p.rearStepped ? rearChamfer / Math.SQRT2 : rearChamfer;
+  if (p.rearStepped && p.rearCornerRecessRadius + p.rearCornerFilletRadius > rearEdge)
+    issue("Rear recess and fillet radii must fit within the corner shoulder");
   if (!p.backFacePlain) {
     const screw = hexSocketBoltDimensions[p.backFaceScrewSize];
     const radius = (p.backFaceScrews ? Math.max(p.backFaceHoleDiameter, screw.headDiameter) : p.backFaceHoleDiameter) / 2;
-    if (p.backFaceHoleSpacing <= 2 * radius)
+    if (p.backFaceHoleSpacingX <= 2 * radius || p.backFaceHoleSpacingY <= 2 * radius)
       issue("Rear holes and screw heads must not overlap each other");
-    if (p.backFaceHoleSpacing + 2 * radius >= p.bodyWidth || (p.stepped ? p.backFaceHoleSpacing + 2 * radius >= p.bodyWidth - 2 * rearEdge : p.bodyWidth - rearChamfer - p.backFaceHoleSpacing <= radius * Math.SQRT2))
+    if (!fitsNemaCircle(
+      p.backFaceHoleSpacingX / 2,
+      p.backFaceHoleSpacingY / 2,
+      radius,
+      {
+        width: p.bodyWidth,
+        chamfer: p.rearCornerChamfer,
+        stepped: p.rearStepped,
+        recessRadius: p.rearCornerRecessRadius,
+        filletRadius: p.rearCornerFilletRadius
+      }
+    ))
       issue("Rear holes and screw heads must fit entirely inside the rear face");
     if (p.backFaceHoleDepth >= p.rearCapLength)
       issue("Rear hole depth must be less than the rear cap length");
@@ -5009,7 +5129,13 @@ var validate3 = (p, ctx) => {
     issue("Mounting holes must clear the pilot");
   if (!p.mountingHoleThrough && p.mountingHoleDepth >= p.frontCapLength)
     issue("Blind mounting hole depth must be less than the front cap length");
-  if (p.mountingHoleThrough && (p.stepped ? p.bodyWidth / 2 - p.bodyCornerChamfer / Math.SQRT2 + Math.min(4, p.bodyCornerChamfer / Math.SQRT2 / 4) >= p.mountingHoleSpacing / 2 - r : p.bodyWidth - p.bodyCornerChamfer - p.mountingHoleSpacing >= -r * Math.SQRT2))
+  if (p.mountingHoleThrough && !clearsNemaCircle(p.mountingHoleSpacing / 2, p.mountingHoleSpacing / 2, r, {
+    width: p.bodyWidth,
+    chamfer: p.bodyCornerChamfer,
+    stepped: p.stepped,
+    recessRadius: p.bodyCornerRecessRadius,
+    filletRadius: p.bodyCornerFilletRadius
+  }))
     issue("Body must clear through front mounting holes");
   if (p.shaftLength <= p.pilotLength)
     issue("Shaft tip must extend beyond the pilot");
@@ -5028,6 +5154,8 @@ var lengths2 = {
   bodylength: "bodyLength",
   bodywidth: "bodyWidth",
   backholespacing: "backFaceHoleSpacing",
+  backholespacingx: "backFaceHoleSpacingX",
+  backholespacingy: "backFaceHoleSpacingY",
   backholediameter: "backFaceHoleDiameter",
   backholedepth: "backFaceHoleDepth",
   shaftlength: "shaftLength",
@@ -5043,7 +5171,11 @@ var lengths2 = {
   rearcap: "rearCapLength",
   facechamfer: "faceCornerChamfer",
   bodychamfer: "bodyCornerChamfer",
-  rearchamfer: "rearCornerChamfer"
+  bodyrecess: "bodyCornerRecessRadius",
+  bodyfillet: "bodyCornerFilletRadius",
+  rearchamfer: "rearCornerChamfer",
+  rearrecess: "rearCornerRecessRadius",
+  rearfillet: "rearCornerFilletRadius"
 };
 var flags = {
   backfaceplain: "backFacePlain",
@@ -5055,6 +5187,8 @@ var flags = {
   dshaft: "dShaft",
   chamfered: "chamfered",
   stepped: "stepped",
+  rearstepped: "rearStepped",
+  rearchamfered: "rearChamfered",
   nowires: "noWires",
   wirestubs: "wireStubs"
 };
@@ -12044,24 +12178,24 @@ function getNemaMotorReferencePoints(input) {
     p.bodyWidth / 2 / Math.max(Math.abs(x), Math.abs(y)),
     (p.bodyWidth - p.faceCornerChamfer) / (Math.abs(x) + Math.abs(y))
   );
-  if (p.nemaSize === 34 && p.stepped) {
-    const h2 = p.bodyWidth / 2, c = p.bodyCornerChamfer / Math.SQRT2, r = Math.min(4, c / 4);
-    const contains = (distance2) => {
-      const a = Math.abs(distance2 * x), b = Math.abs(distance2 * y);
-      if (a > h2 || b > h2) return false;
-      if (c === 0) return true;
-      if (a > h2 - c && b > h2 - c)
-        return a <= h2 - c + r && b <= h2 - c + r && Math.hypot(a - (h2 - c + r), b - (h2 - c + r)) >= r;
-      if (b > h2 - r && a > h2 - c - r)
-        return Math.hypot(a - (h2 - c - r), b - (h2 - r)) <= r;
-      if (a > h2 - r && b > h2 - c - r)
-        return Math.hypot(a - (h2 - r), b - (h2 - c - r)) <= r;
-      return true;
+  if (p.nemaSize !== 34 || p.stepped) {
+    const profile5 = p.nemaSize === 34 ? {
+      width: p.bodyWidth,
+      chamfer: p.bodyCornerChamfer,
+      stepped: p.stepped,
+      recessRadius: p.bodyCornerRecessRadius,
+      filletRadius: p.bodyCornerFilletRadius
+    } : {
+      width: p.bodyWidth,
+      chamfer: p.rearCornerChamfer,
+      stepped: p.rearStepped,
+      recessRadius: p.rearCornerRecessRadius,
+      filletRadius: p.rearCornerFilletRadius
     };
     let low = 0, high = p.bodyWidth;
     for (let i = 0; i < 50; i++) {
       const mid = (low + high) / 2;
-      if (contains(mid)) low = mid;
+      if (isInsideNemaFace(mid * x, mid * y, profile5)) low = mid;
       else high = mid;
     }
     radius = low;
@@ -12249,6 +12383,746 @@ var componentMaterials = {
   steel: { metalness: 1, roughness: 0.25 }
 };
 
+// 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 jscad from "@jscad/modeling";
+var edgeKey = (a, b) => a < b ? `${a},${b}` : `${b},${a}`;
+function geom3ToIndexedMesh(input) {
+  const generalize8 = jscad.modifiers.generalize;
+  input = structuredClone(input);
+  const inputExtent = Math.max(...jscad.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 = jscad.geometries.geom3.fromPoints(
+    jscad.geometries.geom3.toPolygons(input).map((poly) => poly.vertices.map(weld))
+  );
+  const geom = generalize8({ snap: true, triangulate: true }, welded);
+  const extent = Math.max(...jscad.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 * jscad.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 jscad.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 jscad2 = withReferences();
+var {
+  booleans,
+  colors,
+  curves,
+  expansions,
+  extrusions,
+  geometries,
+  hulls,
+  maths,
+  measurements,
+  modifiers,
+  primitives,
+  text,
+  transforms,
+  utils,
+  references
+} = jscad2;
+
+// lib/vanilla/render.ts
+var isVNode = (n) => n && typeof n === "object" && "type" in n;
+var degToRad = (v) => {
+  if (typeof v === "number") return v;
+  if (typeof v === "string") {
+    const m = /^(-?\d+(?:\.\d+)?)\s*deg$/i.exec(v);
+    if (m) return parseFloat(m[1]) * Math.PI / 180;
+    const n = Number(v);
+    if (!Number.isNaN(n)) return n;
+  }
+  return 0;
+};
+var toVec3 = (v) => {
+  if (Array.isArray(v))
+    return [Number(v[0]) || 0, Number(v[1]) || 0, Number(v[2]) || 0];
+  if (typeof v === "object" && v)
+    return [Number(v.x) || 0, Number(v.y) || 0, Number(v.z) || 0];
+  return [0, 0, 0];
+};
+var assertFiniteFeatureTransform = (values) => {
+  if (!values.every(Number.isFinite))
+    throw new Error("JSCAD reference feature transforms must be finite");
+};
+var transformFeatureContext = (context, local) => {
+  if (!context.referenceFeatures) return context;
+  const { mat4 } = context.jscad.maths;
+  const matrix = mat4.multiply(mat4.create(), context.matrix, local);
+  assertFiniteFeatureTransform(matrix);
+  return { ...context, matrix };
+};
+var validateFeatureName = (name) => {
+  if (name !== void 0 && (typeof name !== "string" || !name.trim()))
+    throw new Error("Named JSCAD features require a nonblank name");
+};
+var recordFeature = (context, name, geometry) => {
+  if (!context.referenceFeatures || name === void 0) return;
+  if (Object.hasOwn(context.referenceFeatures, name))
+    throw new Error(`Duplicate JSCAD feature name "${name}"`);
+  const { geometries: geometries9 } = context.jscad;
+  if (!geometries9.geom2.isA(geometry) && !geometries9.path2.isA(geometry) && !geometries9.geom3.isA(geometry))
+    throw new Error(`Named JSCAD feature "${name}" requires native geometry`);
+  assertFiniteFeatureTransform(context.matrix);
+  context.referenceFeatures[name] = {
+    geometry,
+    matrix: [...context.matrix]
+  };
+};
+function renderNode(node, colorCtx, renderCtx) {
+  const {
+    jscad: { primitives: primitives9, booleans: booleans5, hulls: hulls2, geometries: geometries9, extrusions: extrusions9, transforms: transforms3 }
+  } = renderCtx;
+  if (node == null || node === false) return [];
+  if (Array.isArray(node))
+    return node.flatMap((n) => renderNode(n, colorCtx, renderCtx));
+  if (!isVNode(node)) return [];
+  const { type, props, children } = node;
+  if (props?.material) {
+    const { material, ...rest } = props;
+    return renderNode({ ...node, props: rest }, colorCtx, renderCtx).map(
+      (entry) => ({
+        ...entry,
+        material: { ...material },
+        geom: { ...entry.geom, material: { ...material } }
+      })
+    );
+  }
+  if (type === Fragment) {
+    return (children ?? []).flatMap((c) => renderNode(c, colorCtx, renderCtx));
+  }
+  if (type === Colorize) {
+    const newColor = props?.color;
+    return (children ?? []).flatMap(
+      (c) => renderNode(c, newColor ?? colorCtx, renderCtx)
+    );
+  }
+  if (type === Translate) {
+    const offset = props?.offset ?? props?.center ?? { x: props?.x, y: props?.y, z: props?.z };
+    if (renderCtx.referenceFeatures)
+      assertFiniteFeatureTransform(
+        (Array.isArray(offset) ? offset.slice(0, 3) : [offset?.x, offset?.y, offset?.z]).map((value) => Number(value ?? 0))
+      );
+    const off = toVec3(offset);
+    const { mat4 } = renderCtx.jscad.maths;
+    const childContext = transformFeatureContext(
+      renderCtx,
+      mat4.fromTranslation(mat4.create(), off)
+    );
+    const geoms = (children ?? []).flatMap(
+      (c) => renderNode(c, colorCtx, childContext)
+    );
+    return geoms.map(({ geom, color, material }) => ({
+      material,
+      geom: transforms3.translate(off, geom),
+      color: color ?? colorCtx
+    }));
+  }
+  if (type === Rotate) {
+    const angles = props?.angles ?? props?.rotation;
+    if (renderCtx.referenceFeatures)
+      assertFiniteFeatureTransform(
+        (Array.isArray(angles) ? angles.slice(0, 3) : [props?.x, props?.y, props?.z]).map(
+          (value) => Number(
+            typeof value === "string" ? value.replace(/\s*deg$/i, "") : value ?? 0
+          )
+        )
+      );
+    const rot = Array.isArray(angles) ? [degToRad(angles[0]), degToRad(angles[1]), degToRad(angles[2])] : [
+      degToRad(props?.x ?? 0),
+      degToRad(props?.y ?? 0),
+      degToRad(props?.z ?? 0)
+    ];
+    const { mat4 } = renderCtx.jscad.maths;
+    const childContext = transformFeatureContext(
+      renderCtx,
+      mat4.fromTaitBryanRotation(mat4.create(), rot[2], rot[1], rot[0])
+    );
+    const geoms = (children ?? []).flatMap(
+      (c) => renderNode(c, colorCtx, childContext)
+    );
+    return geoms.map(({ geom, color, material }) => ({
+      material,
+      geom: transforms3.rotateZ(
+        rot[2],
+        transforms3.rotateY(rot[1], transforms3.rotateX(rot[0], geom))
+      ),
+      color
+    }));
+  }
+  if (type === Union || type === Subtract || type === Hull) {
+    const entries = (children ?? []).flatMap(
+      (c) => renderNode(c, colorCtx, renderCtx)
+    );
+    const geoms = entries.map((g) => g.geom);
+    if (geoms.length === 0) return [];
+    let geom;
+    if (type === Union) geom = booleans5.union(geoms);
+    else if (type === Subtract)
+      geom = booleans5.subtract(geoms[0], geoms.slice(1));
+    else geom = hulls2.hull(geoms);
+    return [
+      {
+        geom,
+        color: colorCtx,
+        material: type === Subtract ? entries[0]?.material : void 0
+      }
+    ];
+  }
+  if (type === Custom) {
+    const { name, reference, geometry } = props;
+    validateFeatureName(name);
+    if (reference && name === void 0)
+      throw new Error("Named JSCAD features require a nonblank name");
+    recordFeature(renderCtx, name, geometry);
+    if (reference) return [];
+    return [{ geom: props.geometry, color: colorCtx }];
+  }
+  if (type === Polygon) {
+    const points = props?.points ?? [];
+    const origin = points[0] ?? [0, 0];
+    const area = points.reduce((sum, point, index) => {
+      const next = points[(index + 1) % points.length];
+      return sum + (point[0] - origin[0]) * (next[1] - origin[1]) - (next[0] - origin[0]) * (point[1] - origin[1]);
+    }, 0);
+    const oriented = area < 0 ? [...points].reverse() : points;
+    const g2 = geometries9.geom2.fromPoints(oriented);
+    return [{ geom: g2, color: colorCtx ?? props?.color }];
+  }
+  if (type === ExtrudeLinear) {
+    const { topOutlineName, bottomOutlineName, twistAngle, twistSteps } = props;
+    const namedOutline = topOutlineName !== void 0 || bottomOutlineName !== void 0;
+    const height10 = props?.height ?? props?.h ?? 1;
+    validateFeatureName(topOutlineName);
+    validateFeatureName(bottomOutlineName);
+    if (namedOutline) {
+      if (!Number.isFinite(height10) || !Number.isFinite(twistAngle ?? 0))
+        throw new Error(
+          "Named extrusion outlines require finite height and twistAngle"
+        );
+      if (twistSteps !== void 0 && (!Number.isInteger(twistSteps) || twistSteps < 1))
+        throw new Error(
+          "Named extrusion outlines require positive integer twistSteps"
+        );
+    }
+    const entries = (children ?? []).flatMap(
+      (c) => renderNode(c, colorCtx, renderCtx)
+    );
+    const geoms2 = entries.map((g) => g.geom);
+    if (geoms2.length === 0) return [];
+    if (namedOutline && geoms2.length !== 1)
+      throw new Error("Named extrusion outlines require exactly one profile");
+    const base2 = geoms2.length > 1 ? booleans5.union(geoms2) : geoms2[0];
+    if (namedOutline && !geometries9.geom2.isA(base2) && !(geometries9.path2.isA(base2) && base2.isClosed))
+      throw new Error(
+        "Named extrusion outlines require a geom2 or closed path2 profile"
+      );
+    if (namedOutline && renderCtx.referenceFeatures) {
+      const { mat4 } = renderCtx.jscad.maths;
+      const topContext = transformFeatureContext(
+        renderCtx,
+        mat4.multiply(
+          mat4.create(),
+          mat4.fromTranslation(mat4.create(), [0, 0, height10]),
+          mat4.fromZRotation(mat4.create(), twistAngle ?? 0)
+        )
+      );
+      recordFeature(topContext, topOutlineName, base2);
+      recordFeature(renderCtx, bottomOutlineName, base2);
+    }
+    const g3 = extrusions9.extrudeLinear(
+      {
+        height: height10,
+        ...twistAngle !== void 0 ? { twistAngle } : {},
+        ...twistSteps !== void 0 ? { twistSteps } : {}
+      },
+      base2
+    );
+    return [
+      {
+        geom: g3,
+        color: colorCtx ?? props?.color,
+        material: entries.length === 1 ? entries[0]?.material : void 0
+      }
+    ];
+  }
+  if (type === Cuboid || type === Cube || type === Cylinder || type === Sphere || type === RoundedCuboid || type === RoundedCylinder) {
+    let g;
+    if (type === Cuboid) {
+      const size = props?.size ?? [1, 1, 1];
+      const offset = props?.offset;
+      const center = props?.center ?? (offset ? [offset[0], offset[1], offset[2]] : [0, 0, 0]);
+      g = primitives9.cuboid({ size, center });
+    } else if (type === Cube) {
+      const size = props?.size ?? 1;
+      const offset = props?.offset;
+      const center = props?.center ?? (offset ? [offset[0], offset[1], offset[2]] : [0, 0, 0]);
+      g = primitives9.cube({ size, center });
+    } else if (type === Cylinder) {
+      const height10 = props?.height ?? 1;
+      const radius = props?.radius ?? 1;
+      const center = props?.center ?? [0, 0, 0];
+      g = primitives9.cylinder({ height: height10, radius, center });
+    } else if (type === Sphere) {
+      const radius = props?.radius ?? 1;
+      const center = props?.center ?? [0, 0, 0];
+      g = primitives9.sphere({ radius, center });
+    } else if (type === RoundedCylinder) {
+      const height10 = props?.height ?? 1;
+      const radius = props?.radius ?? 1;
+      const roundRadius = props?.roundRadius ?? 0.1;
+      const center = props?.center ?? [0, 0, 0];
+      g = primitives9.roundedCylinder({ height: height10, radius, roundRadius, center });
+    } else {
+      const size = props?.size ?? [1, 1, 1];
+      const roundRadius = props?.roundRadius ?? 0.1;
+      const center = props?.center ?? [0, 0, 0];
+      g = primitives9.roundedCuboid({ size, roundRadius, center });
+    }
+    return [{ geom: g, color: colorCtx ?? props?.color }];
+  }
+  if (typeof type === "function") {
+    const out = type(props ?? {});
+    return renderNode(out, colorCtx, renderCtx);
+  }
+  return (children ?? []).flatMap((c) => renderNode(c, colorCtx, renderCtx));
+}
+function render(root, jscad22) {
+  jscad22 = withReferences(
+    jscad22
+  );
+  const geometries9 = renderNode(root, void 0, { jscad: jscad22 });
+  return {
+    geometries: geometries9.map(
+      (entry) => entry.material ? { ...entry, geom: { ...entry.geom, material: entry.material } } : entry
+    )
+  };
+}
+function renderToJscadModel(root, jscad22) {
+  jscad22 = withReferences(
+    jscad22
+  );
+  const referenceFeatures = /* @__PURE__ */ Object.create(null);
+  const geometries9 = renderNode(root, void 0, {
+    jscad: jscad22,
+    referenceFeatures,
+    matrix: jscad22.maths.mat4.create()
+  });
+  return {
+    geometries: geometries9.map(({ geom, color }) => {
+      if (color === void 0) return geom;
+      const { colors: colors2 } = jscad22;
+      const rgb = typeof color === "string" ? color.startsWith("#") ? colors2.hexToRgb(
+        /^#[\da-f]{3,4}$/i.test(color) ? `#${[...color.slice(1)].map((c) => c + c).join("")}` : color
+      ) : colors2.colorNameToRgb(color) : color;
+      if (!rgb) throw new Error(`Unknown JSCAD color "${color}"`);
+      return colors2.colorize(rgb, geom);
+    }),
+    referenceFeatures
+  };
+}
+
 // lib/vanilla/primitives.ts
 var Cuboid = /* @__PURE__ */ Symbol("Cuboid");
 var Cube = /* @__PURE__ */ Symbol("Cube");
@@ -12439,11 +13313,11 @@ var ModelRendererRegistry = class {
 };
 
 // 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 jscad3 from "@jscad/modeling";
+var { primitives: primitives2, extrusions: extrusions2, geometries: geometries2, modifiers: modifiers2, measurements: measurements2 } = jscad3;
+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++) {
@@ -12502,7 +13376,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();
@@ -12516,7 +13390,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]);
@@ -12549,7 +13423,7 @@ function register55(registry2) {
 }
 
 // lib/mechanical/indexedMeshToGeom3.ts
-import jscad2 from "@jscad/modeling";
+import jscad4 from "@jscad/modeling";
 function indexedMeshToGeom3(mesh) {
   const polygons = [];
   for (let i = 0; i < mesh.indices.length; i += 3)
@@ -12560,7 +13434,7 @@ function indexedMeshToGeom3(mesh) {
         mesh.positions[index * 3 + 2]
       ])
     );
-  return jscad2.geometries.geom3.fromPoints(polygons);
+  return jscad4.geometries.geom3.fromPoints(polygons);
 }
 
 // lib/models/ballbearing/mesh.ts
@@ -12689,11 +13563,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 };
@@ -12710,21 +13584,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 };
@@ -12735,7 +13609,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],
@@ -12743,7 +13617,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);
@@ -12934,7 +13808,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],
@@ -12947,12 +13821,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)
   );
@@ -12960,7 +13834,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],
@@ -12997,10 +13871,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++) {
@@ -13282,11 +14156,11 @@ function register59(registry2) {
 }
 
 // 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 jscad5 from "@jscad/modeling";
+var { primitives: primitives3, extrusions: extrusions3, geometries: geometries3, modifiers: modifiers3, measurements: measurements3 } = jscad5;
+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++) {
@@ -13356,7 +14230,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();
@@ -13370,7 +14244,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]);
@@ -13403,10 +14277,10 @@ function register60(registry2) {
 }
 
 // lib/models/clampingshaftcollar/mesh.ts
-import jscad5 from "@jscad/modeling";
+import jscad7 from "@jscad/modeling";
 
 // lib/mechanical/shaft-mount-geometry.ts
-import jscad4 from "@jscad/modeling";
+import jscad6 from "@jscad/modeling";
 var bodySegments = 64;
 var threadSegments = 24;
 var samplesPerTurn = 12;
@@ -13449,22 +14323,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 });
@@ -13522,10 +14396,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) => jscad6.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 = jscad6.booleans.subtract(scaled[0], ...scaled.slice(1));
+  return jscad6.transforms.scale([1 / factor, 1 / factor, 1 / factor], result);
 }
 function finishShaftMountMesh(geometry) {
   const positions = [];
@@ -13551,7 +14425,7 @@ function finishShaftMountMesh(geometry) {
     vertices.set(key, [...vertices.get(key) ?? [], index]);
     return index;
   };
-  const polygons = jscad4.geometries.geom3.toPolygons(geometry).map(
+  const polygons = jscad6.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;
@@ -13574,11 +14448,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);
@@ -13663,7 +14537,7 @@ function createClampingShaftCollarMesh(input) {
   });
   const s = dimensions5.split;
   const epsilon = 1e-4;
-  const slit = jscad5.primitives.cuboid({
+  const slit = jscad7.primitives.cuboid({
     size: [
       s.xMax - s.xMin + epsilon,
       s.yMax - s.yMin,
@@ -14238,7 +15112,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],
@@ -14249,14 +15123,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);
@@ -14401,15 +15275,15 @@ function register67(registry2) {
 }
 
 // lib/models/flatcableclip/geometry.ts
-import jscad6 from "@jscad/modeling";
+import jscad8 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
+} = jscad8;
 function createFlatCableClipSolid(input) {
   const p = flatCableClipModelPropsSchema.parse(input);
   const legOuter = p.innerWidth / 2 + p.thickness, half = legOuter + p.footLength;
@@ -14427,25 +15301,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);
@@ -14456,8 +15330,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(
@@ -14467,7 +15341,7 @@ function createFlatCableClipMesh(input) {
       })
     )
   );
-  return finishShaftMountMesh(geometries3.geom3.fromPoints(polygons));
+  return finishShaftMountMesh(geometries4.geom3.fromPoints(polygons));
 }
 function createFlatCableClipGeom(input) {
   return indexedMeshToGeom3(createFlatCableClipMesh(input));
@@ -16370,7 +17244,7 @@ function register79(registry2) {
 }
 
 // lib/utils/nemaMotorAssemblyGeometry.ts
-import jscad7 from "@jscad/modeling";
+import jscad9 from "@jscad/modeling";
 function nema34AssemblyCenters(p) {
   const edge = p.bodyWidth / 2;
   return [-1, 1].flatMap(
@@ -16380,16 +17254,16 @@ function nema34AssemblyCenters(p) {
   );
 }
 function cutNema34FrontRecesses(geometry, p) {
-  return jscad7.booleans.subtract(
+  return jscad9.booleans.subtract(
     geometry,
     ...nema34AssemblyCenters(p).flatMap(([x, y]) => [
-      jscad7.primitives.cylinder({
+      jscad9.primitives.cylinder({
         radius: 1.6,
         height: p.frontCapLength + 0.2,
         center: [x, y, -p.frontCapLength / 2],
         segments: 32
       }),
-      jscad7.primitives.cylinder({
+      jscad9.primitives.cylinder({
         radius: 5,
         height: Math.min(4, p.frontCapLength / 2) + 0.1,
         center: [
@@ -16403,8 +17277,8 @@ function cutNema34FrontRecesses(geometry, p) {
   );
 }
 function createNema34FrontScrews(p) {
-  const head = jscad7.booleans.subtract(
-    jscad7.primitives.ellipsoid({
+  const head = jscad9.booleans.subtract(
+    jscad9.primitives.ellipsoid({
       radius: [3.2, 3.2, 1.5],
       center: [0, 0, -1.8],
       segments: 32
@@ -16413,22 +17287,22 @@ function createNema34FrontScrews(p) {
       [3.7, 0.8, 1.1],
       [0.8, 3.7, 1.1]
     ].map(
-      (size) => jscad7.primitives.cuboid({
+      (size) => jscad9.primitives.cuboid({
         size,
         center: [0, 0, -0.8]
       })
     )
   );
   return nema34AssemblyCenters(p).map(
-    ([x, y]) => jscad7.transforms.translate([x, y, 0], head)
+    ([x, y]) => jscad9.transforms.translate([x, y, 0], head)
   );
 }
 
 // lib/NemaMotor.tsx
-import jscad9 from "@jscad/modeling";
+import jscad11 from "@jscad/modeling";
 
 // lib/utils/nemaMotorWireGeometry.ts
-import jscad8 from "@jscad/modeling";
+import jscad10 from "@jscad/modeling";
 
 // lib/utils/nemaMotorParameters.ts
 var resolveNemaMotorProps = nemaMotorModelPropsSchema.parse.bind(nemaMotorModelPropsSchema);
@@ -16439,12 +17313,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) => jscad10.transforms.translate(
     [position.x, position.y, position.z],
-    jscad8.transforms.rotateZ(angle, geometry)
+    jscad10.transforms.rotateZ(angle, geometry)
   );
   if (p.wireStubs) {
-    const colors = [
+    const colors2 = [
       "#d53f3f",
       "#2463af",
       "#3b934b",
@@ -16455,17 +17329,17 @@ function createNemaMotorWireGeometry(input) {
       "#803e91"
     ];
     const wires = Array.from({ length: p.wireCount }, (_, i) => ({
-      color: colors[i],
+      color: colors2[i],
       geometry: place(
-        jscad8.transforms.translate(
+        jscad10.transforms.translate(
           [
             (p.wireLength - 0.15) / 2,
             (i - (p.wireCount - 1) / 2) * p.wireDiameter * 1.5,
             0
           ],
-          jscad8.transforms.rotateY(
+          jscad10.transforms.rotateY(
             Math.PI / 2,
-            jscad8.primitives.cylinder({
+            jscad10.primitives.cylinder({
               height: p.wireLength + 0.15,
               radius: p.wireDiameter / 2,
               segments: 24
@@ -16478,7 +17352,7 @@ function createNemaMotorWireGeometry(input) {
       wires.unshift({
         color: "#252830",
         geometry: place(
-          jscad8.primitives.roundedCuboid({
+          jscad10.primitives.roundedCuboid({
             size: [3, p.wireCount * p.wireDiameter * 1.5 + 3, 6],
             center: [0.8, 0, 0],
             roundRadius: 1,
@@ -16493,12 +17367,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 = jscad10.booleans.subtract(
+    jscad10.primitives.cuboid({
       size: [matingDepth + 0.1, bodyWidth, bodyHeight],
       center: [(matingDepth - 0.1) / 2, 0, 0]
     }),
-    jscad8.primitives.cuboid({
+    jscad10.primitives.cuboid({
       size: [matingDepth - 0.5, bodyWidth - 2 * wall, bodyHeight - 2 * wall],
       center: [matingDepth / 2 + 0.55, 0, 0]
     })
@@ -16508,7 +17382,7 @@ function createNemaMotorWireGeometry(input) {
     ...Array.from({ length: pinCount }, (_, i) => ({
       color: "#b8bec6",
       geometry: place(
-        jscad8.primitives.cuboid({
+        jscad10.primitives.cuboid({
           size: [contactLength, contactSize, contactSize],
           center: [contactLength / 2, (i - (pinCount - 1) / 2) * pitch, 0]
         })
@@ -16556,19 +17430,25 @@ var roundedFace = (width10, radius) => {
     })
   );
 };
-var steppedFace = (width10, chamfer) => {
+var steppedFace = (width10, chamfer, recessRadius, filletRadius) => {
   if (chamfer === 0) return face(width10, 0);
   const h2 = width10 / 2, c = chamfer / Math.SQRT2, r = Math.min(4, c / 4);
   const corner = [];
-  const arc = (x, y, from, to) => {
+  const arc = (x, y, radius, from, to) => {
+    if (radius === 0) {
+      corner.push([x, y]);
+      return;
+    }
     for (let i = 0; i <= 12; i++) {
       const a = (from + (to - from) * i / 12) * Math.PI / 180;
-      corner.push([x + r * Math.cos(a), y + r * Math.sin(a)]);
+      corner.push([x + radius * Math.cos(a), y + radius * Math.sin(a)]);
     }
   };
-  arc(h2 - c - r, h2 - r, 90, 0);
-  arc(h2 - c + r, h2 - c + r, 180, 270);
-  arc(h2 - r, h2 - c - r, 90, 0);
+  const convex = filletRadius ?? r;
+  const concave = recessRadius ?? r;
+  arc(h2 - c - convex, h2 - convex, convex, 90, 0);
+  arc(h2 - c + concave, h2 - c + concave, concave, 180, 270);
+  arc(h2 - convex, h2 - c - convex, convex, 90, 0);
   return [0, 1, 2, 3].flatMap(
     (i) => corner.map(([x, y]) => {
       const a = -i * Math.PI / 2;
@@ -16589,12 +17469,18 @@ function createNemaMotorSections(input) {
     p.bodyWidth,
     p.faceCornerChamfer
   );
-  const profile6 = p.stepped ? steppedFace : face;
-  const core = profile6(p.bodyWidth, p.bodyCornerChamfer);
-  const rear = profile6(
+  const core = p.stepped ? steppedFace(
     p.bodyWidth,
-    p.rearCornerChamfer ?? (p.backFacePlain && p.mountingHoleThrough ? p.bodyCornerChamfer : p.faceCornerChamfer)
-  );
+    p.bodyCornerChamfer,
+    p.bodyCornerRecessRadius,
+    p.bodyCornerFilletRadius
+  ) : face(p.bodyWidth, p.bodyCornerChamfer);
+  const rear = p.rearStepped ? steppedFace(
+    p.bodyWidth,
+    p.rearCornerChamfer,
+    p.rearCornerRecessRadius,
+    p.rearCornerFilletRadius
+  ) : face(p.bodyWidth, p.rearCornerChamfer);
   const h2 = p.mountingHoleSpacing / 2;
   const centers = [
     [-h2, -h2],
@@ -16612,9 +17498,10 @@ function createNemaMotorSections(input) {
   if (p.backFacePlain) {
     add("rearCap", rear, -p.bodyLength, -p.bodyLength + p.rearCapLength);
   } else {
-    const halfPitch = p.backFaceHoleSpacing / 2;
-    const rearHoles = [-halfPitch, halfPitch].flatMap(
-      (x) => [-halfPitch, halfPitch].map(
+    const halfPitchX = p.backFaceHoleSpacingX / 2;
+    const halfPitchY = p.backFaceHoleSpacingY / 2;
+    const rearHoles = [-halfPitchX, halfPitchX].flatMap(
+      (x) => [-halfPitchY, halfPitchY].map(
         (y) => circle(p.backFaceHoleDiameter / 2, x, y)
       )
     );
@@ -16639,12 +17526,12 @@ function createNemaMotorSections(input) {
   else {
     const cut = r - p.shaftFlatDepth;
     const angle = Math.acos(cut / r);
-    const profile7 = 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 = profile7.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)
     ]);
@@ -16655,7 +17542,7 @@ function createNemaMotorSections(input) {
 }
 
 // lib/NemaMotor.tsx
-var generalize3 = jscad9.modifiers.generalize;
+var generalize3 = jscad11.modifiers.generalize;
 function NemaMotor({
   bodyColor = "#242830",
   capColor = "#aeb5bd",
@@ -16664,7 +17551,7 @@ function NemaMotor({
   ...props
 }) {
   const p = resolveNemaMotorProps(props);
-  const screw = p.backFaceScrews ? jscad9.transforms.rotateX(
+  const screw = p.backFaceScrews ? jscad11.transforms.rotateX(
     Math.PI,
     createHexSocketBoltGeom({
       metricSize: p.backFaceScrewSize,
@@ -16672,19 +17559,20 @@ function NemaMotor({
       showThreads: false
     })
   ) : void 0;
-  const halfPitch = p.backFaceHoleSpacing / 2;
+  const halfPitchX = p.backFaceHoleSpacingX / 2;
+  const halfPitchY = p.backFaceHoleSpacingY / 2;
   return /* @__PURE__ */ jsxs(Fragment2, { children: [
     createNemaMotorSections(p).map((section, index) => {
-      const outline = jscad9.geometries.geom2.fromPoints(section.outline);
-      const profile6 = section.holes.length ? jscad9.booleans.subtract(
+      const outline = jscad11.geometries.geom2.fromPoints(section.outline);
+      const profile5 = section.holes.length ? jscad11.booleans.subtract(
         outline,
-        ...section.holes.map((h2) => jscad9.geometries.geom2.fromPoints(h2))
+        ...section.holes.map((h2) => jscad11.geometries.geom2.fromPoints(h2))
       ) : outline;
-      let geometry = jscad9.transforms.translate(
+      let geometry = jscad11.transforms.translate(
         [0, 0, section.zMin],
-        jscad9.extrusions.extrudeLinear(
+        jscad11.extrusions.extrudeLinear(
           { height: section.zMax - section.zMin },
-          profile6
+          profile5
         )
       );
       if (p.nemaSize === 34 && section.name === "frontCap")
@@ -16717,8 +17605,8 @@ function NemaMotor({
       },
       `front-screw-${index}`
     )),
-    screw && [-halfPitch, halfPitch].flatMap(
-      (x) => [-halfPitch, halfPitch].map((y) => /* @__PURE__ */ jsx(
+    screw && [-halfPitchX, halfPitchX].flatMap(
+      (x) => [-halfPitchY, halfPitchY].map((y) => /* @__PURE__ */ jsx(
         Colorize,
         {
           material: componentMaterials.steel,
@@ -16726,7 +17614,7 @@ function NemaMotor({
           children: /* @__PURE__ */ jsx(
             Custom,
             {
-              geometry: jscad9.transforms.translate(
+              geometry: jscad11.transforms.translate(
                 [x, y, -p.bodyLength],
                 generalize3({ simplify: true }, screw)
               )
@@ -17216,19 +18104,19 @@ function register83(registry2) {
 }
 
 // lib/models/perforatedsheet/geometry.ts
-import jscad10 from "@jscad/modeling";
+import jscad12 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
+} = jscad12;
+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);
@@ -17259,7 +18147,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();
@@ -17273,7 +18161,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]);
@@ -17315,7 +18203,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],
@@ -17333,14 +18221,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);
@@ -17372,13 +18260,13 @@ function register85(registry2) {
 }
 
 // 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 jscad13 from "@jscad/modeling";
+var { primitives: primitives6, extrusions: extrusions6, geometries: geometries6, modifiers: modifiers5, measurements: measurements6 } = jscad13;
+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: [
@@ -17397,7 +18285,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();
@@ -17411,7 +18299,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]);
@@ -17444,11 +18332,11 @@ function register86(registry2) {
 }
 
 // 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 jscad14 from "@jscad/modeling";
+var { primitives: primitives7, extrusions: extrusions7, geometries: geometries7, modifiers: modifiers6, measurements: measurements7 } = jscad14;
+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,
@@ -17463,7 +18351,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();
@@ -17477,7 +18365,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]);
@@ -17621,72 +18509,27 @@ function register88(registry2) {
   registry2.register(model88);
 }
 
-// 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 jscad15 from "@jscad/modeling";
+var roundedRectangle6 = (width10, height10, radius) => radius ? jscad15.primitives.roundedRectangle({
   size: [width10, height10],
   roundRadius: radius,
   segments: 64
-}) : rectangle6({ size: [width10, height10] });
-function createRectangularTubeGeom(input) {
+}) : jscad15.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) => jscad15.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
@@ -17694,7 +18537,27 @@ function RectangularTube({
   color = "#929da9",
   ...props
 }) {
-  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createRectangularTubeGeom(props) }) });
+  const { length: length32, outerPoints, innerPoints } = getRectangularTubeProfiles(props);
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsxs(Subtract, { children: [
+    /* @__PURE__ */ jsx(
+      ExtrudeLinear,
+      {
+        height: length32,
+        topOutlineName: "outer_top",
+        bottomOutlineName: "outer_bottom",
+        children: /* @__PURE__ */ jsx(Polygon, { points: outerPoints })
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ExtrudeLinear,
+      {
+        height: length32,
+        topOutlineName: "inner_top",
+        bottomOutlineName: "inner_bottom",
+        children: /* @__PURE__ */ jsx(Polygon, { points: innerPoints })
+      }
+    )
+  ] }) });
 }
 
 // lib/models/rectangulartube/register.tsx
@@ -17939,7 +18802,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 = [];
@@ -17952,10 +18815,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;
@@ -18006,7 +18869,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(
           [
@@ -18019,7 +18882,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;
@@ -18618,7 +19481,7 @@ function register100(registry2) {
 }
 
 // lib/models/tslotcoverstrip/geometry.ts
-import jscad16 from "@jscad/modeling";
+import jscad18 from "@jscad/modeling";
 var {
   primitives: primitives8,
   extrusions: extrusions8,
@@ -18626,8 +19489,8 @@ var {
   geometries: geometries8,
   modifiers: modifiers7,
   measurements: measurements8
-} = jscad16;
-var generalize8 = modifiers7.generalize;
+} = jscad18;
+var generalize7 = modifiers7.generalize;
 function createTSlotCoverStripGeom(input) {
   const p = tSlotCoverStripModelPropsSchema.parse(input);
   const w = p.width / 2;
@@ -18654,7 +19517,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)
   );
@@ -18908,10 +19771,10 @@ function register104(registry2) {
 }
 
 // lib/models/ufl/geometry.ts
-import jscad17 from "@jscad/modeling";
+import jscad19 from "@jscad/modeling";
 function createUflGeometries(input = {}) {
   const d = getUflDimensions(input);
-  const { booleans: booleans5, primitives: primitives9 } = jscad17;
+  const { booleans: booleans5, primitives: primitives9 } = jscad19;
   const silver = "#bcbfc3";
   const dielectric = "#eee9d5";
   const gold = "#d9b45b";
@@ -19068,17 +19931,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;
@@ -19086,7 +19949,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),
@@ -27589,185 +28452,6 @@ var Footprinter3d = ({ footprint }) => {
   return null;
 };
 
-// lib/vanilla/render.ts
-var isVNode = (n) => n && typeof n === "object" && "type" in n;
-var degToRad = (v) => {
-  if (typeof v === "number") return v;
-  if (typeof v === "string") {
-    const m = /^(-?\d+(?:\.\d+)?)\s*deg$/i.exec(v);
-    if (m) return parseFloat(m[1]) * Math.PI / 180;
-    const n = Number(v);
-    if (!Number.isNaN(n)) return n;
-  }
-  return 0;
-};
-var toVec3 = (v) => {
-  if (Array.isArray(v))
-    return [Number(v[0]) || 0, Number(v[1]) || 0, Number(v[2]) || 0];
-  if (typeof v === "object" && v)
-    return [Number(v.x) || 0, Number(v.y) || 0, Number(v.z) || 0];
-  return [0, 0, 0];
-};
-function renderNode(node, colorCtx, renderCtx) {
-  const {
-    jscad: { primitives: primitives9, booleans: booleans5, hulls, geometries: geometries9, extrusions: extrusions9, transforms: transforms2 }
-  } = renderCtx;
-  if (node == null || node === false) return [];
-  if (Array.isArray(node))
-    return node.flatMap((n) => renderNode(n, colorCtx, renderCtx));
-  if (!isVNode(node)) return [];
-  const { type, props, children } = node;
-  if (props?.material) {
-    const { material, ...rest } = props;
-    return renderNode({ ...node, props: rest }, colorCtx, renderCtx).map(
-      (entry) => ({
-        ...entry,
-        material: { ...material },
-        geom: { ...entry.geom, material: { ...material } }
-      })
-    );
-  }
-  if (type === Fragment) {
-    return (children ?? []).flatMap((c) => renderNode(c, colorCtx, renderCtx));
-  }
-  if (type === Colorize) {
-    const newColor = props?.color;
-    return (children ?? []).flatMap(
-      (c) => renderNode(c, newColor ?? colorCtx, renderCtx)
-    );
-  }
-  if (type === Translate) {
-    const off = toVec3(
-      props?.offset ?? props?.center ?? { x: props?.x, y: props?.y, z: props?.z }
-    );
-    const geoms = (children ?? []).flatMap(
-      (c) => renderNode(c, colorCtx, renderCtx)
-    );
-    return geoms.map(({ geom, color, material }) => ({
-      material,
-      geom: transforms2.translate(off, geom),
-      color: color ?? colorCtx
-    }));
-  }
-  if (type === Rotate) {
-    const angles = props?.angles ?? props?.rotation;
-    const rot = Array.isArray(angles) ? [degToRad(angles[0]), degToRad(angles[1]), degToRad(angles[2])] : [
-      degToRad(props?.x ?? 0),
-      degToRad(props?.y ?? 0),
-      degToRad(props?.z ?? 0)
-    ];
-    const geoms = (children ?? []).flatMap(
-      (c) => renderNode(c, colorCtx, renderCtx)
-    );
-    return geoms.map(({ geom, color, material }) => ({
-      material,
-      geom: transforms2.rotateZ(
-        rot[2],
-        transforms2.rotateY(rot[1], transforms2.rotateX(rot[0], geom))
-      ),
-      color
-    }));
-  }
-  if (type === Union || type === Subtract || type === Hull) {
-    const entries = (children ?? []).flatMap(
-      (c) => renderNode(c, colorCtx, renderCtx)
-    );
-    const geoms = entries.map((g) => g.geom);
-    if (geoms.length === 0) return [];
-    let geom;
-    if (type === Union) geom = booleans5.union(geoms);
-    else if (type === Subtract)
-      geom = booleans5.subtract(geoms[0], geoms.slice(1));
-    else geom = hulls.hull(geoms);
-    return [
-      {
-        geom,
-        color: colorCtx,
-        material: type === Subtract ? entries[0]?.material : void 0
-      }
-    ];
-  }
-  if (type === Custom) {
-    return [{ geom: props.geometry, color: colorCtx }];
-  }
-  if (type === Polygon) {
-    const points = props?.points ?? [];
-    const g2 = geometries9.geom2.fromPoints(points);
-    return [{ geom: g2, color: colorCtx ?? props?.color }];
-  }
-  if (type === ExtrudeLinear) {
-    const entries = (children ?? []).flatMap(
-      (c) => renderNode(c, colorCtx, renderCtx)
-    );
-    const geoms2 = entries.map((g) => g.geom);
-    if (geoms2.length === 0) return [];
-    const base2 = geoms2.length > 1 ? booleans5.union(geoms2) : geoms2[0];
-    const height10 = props?.height ?? props?.h ?? 1;
-    let g3 = extrusions9.extrudeLinear({ height: height10 }, base2);
-    if (g3.polygons) {
-      for (const poly of g3.polygons) {
-        if (!poly.plane || !poly.vertices || poly.vertices.length < 3) continue;
-        poly.vertices.reverse();
-      }
-    }
-    return [
-      {
-        geom: g3,
-        color: colorCtx ?? props?.color,
-        material: entries.length === 1 ? entries[0]?.material : void 0
-      }
-    ];
-  }
-  if (type === Cuboid || type === Cube || type === Cylinder || type === Sphere || type === RoundedCuboid || type === RoundedCylinder) {
-    let g;
-    if (type === Cuboid) {
-      const size = props?.size ?? [1, 1, 1];
-      const offset = props?.offset;
-      const center = props?.center ?? (offset ? [offset[0], offset[1], offset[2]] : [0, 0, 0]);
-      g = primitives9.cuboid({ size, center });
-    } else if (type === Cube) {
-      const size = props?.size ?? 1;
-      const offset = props?.offset;
-      const center = props?.center ?? (offset ? [offset[0], offset[1], offset[2]] : [0, 0, 0]);
-      g = primitives9.cube({ size, center });
-    } else if (type === Cylinder) {
-      const height10 = props?.height ?? 1;
-      const radius = props?.radius ?? 1;
-      const center = props?.center ?? [0, 0, 0];
-      g = primitives9.cylinder({ height: height10, radius, center });
-    } else if (type === Sphere) {
-      const radius = props?.radius ?? 1;
-      const center = props?.center ?? [0, 0, 0];
-      g = primitives9.sphere({ radius, center });
-    } else if (type === RoundedCylinder) {
-      const height10 = props?.height ?? 1;
-      const radius = props?.radius ?? 1;
-      const roundRadius = props?.roundRadius ?? 0.1;
-      const center = props?.center ?? [0, 0, 0];
-      g = primitives9.roundedCylinder({ height: height10, radius, roundRadius, center });
-    } else {
-      const size = props?.size ?? [1, 1, 1];
-      const roundRadius = props?.roundRadius ?? 0.1;
-      const center = props?.center ?? [0, 0, 0];
-      g = primitives9.roundedCuboid({ size, roundRadius, center });
-    }
-    return [{ geom: g, color: colorCtx ?? props?.color }];
-  }
-  if (typeof type === "function") {
-    const out = type(props ?? {});
-    return renderNode(out, colorCtx, renderCtx);
-  }
-  return (children ?? []).flatMap((c) => renderNode(c, colorCtx, renderCtx));
-}
-function render(root, jscad18) {
-  const geometries9 = renderNode(root, void 0, { jscad: jscad18 });
-  return {
-    geometries: geometries9.map(
-      (entry) => entry.material ? { ...entry, geom: { ...entry.geom, material: entry.material } } : entry
-    )
-  };
-}
-
 // lib/vanilla/convertCSGToThreeGeom.ts
 import {
   BufferAttribute,
@@ -27778,16 +28462,16 @@ function convertCSGToThreeGeom(csg) {
   if (csg.polygons) {
     const vertices = [];
     const indices = [];
-    const colors = [];
+    const colors2 = [];
     let idx = 0;
     for (const polygon4 of csg.polygons) {
       for (const vertex of polygon4.vertices) {
         vertex.index = idx;
         vertices.push(vertex[0], vertex[1], vertex[2]);
         if (csg.color && csg.color.length >= 3) {
-          colors.push(csg.color[0], csg.color[1], csg.color[2]);
+          colors2.push(csg.color[0], csg.color[1], csg.color[2]);
         } else {
-          colors.push(1, 1, 1);
+          colors2.push(1, 1, 1);
         }
         idx++;
       }
@@ -27804,29 +28488,29 @@ function convertCSGToThreeGeom(csg) {
       new BufferAttribute(new Float32Array(vertices), 3)
     );
     geo.setIndex(indices);
-    if (colors.length > 0) {
+    if (colors2.length > 0) {
       geo.setAttribute(
         "color",
-        new BufferAttribute(new Float32Array(colors), 3)
+        new BufferAttribute(new Float32Array(colors2), 3)
       );
     }
     if (csg.transforms) {
-      const transforms2 = new Matrix4();
-      transforms2.fromArray(csg.transforms);
-      geo.applyMatrix4(transforms2);
+      const transforms3 = new Matrix4();
+      transforms3.fromArray(csg.transforms);
+      geo.applyMatrix4(transforms3);
     }
     geo.computeVertexNormals();
     return geo;
   }
   if (csg.sides) {
     const vertices = [];
-    const colors = [];
+    const colors2 = [];
     for (const side of csg.sides) {
       vertices.push(side[0][0], side[0][1], 0);
       if (csg.color && csg.color.length >= 3) {
-        colors.push(csg.color[0], csg.color[1], csg.color[2]);
+        colors2.push(csg.color[0], csg.color[1], csg.color[2]);
       } else {
-        colors.push(1, 1, 1);
+        colors2.push(1, 1, 1);
       }
     }
     const geo = new BufferGeometry();
@@ -27834,16 +28518,16 @@ function convertCSGToThreeGeom(csg) {
       "position",
       new BufferAttribute(new Float32Array(vertices), 3)
     );
-    if (colors.length > 0) {
+    if (colors2.length > 0) {
       geo.setAttribute(
         "color",
-        new BufferAttribute(new Float32Array(colors), 3)
+        new BufferAttribute(new Float32Array(colors2), 3)
       );
     }
     if (csg.transforms) {
-      const transforms2 = new Matrix4();
-      transforms2.fromArray(csg.transforms);
-      geo.applyMatrix4(transforms2);
+      const transforms3 = new Matrix4();
+      transforms3.fromArray(csg.transforms);
+      geo.applyMatrix4(transforms3);
     }
     return geo;
   }
@@ -27851,25 +28535,104 @@ function convertCSGToThreeGeom(csg) {
   return new BufferGeometry();
 }
 
+// lib/named-edges.ts
+import jscad20 from "@jscad/modeling";
+function listJscadNamedEdges(model108) {
+  return listJscadReferenceFeatures(model108).filter((name) => {
+    const { geometry } = model108.referenceFeatures[name];
+    return jscad20.geometries.geom2.isA(geometry) || jscad20.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 (jscad20.geometries.path2.isA(feature)) {
+    const path = jscad20.geometries.path2.clone(feature);
+    points = jscad20.geometries.path2.toPoints(path);
+    closed = path.isClosed;
+  } else if (jscad20.geometries.geom2.isA(feature)) {
+    const outlines = jscad20.geometries.geom2.toOutlines(
+      jscad20.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 = jscad20.maths.vec3.transform(
+        jscad20.maths.vec3.create(),
+        [x, y, 0],
+        matrix
+      );
+      return { x: point[0], y: point[1], z: point[2] };
+    }),
+    closed
+  };
+}
+
+// lib/models/rectangulartube/model.tsx
+import jscad21 from "@jscad/modeling";
+function createRectangularTubeModel(input) {
+  const model108 = renderToJscadModel(
+    /* @__PURE__ */ jsx(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));
+}
+
 // lib/vanilla/index.ts
-function getJscadModelForFootprint(footprint, jscad18) {
+function getJscadModelForFootprint(footprint, jscad22) {
   const vnode = h(Footprinter3d, { footprint });
-  return render(vnode, jscad18);
+  return render(vnode, jscad22);
 }
-function getJscadModelForFootprintWithPads(footprint, jscad18) {
+function getJscadModelForFootprintWithPads(footprint, jscad22) {
   const vnode = h(
     Fragment,
     {},
     h(Footprinter3d, { footprint }),
     h(ExtrudedPads, { footprint })
   );
-  return render(vnode, jscad18);
+  return render(vnode, jscad22);
 }
-function createJSCADRenderer(jscad18) {
+function createJSCADRenderer(jscad22) {
   function createJSCADRoot(container) {
     return {
       render(element) {
-        const { geometries: geometries9 } = render(element, jscad18);
+        const { geometries: geometries9 } = render(element, jscad22);
         container.splice(0, container.length, ...geometries9);
       }
     };
@@ -28004,6 +28767,7 @@ export {
   createRectangularGasketMesh,
   createRectangularTubeGeom,
   createRectangularTubeMesh,
+  createRectangularTubeModel,
   createRigidCouplerGeom,
   createRigidCouplerMesh,
   createSetScrewGeom,
@@ -28039,8 +28803,14 @@ export {
   createWormGearMesh,
   createZeeBarGeom,
   createZeeBarMesh,
+  geom3ToIndexedMesh,
   getJscadModelForFootprint,
   getJscadModelForFootprintWithPads,
-  h
+  h,
+  listJscadNamedEdges,
+  listJscadReferenceFeatures,
+  readJscadNamedEdge,
+  readJscadReferenceFeature,
+  renderToJscadModel
 };
 //# sourceMappingURL=vanilla.js.map