@tscircuit/3d-viewer 0.0.613 → 0.0.614

package/dist/index.js

@@ -13389,7 +13389,7 @@ var require_generalize = __commonJS({
       clone.polygons = polygons;
       return clone;
     };
-    var generalize = (options, ...geometries) => {
+    var generalize2 = (options, ...geometries) => {
       geometries = flatten(geometries);
       if (geometries.length === 0) throw new Error("wrong number of arguments");
       const results = geometries.map((geometry) => {
@@ -13400,7 +13400,7 @@ var require_generalize = __commonJS({
       });
       return results.length === 1 ? results[0] : results;
     };
-    module.exports = generalize;
+    module.exports = generalize2;
   }
 });
 
@@ -13880,77 +13880,77 @@ var require_dist = __commonJS({
         radToDeg: (radians) => radians * 180 / Math.PI
       }
     };
-    var executeJscadOperations3 = (jscad5, operation) => {
+    var executeJscadOperations3 = (jscad6, operation) => {
       if (Array.isArray(operation) && operation.length === 1) {
-        return executeJscadOperations3(jscad5, operation[0]);
+        return executeJscadOperations3(jscad6, operation[0]);
       }
       if (Array.isArray(operation)) {
         throw new Error(
           `executeJscadOperations currently doesn't support Array<JscadOperation>, try adding a root union or or executing each element individually`
         );
       }
-      const recurse = (op) => executeJscadOperations3(jscad5, op);
+      const recurse = (op) => executeJscadOperations3(jscad6, op);
       const { type, ...params } = operation;
       switch (type) {
         case "intersect":
-          return jscad5.booleans.intersect(...operation.shapes.map(recurse));
+          return jscad6.booleans.intersect(...operation.shapes.map(recurse));
         case "subtract":
-          return jscad5.booleans.subtract(...operation.shapes.map(recurse));
+          return jscad6.booleans.subtract(...operation.shapes.map(recurse));
         case "union":
-          return jscad5.booleans.union(...operation.shapes.map(recurse));
+          return jscad6.booleans.union(...operation.shapes.map(recurse));
         case "hull":
-          return jscad5.hulls.hull(...operation.shapes.map(recurse));
+          return jscad6.hulls.hull(...operation.shapes.map(recurse));
         case "hullChain":
-          return jscad5.hulls.hullChain(...operation.shapes.map(recurse));
+          return jscad6.hulls.hullChain(...operation.shapes.map(recurse));
         case "colorize":
-          return jscad5.colors.colorize(operation.color, recurse(operation.shape));
+          return jscad6.colors.colorize(operation.color, recurse(operation.shape));
         case "cube":
-          return jscad5.primitives.cube(params);
+          return jscad6.primitives.cube(params);
         case "sphere":
-          return jscad5.primitives.sphere(params);
+          return jscad6.primitives.sphere(params);
         case "cylinder":
-          return jscad5.primitives.cylinder(params);
+          return jscad6.primitives.cylinder(params);
         case "polygon":
-          return jscad5.primitives.polygon(params);
+          return jscad6.primitives.polygon(params);
         case "cuboid":
-          return jscad5.primitives.cuboid(params);
+          return jscad6.primitives.cuboid(params);
         case "roundedCuboid":
-          return jscad5.primitives.roundedCuboid(params);
+          return jscad6.primitives.roundedCuboid(params);
         case "rotate":
-          return jscad5.transforms.rotate(operation.angles, recurse(operation.shape));
+          return jscad6.transforms.rotate(operation.angles, recurse(operation.shape));
         case "scale":
-          return jscad5.transforms.scale(operation.factors, recurse(operation.shape));
+          return jscad6.transforms.scale(operation.factors, recurse(operation.shape));
         case "translate":
-          return jscad5.transforms.translate(
+          return jscad6.transforms.translate(
             operation.vector,
             recurse(operation.shape)
           );
         case "extrudeLinear":
-          return jscad5.extrusions.extrudeLinear(
+          return jscad6.extrusions.extrudeLinear(
             operation.options,
             recurse(operation.shape)
           );
         case "extrudeRotate":
-          return jscad5.extrusions.extrudeRotate(
+          return jscad6.extrusions.extrudeRotate(
             operation.options,
             recurse(operation.shape)
           );
         case "createGeom2":
-          return jscad5.geometries.geom2.create(operation.points);
+          return jscad6.geometries.geom2.create(operation.points);
         case "createGeom3":
-          return jscad5.geometries.geom3.create(operation.polygons);
+          return jscad6.geometries.geom3.create(operation.polygons);
         case "createPath2":
-          return jscad5.geometries.path2.create(operation.points);
+          return jscad6.geometries.path2.create(operation.points);
         case "measureBoundingBox":
-          return jscad5.measurements.measureBoundingBox(recurse(operation.shape));
+          return jscad6.measurements.measureBoundingBox(recurse(operation.shape));
         case "measureArea":
-          return jscad5.measurements.measureArea(recurse(operation.shape));
+          return jscad6.measurements.measureArea(recurse(operation.shape));
         case "measureVolume":
-          return jscad5.measurements.measureVolume(recurse(operation.shape));
+          return jscad6.measurements.measureVolume(recurse(operation.shape));
         case "degToRad":
-          return jscad5.utils.degToRad(operation.degrees);
+          return jscad6.utils.degToRad(operation.degrees);
         case "radToDeg":
-          return jscad5.utils.radToDeg(operation.radians);
+          return jscad6.utils.radToDeg(operation.radians);
         default:
           if (operation.type === void 0) {
             throw new Error(
@@ -14789,10 +14789,11 @@ var Html = ({ children, position, style }) => {
   return portal;
 };
 
-// node_modules/@tscircuit/modelprinter/index.js
+// node_modules/jscad-electronics/node_modules/@tscircuit/modelprinter/index.js
+import { z as z3 } from "zod";
 import { z as z2 } from "zod";
 
-// node_modules/@tscircuit/mm/dist/index.js
+// node_modules/jscad-electronics/node_modules/@tscircuit/modelprinter/node_modules/@tscircuit/mm/dist/index.js
 var unitToMm = {
   in: 25.4,
   inch: 25.4,
@@ -14819,11 +14820,10 @@ var mm = (n) => {
   throw new Error(`Unsupported unit: ${unit}`);
 };
 
-// node_modules/@tscircuit/modelprinter/index.js
+// node_modules/jscad-electronics/node_modules/@tscircuit/modelprinter/index.js
 import { z } from "zod";
-import { z as z3 } from "zod";
-import { z as z5 } from "zod";
 import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var modelLengthSchema = z.union([z.number(), z.string()]).transform((value, context) => {
   try {
     const parsed = mm(value);
@@ -14845,13 +14845,111 @@ var nonnegativeModelLengthSchema = modelLengthSchema.refine(
   (value) => value >= 0,
   "Length cannot be negative"
 );
-var nemaSizeSchema = z2.union([
-  z2.literal(8),
-  z2.literal(17),
-  z2.literal(23)
+var hexSocketBoltDimensions = {
+  M2: {
+    diameter: 2,
+    threadPitch: 0.4,
+    headDiameter: 3.8,
+    headHeight: 2,
+    socketWidth: 1.5,
+    socketDepth: 1
+  },
+  "M2.5": {
+    diameter: 2.5,
+    threadPitch: 0.45,
+    headDiameter: 4.5,
+    headHeight: 2.5,
+    socketWidth: 2,
+    socketDepth: 1.1
+  },
+  M3: {
+    diameter: 3,
+    threadPitch: 0.5,
+    headDiameter: 5.5,
+    headHeight: 3,
+    socketWidth: 2.5,
+    socketDepth: 1.3
+  },
+  M4: {
+    diameter: 4,
+    threadPitch: 0.7,
+    headDiameter: 7,
+    headHeight: 4,
+    socketWidth: 3,
+    socketDepth: 2
+  },
+  M5: {
+    diameter: 5,
+    threadPitch: 0.8,
+    headDiameter: 8.5,
+    headHeight: 5,
+    socketWidth: 4,
+    socketDepth: 2.5
+  },
+  M6: {
+    diameter: 6,
+    threadPitch: 1,
+    headDiameter: 10,
+    headHeight: 6,
+    socketWidth: 5,
+    socketDepth: 3
+  },
+  M8: {
+    diameter: 8,
+    threadPitch: 1.25,
+    headDiameter: 13,
+    headHeight: 8,
+    socketWidth: 6,
+    socketDepth: 4
+  },
+  M10: {
+    diameter: 10,
+    threadPitch: 1.5,
+    headDiameter: 16,
+    headHeight: 10,
+    socketWidth: 8,
+    socketDepth: 5
+  },
+  M12: {
+    diameter: 12,
+    threadPitch: 1.75,
+    headDiameter: 18,
+    headHeight: 12,
+    socketWidth: 10,
+    socketDepth: 6
+  }
+};
+var metricBoltSizeSchema = z2.enum([
+  "M2",
+  "M2.5",
+  "M3",
+  "M4",
+  "M5",
+  "M6",
+  "M8",
+  "M10",
+  "M12"
+]);
+var hexSocketBoltModelPropsShape = {
+  metricSize: metricBoltSizeSchema,
+  /** Length under the head, excluding the head itself. */
+  length: positiveModelLengthSchema,
+  showThreads: z2.boolean().default(true)
+};
+var hexSocketBoltModelPropsSchema = z2.object(hexSocketBoltModelPropsShape).strict();
+var hexSocketBoltModelDefinitionSchema = z2.object({
+  fn: z2.literal("hexsocketbolt"),
+  ...hexSocketBoltModelPropsShape
+}).strict();
+var nemaSizeSchema = z3.union([
+  z3.literal(8),
+  z3.literal(17),
+  z3.literal(23)
 ]);
 var nemaMotorDimensions = {
   8: {
+    backFaceScrewSize: "M2",
+    backFaceHoleDepth: 2,
     bodyWidth: 20.3,
     bodyLength: 33,
     mountingHoleSpacing: 16,
@@ -14872,6 +14970,8 @@ var nemaMotorDimensions = {
     bodyCornerChamfer: 3
   },
   17: {
+    backFaceScrewSize: "M3",
+    backFaceHoleDepth: 4.5,
     bodyWidth: 42.3,
     bodyLength: 38,
     mountingHoleSpacing: 31,
@@ -14892,6 +14992,8 @@ var nemaMotorDimensions = {
     bodyCornerChamfer: 6
   },
   23: {
+    backFaceScrewSize: "M4",
+    backFaceHoleDepth: 4.5,
     bodyWidth: 56.4,
     bodyLength: 51,
     mountingHoleSpacing: 47.14,
@@ -14914,24 +15016,37 @@ var nemaMotorDimensions = {
 };
 var shape = {
   nemaSize: nemaSizeSchema,
+  /** Rear cap at Z=-bodyLength: bare, open bores or installed cap screws. */
+  backFace: z3.enum(["plain", "holes", "screws"]).optional(),
+  backFaceHoleSpacing: positiveModelLengthSchema.optional(),
+  backFaceHoleDiameter: positiveModelLengthSchema.optional(),
+  backFaceHoleDepth: positiveModelLengthSchema.optional(),
+  backFaceScrewSize: metricBoltSizeSchema.optional(),
+  /** Visual termination; the wireside reference exists even when hidden. */
+  wireConnection: z3.enum(["none", "stubs", "jst-ph-6"]).optional(),
+  /** Counterclockwise angle about local +Z; 0 is the +X side. */
+  wireSideAngle: z3.number().finite().optional(),
+  wireLength: positiveModelLengthSchema.optional(),
+  wireDiameter: positiveModelLengthSchema.optional(),
+  wireCount: z3.number().int().min(2).max(8).optional(),
   bodyWidth: positiveModelLengthSchema.optional(),
   bodyLength: positiveModelLengthSchema.optional(),
   mountingHoleSpacing: positiveModelLengthSchema.optional(),
   mountingHoleDiameter: positiveModelLengthSchema.optional(),
   mountingHoleDepth: positiveModelLengthSchema.optional(),
-  mountingHoleThrough: z2.boolean().optional(),
+  mountingHoleThrough: z3.boolean().optional(),
   pilotDiameter: positiveModelLengthSchema.optional(),
   pilotLength: positiveModelLengthSchema.optional(),
   /** Distance from mounting face Z=0 to shaft tip, including pilot height. */
   shaftLength: positiveModelLengthSchema.optional(),
   shaftDiameter: positiveModelLengthSchema.optional(),
-  shaftShape: z2.enum(["round", "d"]).optional(),
+  shaftShape: z3.enum(["round", "d"]).optional(),
   /** Radial material removed from the +X side before rotation. */
   shaftFlatDepth: nonnegativeModelLengthSchema.optional(),
   /** Flat extends back from the tip; leaves a round shoulder above the pilot. */
   shaftFlatLength: nonnegativeModelLengthSchema.optional(),
   /** Degrees around +Z, counterclockwise; zero puts the flat on +X. */
-  shaftFlatAngle: z2.number().finite().optional(),
+  shaftFlatAngle: z3.number().finite().optional(),
   frontCapLength: positiveModelLengthSchema.optional(),
   rearCapLength: positiveModelLengthSchema.optional(),
   faceCornerChamfer: nonnegativeModelLengthSchema.optional(),
@@ -14939,8 +15054,20 @@ var shape = {
 };
 var resolve = (p) => {
   const d = nemaMotorDimensions[p.nemaSize];
+  const backFaceScrewSize = p.backFaceScrewSize ?? d.backFaceScrewSize;
+  const screw = hexSocketBoltDimensions[backFaceScrewSize];
   return {
     nemaSize: p.nemaSize,
+    wireConnection: p.wireConnection ?? "stubs",
+    wireSideAngle: ((p.wireSideAngle ?? 0) % 360 + 360) % 360,
+    wireLength: p.wireLength ?? 6,
+    wireDiameter: p.wireDiameter ?? 1.2,
+    wireCount: p.wireCount ?? 4,
+    backFace: p.backFace ?? "screws",
+    backFaceHoleSpacing: p.backFaceHoleSpacing ?? p.mountingHoleSpacing ?? d.mountingHoleSpacing,
+    backFaceHoleDiameter: p.backFaceHoleDiameter ?? screw.diameter,
+    backFaceHoleDepth: p.backFaceHoleDepth ?? d.backFaceHoleDepth,
+    backFaceScrewSize,
     bodyWidth: p.bodyWidth ?? d.bodyWidth,
     bodyLength: p.bodyLength ?? d.bodyLength,
     mountingHoleSpacing: p.mountingHoleSpacing ?? d.mountingHoleSpacing,
@@ -14963,6 +15090,26 @@ var resolve = (p) => {
 };
 var validate = (p, ctx) => {
   const issue = (message) => ctx.addIssue({ code: "custom", message });
+  if (p.backFace !== "plain") {
+    const screw = hexSocketBoltDimensions[p.backFaceScrewSize];
+    const radius = (p.backFace === "screws" ? Math.max(p.backFaceHoleDiameter, screw.headDiameter) : p.backFaceHoleDiameter) / 2;
+    if (p.backFaceHoleSpacing <= 2 * radius)
+      issue("Rear holes and screw heads must not overlap each other");
+    if (p.backFaceHoleSpacing + 2 * radius >= p.bodyWidth || p.bodyWidth - p.faceCornerChamfer - p.backFaceHoleSpacing <= radius * Math.SQRT2)
+      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");
+    if (p.backFace === "screws" && p.backFaceHoleDiameter < screw.diameter)
+      issue("Rear holes must accommodate the screw diameter");
+  }
+  if (p.wireConnection === "stubs") {
+    if (p.wireDiameter * p.wireCount * 1.5 > p.bodyWidth - 2 * p.faceCornerChamfer)
+      issue("Wire bundle must fit on the cap side");
+    if (p.wireDiameter >= p.rearCapLength)
+      issue("Wire diameter must fit within the rear cap");
+  }
+  if (p.wireConnection === "jst-ph-6" && p.bodyWidth - 2 * p.faceCornerChamfer < 13.9)
+    issue("Six-position JST-PH header must fit on the motor side");
   const r = p.mountingHoleDiameter / 2;
   if (p.frontCapLength + p.rearCapLength >= p.bodyLength)
     issue("End caps must leave a positive body length");
@@ -14979,7 +15126,7 @@ var validate = (p, ctx) => {
   if (!p.mountingHoleThrough && p.mountingHoleDepth >= p.frontCapLength)
     issue("Blind mounting hole depth must be less than the front cap length");
   if (p.mountingHoleThrough && p.bodyWidth - p.bodyCornerChamfer - p.mountingHoleSpacing >= -r * Math.SQRT2)
-    issue("Body and rear cap must clear through mounting holes");
+    issue("Body must clear through front mounting holes");
   if (p.shaftLength <= p.pilotLength)
     issue("Shaft tip must extend beyond the pilot");
   if (p.shaftShape === "d" && (p.shaftFlatDepth <= 0 || p.shaftFlatDepth >= p.shaftDiameter / 2 || p.shaftFlatLength <= 0 || p.shaftFlatLength > p.shaftLength - p.pilotLength))
@@ -14987,31 +15134,31 @@ var validate = (p, ctx) => {
       "D flat must have positive depth less than the shaft radius and fit above the pilot"
     );
 };
-var nemaMotorModelPropsSchema = z2.object(shape).strict().transform(resolve).superRefine(validate);
-var nemaMotorModelDefinitionSchema = z2.object({ fn: z2.literal("nema"), ...shape }).strict().transform(({ fn, ...props }) => ({ fn, ...resolve(props) })).superRefine(validate);
+var nemaMotorModelPropsSchema = z3.object(shape).strict().transform(resolve).superRefine(validate);
+var nemaMotorModelDefinitionSchema = z3.object({ fn: z3.literal("nema"), ...shape }).strict().transform(({ fn, ...props }) => ({ fn, ...resolve(props) })).superRefine(validate);
 var holePosition = {
-  panel: z3.enum(["base", "left", "right"]),
+  panel: z4.enum(["base", "left", "right"]),
   /** Panel-local mm, centered on its straight section: u along its length,
    * v along the sheet width. Side-panel u increases upward. */
   u: modelLengthSchema,
   v: modelLengthSchema
 };
-var sheetMetalHoleSchema = z3.discriminatedUnion("shape", [
-  z3.object({
+var sheetMetalHoleSchema = z4.discriminatedUnion("shape", [
+  z4.object({
     ...holePosition,
-    shape: z3.literal("round"),
+    shape: z4.literal("round"),
     diameter: positiveModelLengthSchema
   }).strict(),
-  z3.object({
+  z4.object({
     ...holePosition,
-    shape: z3.literal("slot"),
+    shape: z4.literal("slot"),
     length: positiveModelLengthSchema,
     width: positiveModelLengthSchema,
-    axis: z3.enum(["u", "v"]).default("v")
+    axis: z4.enum(["u", "v"]).default("v")
   }).strict()
 ]);
 var sheetMetalShape = {
-  profile: z3.enum(["plate", "angle", "channel"]).default("plate"),
+  profile: z4.enum(["plate", "angle", "channel"]).default("plate"),
   width: positiveModelLengthSchema,
   /** Straight base length between bend tangencies, not overall width. */
   baseLength: positiveModelLengthSchema,
@@ -15019,106 +15166,10 @@ var sheetMetalShape = {
   flangeHeight: positiveModelLengthSchema.default(12),
   thickness: positiveModelLengthSchema.default(1),
   insideBendRadius: positiveModelLengthSchema.default(1),
-  holes: z3.array(sheetMetalHoleSchema).max(100).default([])
+  holes: z4.array(sheetMetalHoleSchema).max(100).default([])
 };
-var sheetMetalModelPropsSchema = z3.object(sheetMetalShape).strict();
-var sheetMetalModelDefinitionSchema = z3.object({ fn: z3.literal("sheetmetal"), ...sheetMetalShape }).strict();
-var hexSocketBoltDimensions = {
-  M2: {
-    diameter: 2,
-    threadPitch: 0.4,
-    headDiameter: 3.8,
-    headHeight: 2,
-    socketWidth: 1.5,
-    socketDepth: 1
-  },
-  "M2.5": {
-    diameter: 2.5,
-    threadPitch: 0.45,
-    headDiameter: 4.5,
-    headHeight: 2.5,
-    socketWidth: 2,
-    socketDepth: 1.1
-  },
-  M3: {
-    diameter: 3,
-    threadPitch: 0.5,
-    headDiameter: 5.5,
-    headHeight: 3,
-    socketWidth: 2.5,
-    socketDepth: 1.3
-  },
-  M4: {
-    diameter: 4,
-    threadPitch: 0.7,
-    headDiameter: 7,
-    headHeight: 4,
-    socketWidth: 3,
-    socketDepth: 2
-  },
-  M5: {
-    diameter: 5,
-    threadPitch: 0.8,
-    headDiameter: 8.5,
-    headHeight: 5,
-    socketWidth: 4,
-    socketDepth: 2.5
-  },
-  M6: {
-    diameter: 6,
-    threadPitch: 1,
-    headDiameter: 10,
-    headHeight: 6,
-    socketWidth: 5,
-    socketDepth: 3
-  },
-  M8: {
-    diameter: 8,
-    threadPitch: 1.25,
-    headDiameter: 13,
-    headHeight: 8,
-    socketWidth: 6,
-    socketDepth: 4
-  },
-  M10: {
-    diameter: 10,
-    threadPitch: 1.5,
-    headDiameter: 16,
-    headHeight: 10,
-    socketWidth: 8,
-    socketDepth: 5
-  },
-  M12: {
-    diameter: 12,
-    threadPitch: 1.75,
-    headDiameter: 18,
-    headHeight: 12,
-    socketWidth: 10,
-    socketDepth: 6
-  }
-};
-var metricBoltSizeSchema = z4.enum([
-  "M2",
-  "M2.5",
-  "M3",
-  "M4",
-  "M5",
-  "M6",
-  "M8",
-  "M10",
-  "M12"
-]);
-var hexSocketBoltModelPropsShape = {
-  metricSize: metricBoltSizeSchema,
-  /** Length under the head, excluding the head itself. */
-  length: positiveModelLengthSchema,
-  showThreads: z4.boolean().default(true)
-};
-var hexSocketBoltModelPropsSchema = z4.object(hexSocketBoltModelPropsShape).strict();
-var hexSocketBoltModelDefinitionSchema = z4.object({
-  fn: z4.literal("hexsocketbolt"),
-  ...hexSocketBoltModelPropsShape
-}).strict();
+var sheetMetalModelPropsSchema = z4.object(sheetMetalShape).strict();
+var sheetMetalModelDefinitionSchema = z4.object({ fn: z4.literal("sheetmetal"), ...sheetMetalShape }).strict();
 var flexScreenOrientationSchema = z5.enum([
   "sitsFlat",
   "sitsFlatBelowBoard",
@@ -15308,10 +15359,15 @@ var parseModelStringParams = (definition) => {
   return params;
 };
 var lengths = {
+  wirelength: "wireLength",
+  wirediameter: "wireDiameter",
   l: "bodyLength",
   length: "bodyLength",
   bodylength: "bodyLength",
   bodywidth: "bodyWidth",
+  backholespacing: "backFaceHoleSpacing",
+  backholediameter: "backFaceHoleDiameter",
+  backholedepth: "backFaceHoleDepth",
   shaftlength: "shaftLength",
   shaftdiameter: "shaftDiameter",
   flatdepth: "shaftFlatDepth",
@@ -15342,10 +15398,26 @@ function parseNemaMotorModelParams(raw) {
     if (name in lengths) {
       property = lengths[name];
       parsed = value;
-    } else if (name === "flatangle") {
-      property = "shaftFlatAngle";
+    } else if (["backfaceholes", "backfacescrews", "plainbackface"].includes(name)) {
+      if (value) throw new Error(`NEMA flag "${name}" does not accept a value`);
+      property = "backFace";
+      parsed = name === "backfaceholes" ? "holes" : name === "backfacescrews" ? "screws" : "plain";
+    } else if (["wirestubs", "nowires"].includes(name) || name === "jstph") {
+      if (name === "jstph" && value !== "6" || name !== "jstph" && value)
+        throw new Error(`Invalid wire connection token "${token}"`);
+      property = "wireConnection";
+      parsed = name === "jstph" ? "jst-ph-6" : name === "nowires" ? "none" : "stubs";
+    } else if (name === "wirecount") {
+      property = "wireCount";
+      if (!/^\d+$/.test(value)) throw new Error("wirecount requires an integer");
+      parsed = Number(value);
+    } else if (name === "backscrewm") {
+      property = "backFaceScrewSize";
+      parsed = `M${value}`;
+    } else if (name === "flatangle" || name === "wireangle") {
+      property = name === "flatangle" ? "shaftFlatAngle" : "wireSideAngle";
       if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:deg)?$/i.test(value))
-        throw new Error("flatangle requires a numeric angle in degrees");
+        throw new Error(`${name} requires a numeric angle in degrees`);
       parsed = Number(value.replace(/deg$/i, ""));
     } else if (["round", "dshaft", "throughholes", "blindholes"].includes(name)) {
       if (value) throw new Error(`NEMA flag "${name}" does not accept a value`);
@@ -15729,6 +15801,50 @@ var modelprinter = {
   getModelNames: () => Object.keys(modelFunctions)
 };
 var mp = modelprinter;
+function getNemaMotorReferencePoints(input) {
+  const p = nemaMotorModelPropsSchema.parse(input);
+  const radians = p.wireSideAngle * Math.PI / 180;
+  const x = Math.cos(radians), y = Math.sin(radians);
+  const radius = Math.min(
+    p.bodyWidth / 2 / Math.max(Math.abs(x), Math.abs(y)),
+    (p.bodyWidth - p.faceCornerChamfer) / (Math.abs(x) + Math.abs(y))
+  );
+  const flatRadians = p.shaftFlatAngle * Math.PI / 180;
+  return {
+    frontface: {
+      position: { x: 0, y: 0, z: 0 },
+      direction: { x: 0, y: 0, z: 1 }
+    },
+    backface: {
+      position: { x: 0, y: 0, z: -p.bodyLength },
+      direction: { x: 0, y: 0, z: -1 }
+    },
+    shafttip: {
+      position: { x: 0, y: 0, z: p.shaftLength },
+      direction: { x: 0, y: 0, z: 1 }
+    },
+    wireside: {
+      position: {
+        x: radius * x,
+        y: radius * y,
+        z: -p.bodyLength + p.rearCapLength / 2
+      },
+      direction: { x, y, z: 0 }
+    },
+    shaftflat: p.shaftShape === "d" ? {
+      position: {
+        x: (p.shaftDiameter / 2 - p.shaftFlatDepth) * Math.cos(flatRadians),
+        y: (p.shaftDiameter / 2 - p.shaftFlatDepth) * Math.sin(flatRadians),
+        z: p.shaftLength - p.shaftFlatLength / 2
+      },
+      direction: {
+        x: Math.cos(flatRadians),
+        y: Math.sin(flatRadians),
+        z: 0
+      }
+    } : void 0
+  };
+}
 
 // node_modules/@tscircuit/footprinter/dist/index.js
 import {
@@ -29901,6 +30017,7 @@ function signedArea(data, start, end, dim) {
 
 // node_modules/jscad-electronics/dist/vanilla.js
 var import_modeling2 = __toESM(require_src(), 1);
+var import_modeling3 = __toESM(require_src(), 1);
 
 // node_modules/jscad-electronics/node_modules/@tscircuit/mm/dist/index.js
 var unitToMm3 = {
@@ -30065,7 +30182,7 @@ var createHexSocketBoltMesh = (input) => {
   } = hexSocketBoltDimensions[props.metricSize];
   const { length: length83, showThreads } = props;
   const segments = 96;
-  const steps = Math.max(2, Math.ceil(length83 / pitch * 24));
+  const steps = showThreads ? Math.max(2, Math.ceil(length83 / pitch * 24)) : 2;
   if (steps > 24e3)
     throw new Error(
       "Bolt length exceeds mesh resolution limit (1000 thread turns)"
@@ -30101,8 +30218,11 @@ var createHexSocketBoltMesh = (input) => {
     }
   };
   let previous = -1;
-  for (let step = 0; step <= steps; step++) {
-    const z27 = -length83 + length83 * step / steps;
+  const shaftLevels = showThreads ? Array.from(
+    { length: steps + 1 },
+    (_, step) => -length83 + length83 * step / steps
+  ) : [-length83, -length83 + tipBevel, 0];
+  for (const z27 of shaftLevels) {
     const current = ring(z27, (angle) => {
       const phase = ((z27 / pitch - angle / (2 * Math.PI)) % 1 + 1) % 1;
       const distance22 = Math.min(phase, 1 - phase);
@@ -30307,6 +30427,64 @@ function SheetMetal({ color = "#737e8f", ...props }) {
 var resolveNemaMotorProps = nemaMotorModelPropsSchema.parse.bind(
   nemaMotorModelPropsSchema
 );
+function createNemaMotorWireGeometry(input) {
+  const p = resolveNemaMotorProps(input);
+  if (p.wireConnection === "none") return [];
+  const { position } = getNemaMotorReferencePoints(p).wireside;
+  const angle = p.wireSideAngle * Math.PI / 180;
+  const place = (geometry) => import_modeling3.default.transforms.translate(
+    [position.x, position.y, position.z],
+    import_modeling3.default.transforms.rotateZ(angle, geometry)
+  );
+  if (p.wireConnection === "stubs") {
+    const colors2 = [
+      "#d53f3f",
+      "#2463af",
+      "#3b934b",
+      "#252830",
+      "#e5d049",
+      "#eeeeee",
+      "#ce7432",
+      "#803e91"
+    ];
+    return Array.from({ length: p.wireCount }, (_, i) => ({
+      color: colors2[i],
+      geometry: place(
+        import_modeling3.default.transforms.translate(
+          [
+            (p.wireLength - 0.15) / 2,
+            (i - (p.wireCount - 1) / 2) * p.wireDiameter * 1.5,
+            0
+          ],
+          import_modeling3.default.transforms.rotateY(
+            Math.PI / 2,
+            import_modeling3.default.primitives.cylinder({
+              height: p.wireLength + 0.15,
+              radius: p.wireDiameter / 2,
+              segments: 24
+            })
+          )
+        )
+      )
+    }));
+  }
+  const shell = import_modeling3.default.booleans.subtract(
+    import_modeling3.default.primitives.cuboid({ size: [6.1, 13.9, 4.5], center: [2.95, 0, 0] }),
+    import_modeling3.default.primitives.cuboid({ size: [5.5, 12.7, 3.3], center: [3.55, 0, 0] })
+  );
+  return [
+    { color: "#eeeeea", geometry: place(shell) },
+    ...Array.from({ length: 6 }, (_, i) => ({
+      color: "#b8bec6",
+      geometry: place(
+        import_modeling3.default.primitives.cuboid({
+          size: [3.4, 0.5, 0.5],
+          center: [1.7, (i - 2.5) * 2, 0]
+        })
+      )
+    }))
+  ];
+}
 var circle = (radius, x = 0, y = 0) => Array.from({ length: 96 }, (_, i) => [
   x + radius * Math.cos(i * Math.PI / 48),
   y + radius * Math.sin(i * Math.PI / 48)
@@ -30353,12 +30531,34 @@ function createNemaMotorSections(input) {
   add("frontCap", front, -holeDepth, 0, holes);
   add("frontCap", front, -p.frontCapLength, -holeDepth);
   add("body", core, -p.bodyLength + p.rearCapLength, -p.frontCapLength);
-  add(
-    "rearCap",
-    p.mountingHoleThrough ? core : front,
-    -p.bodyLength,
-    -p.bodyLength + p.rearCapLength
-  );
+  if (p.backFace === "plain") {
+    add(
+      "rearCap",
+      p.mountingHoleThrough ? core : front,
+      -p.bodyLength,
+      -p.bodyLength + p.rearCapLength
+    );
+  } else {
+    const halfPitch = p.backFaceHoleSpacing / 2;
+    const rearHoles = [-halfPitch, halfPitch].flatMap(
+      (x) => [-halfPitch, halfPitch].map(
+        (y) => circle(p.backFaceHoleDiameter / 2, x, y)
+      )
+    );
+    add(
+      "rearCap",
+      front,
+      -p.bodyLength,
+      -p.bodyLength + p.backFaceHoleDepth,
+      rearHoles
+    );
+    add(
+      "rearCap",
+      front,
+      -p.bodyLength + p.backFaceHoleDepth,
+      -p.bodyLength + p.rearCapLength
+    );
+  }
   add("pilot", circle(p.pilotDiameter / 2), 0, p.pilotLength);
   const r = p.shaftDiameter / 2;
   const round2 = circle(r);
@@ -30381,34 +30581,60 @@ function createNemaMotorSections(input) {
   }
   return sections;
 }
+var generalize = import_modeling2.default.modifiers.generalize;
 function NemaMotor({
   bodyColor = "#242830",
   capColor = "#aeb5bd",
   shaftColor = "#b8bec6",
+  screwColor = "#626b78",
   ...props
 }) {
-  return /* @__PURE__ */ jsx3(Fragment2, { children: createNemaMotorSections(props).map((section, index2) => {
-    const outline = import_modeling2.default.geometries.geom2.fromPoints(section.outline);
-    const profile = section.holes.length ? import_modeling2.default.booleans.subtract(
-      outline,
-      ...section.holes.map((h2) => import_modeling2.default.geometries.geom2.fromPoints(h2))
-    ) : outline;
-    const geometry = import_modeling2.default.transforms.translate(
-      [0, 0, section.zMin],
-      import_modeling2.default.extrusions.extrudeLinear(
-        { height: section.zMax - section.zMin },
-        profile
-      )
-    );
-    return /* @__PURE__ */ jsx3(
-      Colorize,
-      {
-        color: section.name === "body" ? bodyColor : section.name === "shaft" ? shaftColor : capColor,
-        children: /* @__PURE__ */ jsx3(Custom, { geometry })
-      },
-      `${section.name}-${index2}`
-    );
-  }) });
+  const p = resolveNemaMotorProps(props);
+  const screw = p.backFace === "screws" ? import_modeling2.default.transforms.rotateX(
+    Math.PI,
+    createHexSocketBoltGeom({
+      metricSize: p.backFaceScrewSize,
+      length: p.backFaceHoleDepth,
+      showThreads: false
+    })
+  ) : void 0;
+  const halfPitch = p.backFaceHoleSpacing / 2;
+  return /* @__PURE__ */ jsxs(Fragment2, { children: [
+    createNemaMotorSections(p).map((section, index2) => {
+      const outline = import_modeling2.default.geometries.geom2.fromPoints(section.outline);
+      const profile = section.holes.length ? import_modeling2.default.booleans.subtract(
+        outline,
+        ...section.holes.map((h2) => import_modeling2.default.geometries.geom2.fromPoints(h2))
+      ) : outline;
+      const geometry = import_modeling2.default.transforms.translate(
+        [0, 0, section.zMin],
+        import_modeling2.default.extrusions.extrudeLinear(
+          { height: section.zMax - section.zMin },
+          profile
+        )
+      );
+      return /* @__PURE__ */ jsx3(
+        Colorize,
+        {
+          color: section.name === "body" ? bodyColor : section.name === "shaft" ? shaftColor : capColor,
+          children: /* @__PURE__ */ jsx3(Custom, { geometry: generalize({ simplify: true }, geometry) })
+        },
+        `${section.name}-${index2}`
+      );
+    }),
+    createNemaMotorWireGeometry(p).map(({ geometry, color }, index2) => /* @__PURE__ */ jsx3(Colorize, { color, children: /* @__PURE__ */ jsx3(Custom, { geometry: generalize({ simplify: true }, geometry) }) }, `wire-${index2}`)),
+    screw && [-halfPitch, halfPitch].flatMap(
+      (x) => [-halfPitch, halfPitch].map((y) => /* @__PURE__ */ jsx3(Colorize, { color: screwColor, children: /* @__PURE__ */ jsx3(
+        Custom,
+        {
+          geometry: import_modeling2.default.transforms.translate(
+            [x, y, -p.bodyLength],
+            generalize({ simplify: true }, screw)
+          )
+        }
+      ) }, `rear-screw-${x}-${y}`))
+    )
+  ] });
 }
 function LGA(p) {
   for (const k of [
@@ -39017,8 +39243,8 @@ function renderNode(node, colorCtx, renderCtx) {
   }
   return (children ?? []).flatMap((c) => renderNode(c, colorCtx, renderCtx));
 }
-function render(root, jscad32) {
-  const geometries = renderNode(root, void 0, { jscad: jscad32 });
+function render(root, jscad42) {
+  const geometries = renderNode(root, void 0, { jscad: jscad42 });
   return { geometries };
 }
 function convertCSGToThreeGeom(csg) {
@@ -39097,9 +39323,9 @@ function convertCSGToThreeGeom(csg) {
   console.error("Invalid CSG object: neither polygons nor sides found");
   return new BufferGeometry();
 }
-function getJscadModelForFootprint(footprint, jscad32) {
+function getJscadModelForFootprint(footprint, jscad42) {
   const vnode = h(Footprinter3d, { footprint });
-  return render(vnode, jscad32);
+  return render(vnode, jscad42);
 }
 
 // src/three-components/FootprinterModel.tsx
@@ -39702,7 +39928,7 @@ function GltfModel({
 
 // src/three-components/JscadModel.tsx
 var import_jscad_planner = __toESM(require_dist(), 1);
-var import_modeling3 = __toESM(require_src(), 1);
+var import_modeling4 = __toESM(require_src(), 1);
 import * as THREE11 from "three";
 import { useState as useState6, useEffect as useEffect9 } from "react";
 import { jsx as jsx8 } from "react/jsx-runtime";
@@ -39723,7 +39949,7 @@ var JscadModel = ({
 }) => {
   const [mesh, setMesh] = useState6(null);
   useEffect9(() => {
-    const jscadObject = (0, import_jscad_planner.executeJscadOperations)(import_modeling3.default, jscadPlan);
+    const jscadObject = (0, import_jscad_planner.executeJscadOperations)(import_modeling4.default, jscadPlan);
     if (!jscadObject || !jscadObject.polygons && !jscadObject.sides) {
       setMesh(null);
       return;
@@ -40888,7 +41114,7 @@ import * as THREE25 from "three";
 // package.json
 var package_default = {
   name: "@tscircuit/3d-viewer",
-  version: "0.0.612",
+  version: "0.0.613",
   repository: {
     type: "git",
     url: "https://github.com/tscircuit/3d-viewer"
@@ -40926,7 +41152,7 @@ var package_default = {
   dependencies: {
     "@jscad/regl-renderer": "^2.6.12",
     "@jscad/stl-serializer": "^2.1.20",
-    "circuit-json": "^0.0.500",
+    "circuit-json": "^0.0.514",
     "circuit-to-canvas": "^0.0.131",
     "react-hot-toast": "^2.6.0",
     three: "^0.165.0",
@@ -40951,10 +41177,10 @@ var package_default = {
     "@storybook/blocks": "9.0.0-alpha.17",
     "@storybook/react-vite": "^9.1.5",
     "@tscircuit/alphabet": "^0.0.25",
-    "@tscircuit/circuit-json-util": "^0.0.116",
+    "@tscircuit/circuit-json-util": "^0.0.119",
     "@tscircuit/copper-pour-solver": "^0.0.29",
-    "@tscircuit/core": "^0.0.1972",
-    "@tscircuit/props": "^0.0.666",
+    "@tscircuit/core": "^0.0.2075",
+    "@tscircuit/props": "^0.0.684",
     "@tscircuit/solver-utils": "^0.0.4",
     "@types/debug": "^4.1.13",
     "@types/jsdom": "^21.1.7",
@@ -40965,7 +41191,7 @@ var package_default = {
     "bun-match-svg": "^0.0.9",
     "bun-types": "1.2.1",
     debug: "^4.4.0",
-    "jscad-electronics": "^0.0.182",
+    "jscad-electronics": "^0.0.184",
     "jscad-planner": "^0.0.13",
     jsdom: "^26.0.0",
     "manifold-3d": "^3.2.1",
@@ -40977,9 +41203,9 @@ var package_default = {
     typescript: "^5.7.3",
     vite: "^7.1.5",
     "vite-tsconfig-paths": "^4.3.2",
-    "circuit-json-to-gltf": "0.0.129",
+    "circuit-json-to-gltf": "0.0.143",
     zod: "^3.25.67",
-    "@tscircuit/modelprinter": "^0.0.4"
+    "@tscircuit/modelprinter": "^0.0.6"
   },
   engines: {
     node: "24.x"
@@ -57699,7 +57925,7 @@ function createGeometryFromPolygons(polygons) {
 }
 
 // src/utils/render-component.tsx
-var import_modeling4 = __toESM(require_src(), 1);
+var import_modeling5 = __toESM(require_src(), 1);
 var import_jscad_planner2 = __toESM(require_dist(), 1);
 var jscadModeling2 = __toESM(require_src(), 1);
 import * as THREE57 from "three";
@@ -57762,7 +57988,7 @@ async function renderComponent(component, scene) {
   }
   if (component.model_jscad) {
     const jscadObject = (0, import_jscad_planner2.executeJscadOperations)(
-      import_modeling4.default,
+      import_modeling5.default,
       component.model_jscad
     );
     if (jscadObject && (jscadObject.polygons || jscadObject.sides)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/3d-viewer",
-  "version": "0.0.613",
+  "version": "0.0.614",
   "repository": {
     "type": "git",
     "url": "https://github.com/tscircuit/3d-viewer"
@@ -38,7 +38,7 @@
   "dependencies": {
     "@jscad/regl-renderer": "^2.6.12",
     "@jscad/stl-serializer": "^2.1.20",
-    "circuit-json": "^0.0.500",
+    "circuit-json": "^0.0.514",
     "circuit-to-canvas": "^0.0.131",
     "react-hot-toast": "^2.6.0",
     "three": "^0.165.0",
@@ -63,10 +63,10 @@
     "@storybook/blocks": "9.0.0-alpha.17",
     "@storybook/react-vite": "^9.1.5",
     "@tscircuit/alphabet": "^0.0.25",
-    "@tscircuit/circuit-json-util": "^0.0.116",
+    "@tscircuit/circuit-json-util": "^0.0.119",
     "@tscircuit/copper-pour-solver": "^0.0.29",
-    "@tscircuit/core": "^0.0.1972",
-    "@tscircuit/props": "^0.0.666",
+    "@tscircuit/core": "^0.0.2075",
+    "@tscircuit/props": "^0.0.684",
     "@tscircuit/solver-utils": "^0.0.4",
     "@types/debug": "^4.1.13",
     "@types/jsdom": "^21.1.7",
@@ -77,7 +77,7 @@
     "bun-match-svg": "^0.0.9",
     "bun-types": "1.2.1",
     "debug": "^4.4.0",
-    "jscad-electronics": "^0.0.182",
+    "jscad-electronics": "^0.0.184",
     "jscad-planner": "^0.0.13",
     "jsdom": "^26.0.0",
     "manifold-3d": "^3.2.1",
@@ -89,9 +89,9 @@
     "typescript": "^5.7.3",
     "vite": "^7.1.5",
     "vite-tsconfig-paths": "^4.3.2",
-    "circuit-json-to-gltf": "0.0.129",
+    "circuit-json-to-gltf": "0.0.143",
     "zod": "^3.25.67",
-    "@tscircuit/modelprinter": "^0.0.4"
+    "@tscircuit/modelprinter": "^0.0.6"
   },
   "engines": {
     "node": "24.x"