jscad-electronics 0.0.223 → 0.0.228

package/dist/vanilla.js

@@ -24,7 +24,7 @@ function h(type, props, ...restChildren) {
   };
 }
 
-// .model-contracts/generations/a0c3adcab6538807c2f328e983467915c62ee778-v2/node_modules/zod/v3/external.js
+// .model-contracts/generations/a2cdaa0ea42c20364c601d990971fef4f4e234fc-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/a0c3adcab6538807c2f328e983467915c62ee778-v2/node_modules/zod/v3/helpers/util.js
+// .model-contracts/generations/a2cdaa0ea42c20364c601d990971fef4f4e234fc-v2/node_modules/zod/v3/helpers/util.js
 var util;
 (function(util2) {
   util2.assertEqual = (_) => {
@@ -270,7 +270,7 @@ var getParsedType = (data) => {
   }
 };
 
-// .model-contracts/generations/a0c3adcab6538807c2f328e983467915c62ee778-v2/node_modules/zod/v3/ZodError.js
+// .model-contracts/generations/a2cdaa0ea42c20364c601d990971fef4f4e234fc-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/a0c3adcab6538807c2f328e983467915c62ee778-v2/node_modules/zod/v3/locales/en.js
+// .model-contracts/generations/a2cdaa0ea42c20364c601d990971fef4f4e234fc-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/a0c3adcab6538807c2f328e983467915c62ee778-v2/node_modules/zod/v3/errors.js
+// .model-contracts/generations/a2cdaa0ea42c20364c601d990971fef4f4e234fc-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/a0c3adcab6538807c2f328e983467915c62ee778-v2/node_modules/zod/v3/helpers/parseUtil.js
+// .model-contracts/generations/a2cdaa0ea42c20364c601d990971fef4f4e234fc-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/a0c3adcab6538807c2f328e983467915c62ee778-v2/node_modules/zod/v3/helpers/errorUtil.js
+// .model-contracts/generations/a2cdaa0ea42c20364c601d990971fef4f4e234fc-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/a0c3adcab6538807c2f328e983467915c62ee778-v2/node_modules/zod/v3/types.js
+// .model-contracts/generations/a2cdaa0ea42c20364c601d990971fef4f4e234fc-v2/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
   constructor(parent, value, path, key) {
     this._cachedPath = [];
@@ -2402,9 +2402,9 @@ var ZodObject = class _ZodObject extends ZodType {
   _getCached() {
     if (this._cached !== null)
       return this._cached;
-    const shape33 = this._def.shape();
-    const keys = util.objectKeys(shape33);
-    this._cached = { shape: shape33, keys };
+    const shape39 = this._def.shape();
+    const keys = util.objectKeys(shape39);
+    this._cached = { shape: shape39, keys };
     return this._cached;
   }
   _parse(input) {
@@ -2419,7 +2419,7 @@ var ZodObject = class _ZodObject extends ZodType {
       return INVALID;
     }
     const { status, ctx } = this._processInputParams(input);
-    const { shape: shape33, keys: shapeKeys } = this._getCached();
+    const { shape: shape39, keys: shapeKeys } = this._getCached();
     const extraKeys = [];
     if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
       for (const key in ctx.data) {
@@ -2430,7 +2430,7 @@ var ZodObject = class _ZodObject extends ZodType {
     }
     const pairs = [];
     for (const key of shapeKeys) {
-      const keyValidator = shape33[key];
+      const keyValidator = shape39[key];
       const value = ctx.data[key];
       pairs.push({
         key: { status: "valid", value: key },
@@ -2636,27 +2636,27 @@ var ZodObject = class _ZodObject extends ZodType {
     });
   }
   pick(mask) {
-    const shape33 = {};
+    const shape39 = {};
     for (const key of util.objectKeys(mask)) {
       if (mask[key] && this.shape[key]) {
-        shape33[key] = this.shape[key];
+        shape39[key] = this.shape[key];
       }
     }
     return new _ZodObject({
       ...this._def,
-      shape: () => shape33
+      shape: () => shape39
     });
   }
   omit(mask) {
-    const shape33 = {};
+    const shape39 = {};
     for (const key of util.objectKeys(this.shape)) {
       if (!mask[key]) {
-        shape33[key] = this.shape[key];
+        shape39[key] = this.shape[key];
       }
     }
     return new _ZodObject({
       ...this._def,
-      shape: () => shape33
+      shape: () => shape39
     });
   }
   /**
@@ -2703,27 +2703,27 @@ var ZodObject = class _ZodObject extends ZodType {
     return createZodEnum(util.objectKeys(this.shape));
   }
 };
-ZodObject.create = (shape33, params) => {
+ZodObject.create = (shape39, params) => {
   return new ZodObject({
-    shape: () => shape33,
+    shape: () => shape39,
     unknownKeys: "strip",
     catchall: ZodNever.create(),
     typeName: ZodFirstPartyTypeKind.ZodObject,
     ...processCreateParams(params)
   });
 };
-ZodObject.strictCreate = (shape33, params) => {
+ZodObject.strictCreate = (shape39, params) => {
   return new ZodObject({
-    shape: () => shape33,
+    shape: () => shape39,
     unknownKeys: "strict",
     catchall: ZodNever.create(),
     typeName: ZodFirstPartyTypeKind.ZodObject,
     ...processCreateParams(params)
   });
 };
-ZodObject.lazycreate = (shape33, params) => {
+ZodObject.lazycreate = (shape39, params) => {
   return new ZodObject({
-    shape: shape33,
+    shape: shape39,
     unknownKeys: "strip",
     catchall: ZodNever.create(),
     typeName: ZodFirstPartyTypeKind.ZodObject,
@@ -4065,7 +4065,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// .model-contracts/generations/a0c3adcab6538807c2f328e983467915c62ee778-v2/node_modules/@tscircuit/mm/dist/index.js
+// .model-contracts/generations/a2cdaa0ea42c20364c601d990971fef4f4e234fc-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/a0c3adcab6538807c2f328e983467915c62ee778-v2/index.js
+// .model-contracts/generations/a2cdaa0ea42c20364c601d990971fef4f4e234fc-v2/index.js
 function normalizeNemaMotorModelString(value) {
   if (!/^nema(?:8|17|23)(?:_|$)/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");
@@ -4178,55 +4178,55 @@ var stringFlags = {
   male: "threadgender(male)"
 };
 var omittedStringFlags = ["righthanded", "male"];
-function defineModel(model392) {
-  return model392;
+function defineModel(model452) {
+  return model452;
 }
 var ModelRegistry = class {
   models = /* @__PURE__ */ new Map();
-  register(model392) {
-    if (typeof model392.name !== "string" || !/^[a-z]+$/.test(model392.name)) {
+  register(model452) {
+    if (typeof model452.name !== "string" || !/^[a-z]+$/.test(model452.name)) {
       throw new Error("Model names must contain only lowercase letters");
     }
-    if (this.models.has(model392.name)) {
+    if (this.models.has(model452.name)) {
       throw new Error(
-        `Modelprinter function "${model392.name}" is already registered`
+        `Modelprinter function "${model452.name}" is already registered`
       );
     }
-    if (model392.normalizeString !== void 0 && typeof model392.normalizeString !== "function")
+    if (model452.normalizeString !== void 0 && typeof model452.normalizeString !== "function")
       throw new Error("Model string normalizer must be a function");
-    this.models.set(model392.name, {
-      name: model392.name,
-      schema: model392.schema,
-      parse: model392.parse,
-      normalizeString: model392.normalizeString
+    this.models.set(model452.name, {
+      name: model452.name,
+      schema: model452.schema,
+      parse: model452.parse,
+      normalizeString: model452.normalizeString
     });
   }
   getModelNames() {
     return [...this.models.keys()];
   }
   normalize(params) {
-    const model392 = this.models.get(params.fn);
-    if (!model392?.normalizeString) return params;
-    const value = model392.normalizeString(params.string);
+    const model452 = this.models.get(params.fn);
+    if (!model452?.normalizeString) return params;
+    const value = model452.normalizeString(params.string);
     if (typeof value !== "string")
-      throw new Error(`Normalizer for "${model392.name}" must return a string`);
+      throw new Error(`Normalizer for "${model452.name}" must return a string`);
     if (value === params.string) return params;
     const normalized = parseModelStringParams(value);
-    if (normalized.fn !== model392.name)
+    if (normalized.fn !== model452.name)
       throw new Error(
-        `Normalizer for "${model392.name}" must preserve the model name`
+        `Normalizer for "${model452.name}" must preserve the model name`
       );
     return normalized;
   }
   parse(params) {
-    const model392 = this.models.get(params.fn);
-    if (!model392) {
+    const model452 = this.models.get(params.fn);
+    if (!model452) {
       throw new Error(`Unsupported modelprinter function "${params.fn}"`);
     }
-    const definition = model392.parse(params);
-    if (definition === null || typeof definition !== "object" || Array.isArray(definition) || definition.fn !== model392.name) {
+    const definition = model452.parse(params);
+    if (definition === null || typeof definition !== "object" || Array.isArray(definition) || definition.fn !== model452.name) {
       throw new Error(
-        `Parser for "${model392.name}" must return a model with fn "${model392.name}"`
+        `Parser for "${model452.name}" must return a model with fn "${model452.name}"`
       );
     }
     return definition;
@@ -5091,7 +5091,7 @@ var sheetMetalShape = {
 };
 var sheetMetalModelPropsSchema = external_exports.object(sheetMetalShape).strict();
 var sheetMetalModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("sheetmetal"), ...sheetMetalShape }).strict();
-function parseSheetMetalFeature(feature, profile) {
+function parseSheetMetalFeature(feature, profile6) {
   const match = feature.match(/^(hole|slot)[1-9]\d*\(([^()]+)\)$/);
   if (!match) throw new Error(`Invalid sheet metal feature "${feature}"`);
   const kind = match[1];
@@ -5124,8 +5124,8 @@ function parseSheetMetalFeature(feature, profile) {
   if (faces.length !== 1)
     throw new Error(`Specify exactly one face in ${feature}`);
   const face2 = faces[0];
-  if (face2 === "angledface" && profile !== "angle" || ["leftface", "rightface"].includes(face2) && profile !== "channel")
-    throw new Error(`No ${face2} on ${profile}`);
+  if (face2 === "angledface" && profile6 !== "angle" || ["leftface", "rightface"].includes(face2) && profile6 !== "channel")
+    throw new Error(`No ${face2} on ${profile6}`);
   for (const [a, b] of [
     ["leftofcenter", "rightofcenter"],
     ["abovecenter", "belowcenter"],
@@ -5155,12 +5155,12 @@ function parseSheetMetalFeature(feature, profile) {
   }
   if (!("l" in values) || !("w" in values))
     throw new Error(`Slot requires l and w in ${feature}`);
-  const length20 = distance2("l"), width10 = distance2("w");
-  if (length20 < width10) throw new Error("Slot length must be at least its width");
+  const length26 = distance2("l"), width10 = distance2("w");
+  if (length26 < width10) throw new Error("Slot length must be at least its width");
   return sheetMetalHoleSchema.parse({
     ...position,
     shape: "slot",
-    length: length20,
+    length: length26,
     width: width10,
     axis: panel === "base" === !("vertical" in values) ? "u" : "v"
   });
@@ -5363,9 +5363,9 @@ var flexScreenModelPropsSchema = external_exports.object(flexScreenModelPropsSha
 var flexScreenModelDefinitionSchema = external_exports.object({
   fn: external_exports.literal("flexscreen"),
   ...flexScreenModelPropsShape
-}).strict().superRefine((model392, context) => {
-  validateTailLengths(model392, context);
-  addOrientationShortcutIssue(model392, (path) => {
+}).strict().superRefine((model452, context) => {
+  validateTailLengths(model452, context);
+  addOrientationShortcutIssue(model452, (path) => {
     context.addIssue({
       code: "custom",
       message: "Only one FlexScreen orientation shortcut can be true",
@@ -5868,6 +5868,90 @@ var model9 = defineModel({
 function register9(registry2) {
   registry2.register(model9);
 }
+var length2 = external_exports.union([
+  external_exports.number(),
+  external_exports.string().regex(/^[+]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
+]).pipe(modelLengthSchema);
+var positiveLength = length2.refine(
+  (value) => value > 0,
+  "Length must be positive"
+);
+var nonnegativeLength = length2.refine(
+  (value) => value >= 0,
+  "Length cannot be negative"
+);
+var shape6 = {
+  width: positiveLength,
+  height: positiveLength,
+  thickness: positiveLength,
+  length: positiveLength,
+  innerRadius: nonnegativeLength.default(0),
+  tipRadius: nonnegativeLength.default(0)
+};
+function validate6(p, context) {
+  if (p.thickness >= Math.min(p.width, p.height))
+    context.addIssue({
+      code: "custom",
+      message: "Invalid anglebar dimensions: constraint 1"
+    });
+  if (p.innerRadius >= Math.min(p.width, p.height) - p.thickness)
+    context.addIssue({
+      code: "custom",
+      message: "Invalid anglebar dimensions: constraint 2"
+    });
+  if (2 * p.tipRadius >= p.thickness)
+    context.addIssue({
+      code: "custom",
+      message: "Invalid anglebar dimensions: constraint 3"
+    });
+  if (p.innerRadius + p.tipRadius >= Math.min(p.width, p.height) - p.thickness)
+    context.addIssue({
+      code: "custom",
+      message: "Invalid anglebar dimensions: constraint 4"
+    });
+}
+var angleBarModelPropsSchema = external_exports.object(shape6).strict().superRefine(validate6);
+var angleBarModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("anglebar"), ...shape6 }).strict().superRefine(validate6);
+var aliases2 = {
+  w: "width",
+  h: "height",
+  t: "thickness",
+  l: "length",
+  innerr: "innerRadius",
+  tipr: "tipRadius",
+  width: "width",
+  height: "height",
+  thickness: "thickness",
+  length: "length",
+  innerradius: "innerRadius",
+  tipradius: "tipRadius"
+};
+function parseAngleBarModelParams(raw) {
+  const [name, ...tokens] = splitModelStringTokens(raw.string);
+  if (raw.fn !== "anglebar" || name?.toLowerCase() !== "anglebar")
+    throw new Error("Expected anglebar without inline values");
+  const props = { fn: "anglebar" };
+  for (const token of tokens) {
+    const match = token.match(/^([a-z]+)(.*)$/i);
+    const key = match?.[1]?.toLowerCase();
+    const value = match?.[2];
+    if (!key || !Object.hasOwn(aliases2, key) || !value)
+      throw new Error(`Unknown or malformed anglebar token "${token}"`);
+    const property = aliases2[key];
+    if (Object.hasOwn(props, property))
+      throw new Error(`Duplicate anglebar property "${property}"`);
+    props[property] = value;
+  }
+  return angleBarModelDefinitionSchema.parse(props);
+}
+var model10 = defineModel({
+  name: "anglebar",
+  schema: angleBarModelDefinitionSchema,
+  parse: parseAngleBarModelParams
+});
+function register10(registry2) {
+  registry2.register(model10);
+}
 var ballBearingStandardSizes = {
   "608": { innerDiameter: 8, outerDiameter: 22, width: 7 },
   "625": { innerDiameter: 5, outerDiameter: 16, width: 5 },
@@ -5889,14 +5973,14 @@ var ballBearingCodeSchema = external_exports.enum([
   "6001",
   "6002"
 ]);
-var positiveLength = external_exports.union([
+var positiveLength2 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema).refine((value) => value > 0, "Length must be positive");
-var shape6 = {
-  innerDiameter: positiveLength.optional(),
-  outerDiameter: positiveLength.optional(),
-  width: positiveLength.optional(),
+var shape7 = {
+  innerDiameter: positiveLength2.optional(),
+  outerDiameter: positiveLength2.optional(),
+  width: positiveLength2.optional(),
   code: ballBearingCodeSchema.optional(),
   bothSidesOpen: external_exports.boolean().optional(),
   bothSidesShielded: external_exports.boolean().optional(),
@@ -5958,8 +6042,8 @@ function resolve2(input, context) {
     });
   return props;
 }
-var ballBearingModelPropsSchema = external_exports.object(shape6).strict().transform(resolve2);
-var ballBearingModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("ballbearing"), ...shape6 }).strict().transform((input, context) => ({ fn: input.fn, ...resolve2(input, context) }));
+var ballBearingModelPropsSchema = external_exports.object(shape7).strict().transform(resolve2);
+var ballBearingModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("ballbearing"), ...shape7 }).strict().transform((input, context) => ({ fn: input.fn, ...resolve2(input, context) }));
 function getBallBearingDimensions(input = {}) {
   const props = ballBearingModelPropsSchema.parse(input);
   const boreRadius = props.innerDiameter / 2;
@@ -6094,14 +6178,14 @@ function normalizeBallBearingModelString(value) {
   const faces = top === bottom ? `bothsides${top}` : `topside${top}_bottomside${bottom}`;
   return `ballbearing_id${decimal(props.innerDiameter)}mm_od${decimal(props.outerDiameter)}mm_w${decimal(props.width)}mm_${faces}`;
 }
-var model10 = defineModel({
+var model11 = defineModel({
   name: "ballbearing",
   schema: ballBearingModelDefinitionSchema,
   parse: parseBallBearingModelParams,
   normalizeString: normalizeBallBearingModelString
 });
-function register10(registry2) {
-  registry2.register(model10);
+function register11(registry2) {
+  registry2.register(model11);
 }
 var ballTransferUnitDefaults = {
   ballDiameter: 25,
@@ -6115,19 +6199,19 @@ var ballTransferUnitDefaults = {
   socketClearance: 0.25,
   faceThreeHole: true
 };
-var length2 = external_exports.union([
+var length3 = external_exports.union([
   external_exports.number().finite(),
   external_exports.string().regex(
     /^[+]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i,
     "Expected a complete length with a supported unit"
   ).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema);
-var positive2 = length2.refine((value) => value > 0, "Length must be positive");
-var nonnegative = length2.refine(
+var positive2 = length3.refine((value) => value > 0, "Length must be positive");
+var nonnegative = length3.refine(
   (value) => value >= 0,
   "Length cannot be negative"
 );
-var shape7 = {
+var shape8 = {
   ballDiameter: positive2.default(ballTransferUnitDefaults.ballDiameter),
   bodyDiameter: positive2.default(ballTransferUnitDefaults.bodyDiameter),
   /** Overall height from the flat body bottom to the load-ball top. */
@@ -6145,7 +6229,7 @@ var shape7 = {
   ),
   faceThreeHole: external_exports.literal(true).default(true)
 };
-function validate6(props, context) {
+function validate7(props, context) {
   const issue = (path, message) => context.addIssue({ code: "custom", path: [path], message });
   const ballRadius = props.ballDiameter / 2;
   const socketRadius = ballRadius + props.socketClearance;
@@ -6174,8 +6258,8 @@ function validate6(props, context) {
   if (props.holeDiameter >= props.pitchCircleDiameter * Math.sqrt(3) / 2)
     issue("holeDiameter", "Mounting holes must not intersect one another");
 }
-var ballTransferUnitModelPropsSchema = external_exports.object(shape7).strict().superRefine(validate6);
-var ballTransferUnitModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("balltransferunit"), ...shape7 }).strict().superRefine(validate6);
+var ballTransferUnitModelPropsSchema = external_exports.object(shape8).strict().superRefine(validate7);
+var ballTransferUnitModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("balltransferunit"), ...shape8 }).strict().superRefine(validate7);
 function getBallTransferUnitDimensions(input = {}) {
   const props = ballTransferUnitModelPropsSchema.parse(input);
   const ballRadius = props.ballDiameter / 2;
@@ -6252,13 +6336,13 @@ function parseBallTransferUnitModelParams(raw) {
   }
   return ballTransferUnitModelDefinitionSchema.parse(props);
 }
-var model11 = defineModel({
+var model12 = defineModel({
   name: "balltransferunit",
   schema: ballTransferUnitModelDefinitionSchema,
   parse: parseBallTransferUnitModelParams
 });
-function register11(registry2) {
-  registry2.register(model11);
+function register12(registry2) {
+  registry2.register(model12);
 }
 var stringFlags2 = {
   hexsocket: "drive(hexsocket)",
@@ -6316,24 +6400,24 @@ var buttonScrewDimensions = {
     referenceThreadLength: 24
   }
 };
-var length3 = external_exports.union([
+var length4 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema).refine((value) => value > 0, "Length must be positive");
 var buttonScrewMetricSizeSchema = external_exports.enum(["M3", "M4", "M5", "M6"]);
-var shape8 = {
+var shape9 = {
   iso73801: external_exports.literal(true).default(true),
   metricSize: buttonScrewMetricSizeSchema,
   /** Under-head length; this family supports short fully threaded screws only. */
-  length: length3,
+  length: length4,
   drive: external_exports.literal("hexsocket").default("hexsocket"),
   thread: external_exports.literal("full").default("full"),
-  threadPitch: length3.optional(),
+  threadPitch: length4.optional(),
   threadHand: external_exports.literal("right").default("right"),
   threadClass: external_exports.literal("6g").default("6g"),
   showThreads: external_exports.boolean().default(true)
 };
-function validate7(props, context) {
+function validate8(props, context) {
   const dimensions5 = buttonScrewDimensions[props.metricSize];
   if (props.threadPitch !== void 0 && Math.abs(props.threadPitch - dimensions5.threadPitch) > 1e-9)
     context.addIssue({
@@ -6360,8 +6444,8 @@ function normalize(props) {
     threadPitch: buttonScrewDimensions[props.metricSize].threadPitch
   };
 }
-var buttonScrewModelPropsSchema = external_exports.object(shape8).strict().superRefine(validate7).transform(normalize);
-var buttonScrewModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("buttonscrew"), ...shape8 }).strict().superRefine(validate7).transform(normalize);
+var buttonScrewModelPropsSchema = external_exports.object(shape9).strict().superRefine(validate8).transform(normalize);
+var buttonScrewModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("buttonscrew"), ...shape9 }).strict().superRefine(validate8).transform(normalize);
 function getButtonScrewDimensions(input) {
   const props = buttonScrewModelPropsSchema.parse(input);
   const dims = buttonScrewDimensions[props.metricSize];
@@ -6435,7 +6519,7 @@ function parseButtonScrewModelParams(raw) {
   }
   return buttonScrewModelDefinitionSchema.parse(props);
 }
-var model12 = defineModel({
+var model13 = defineModel({
   name: "buttonscrew",
   schema: buttonScrewModelDefinitionSchema,
   parse: parseButtonScrewModelParams,
@@ -6446,31 +6530,31 @@ var model12 = defineModel({
     omittedStringFlags2
   )
 });
-function register12(registry2) {
-  registry2.register(model12);
+function register13(registry2) {
+  registry2.register(model13);
 }
 var stringFlags3 = {
   symmetricring: "shape(symmetricring)"
 };
 var omittedStringFlags3 = [];
-var length4 = external_exports.union([
+var length5 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(
     /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i,
     "Expected a complete numeric length with an optional unit"
   )
 ]).pipe(positiveModelLengthSchema);
-var shape9 = {
-  panelHoleDiameter: length4,
-  innerDiameter: length4,
-  outerDiameter: length4,
-  height: length4,
-  grooveWidth: length4,
+var shape10 = {
+  panelHoleDiameter: length5,
+  innerDiameter: length5,
+  outerDiameter: length5,
+  height: length5,
+  grooveWidth: length5,
   /** Radial recess from the flange outside diameter. */
-  grooveDepth: length4,
+  grooveDepth: length5,
   shape: external_exports.literal("symmetricring").default("symmetricring")
 };
-function validate8(props, context) {
+function validate9(props, context) {
   if (props.innerDiameter >= props.panelHoleDiameter || props.panelHoleDiameter >= props.outerDiameter)
     context.addIssue({
       code: "custom",
@@ -6497,8 +6581,8 @@ function validate8(props, context) {
       message: "Derived root wall and flange thicknesses must be positive"
     });
 }
-var cableGrommetModelPropsSchema = external_exports.object(shape9).strict().superRefine(validate8);
-var cableGrommetModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("cablegrommet"), ...shape9 }).strict().superRefine(validate8);
+var cableGrommetModelPropsSchema = external_exports.object(shape10).strict().superRefine(validate9);
+var cableGrommetModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("cablegrommet"), ...shape10 }).strict().superRefine(validate9);
 function getCableGrommetDimensions(input) {
   const props = cableGrommetModelPropsSchema.parse(input);
   const grooveRootDiameter = props.outerDiameter - 2 * props.grooveDepth;
@@ -6551,7 +6635,7 @@ function parseCableGrommetModelParams(raw) {
   }
   return cableGrommetModelDefinitionSchema.parse(props);
 }
-var model13 = defineModel({
+var model14 = defineModel({
   name: "cablegrommet",
   schema: cableGrommetModelDefinitionSchema,
   parse: parseCableGrommetModelParams,
@@ -6562,8 +6646,100 @@ var model13 = defineModel({
     omittedStringFlags3
   )
 });
-function register13(registry2) {
-  registry2.register(model13);
+function register14(registry2) {
+  registry2.register(model14);
+}
+var length6 = external_exports.union([
+  external_exports.number(),
+  external_exports.string().regex(/^[+]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
+]).pipe(modelLengthSchema);
+var positiveLength3 = length6.refine(
+  (value) => value > 0,
+  "Length must be positive"
+);
+var nonnegativeLength2 = length6.refine(
+  (value) => value >= 0,
+  "Length cannot be negative"
+);
+var shape11 = {
+  width: positiveLength3,
+  height: positiveLength3,
+  webThickness: positiveLength3,
+  flangeThickness: positiveLength3,
+  length: positiveLength3,
+  innerRadius: nonnegativeLength2.default(0),
+  tipRadius: nonnegativeLength2.default(0)
+};
+function validate10(p, context) {
+  if (2 * p.flangeThickness >= p.width)
+    context.addIssue({
+      code: "custom",
+      message: "Invalid channelbar dimensions: constraint 1"
+    });
+  if (p.webThickness >= p.height)
+    context.addIssue({
+      code: "custom",
+      message: "Invalid channelbar dimensions: constraint 2"
+    });
+  if (2 * p.innerRadius >= p.width - 2 * p.flangeThickness)
+    context.addIssue({
+      code: "custom",
+      message: "Invalid channelbar dimensions: constraint 3"
+    });
+  if (p.innerRadius + p.tipRadius >= p.height - p.webThickness)
+    context.addIssue({
+      code: "custom",
+      message: "Invalid channelbar dimensions: constraint 4"
+    });
+  if (2 * p.tipRadius >= p.flangeThickness)
+    context.addIssue({
+      code: "custom",
+      message: "Invalid channelbar dimensions: constraint 5"
+    });
+}
+var channelBarModelPropsSchema = external_exports.object(shape11).strict().superRefine(validate10);
+var channelBarModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("channelbar"), ...shape11 }).strict().superRefine(validate10);
+var aliases3 = {
+  w: "width",
+  h: "height",
+  web: "webThickness",
+  flange: "flangeThickness",
+  l: "length",
+  innerr: "innerRadius",
+  tipr: "tipRadius",
+  width: "width",
+  height: "height",
+  webthickness: "webThickness",
+  flangethickness: "flangeThickness",
+  length: "length",
+  innerradius: "innerRadius",
+  tipradius: "tipRadius"
+};
+function parseChannelBarModelParams(raw) {
+  const [name, ...tokens] = splitModelStringTokens(raw.string);
+  if (raw.fn !== "channelbar" || name?.toLowerCase() !== "channelbar")
+    throw new Error("Expected channelbar without inline values");
+  const props = { fn: "channelbar" };
+  for (const token of tokens) {
+    const match = token.match(/^([a-z]+)(.*)$/i);
+    const key = match?.[1]?.toLowerCase();
+    const value = match?.[2];
+    if (!key || !Object.hasOwn(aliases3, key) || !value)
+      throw new Error(`Unknown or malformed channelbar token "${token}"`);
+    const property = aliases3[key];
+    if (Object.hasOwn(props, property))
+      throw new Error(`Duplicate channelbar property "${property}"`);
+    props[property] = value;
+  }
+  return channelBarModelDefinitionSchema.parse(props);
+}
+var model15 = defineModel({
+  name: "channelbar",
+  schema: channelBarModelDefinitionSchema,
+  parse: parseChannelBarModelParams
+});
+function register15(registry2) {
+  registry2.register(model15);
 }
 var stringFlags4 = {
   singleclamp: "mount(singleclamp)",
@@ -6571,19 +6747,19 @@ var stringFlags4 = {
   righthanded: "threadhand(right)"
 };
 var omittedStringFlags4 = ["righthanded"];
-var length5 = external_exports.union([
+var length7 = external_exports.union([
   external_exports.number().finite(),
   external_exports.string().regex(
     /^[+]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i,
     "Expected a complete length with a supported unit"
   ).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema);
-var positive3 = length5.refine((value) => value > 0, "Length must be positive");
-var nonnegative2 = length5.refine(
+var positive3 = length7.refine((value) => value > 0, "Length must be positive");
+var nonnegative2 = length7.refine(
   (value) => value >= 0,
   "Length cannot be negative"
 );
-var shape10 = {
+var shape12 = {
   boreDiameter: positive3,
   outerDiameter: positive3,
   width: positive3,
@@ -6609,7 +6785,7 @@ function resolve3(props) {
     clearanceHoleDiameter: props.clearanceHoleDiameter ?? threadDiameter + 0.5
   };
 }
-function validate9(props, context) {
+function validate11(props, context) {
   const p = resolve3(props);
   const issue = (message) => context.addIssue({ code: "custom", message });
   const diameter = hexSocketBoltDimensions[p.metricSize].diameter;
@@ -6636,8 +6812,8 @@ function validate9(props, context) {
   if (p.clampX + radius < outerRadius && p.splitWidth / 2 >= Math.sqrt(outerRadius ** 2 - (p.clampX + radius) ** 2))
     issue("Split must leave material around both sides of the clamping bore");
 }
-var clampingShaftCollarModelPropsSchema = external_exports.object(shape10).strict().superRefine(validate9).transform(resolve3);
-var clampingShaftCollarModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("clampingshaftcollar"), ...shape10 }).strict().superRefine(validate9).transform((props) => ({ fn: props.fn, ...resolve3(props) }));
+var clampingShaftCollarModelPropsSchema = external_exports.object(shape12).strict().superRefine(validate11).transform(resolve3);
+var clampingShaftCollarModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("clampingshaftcollar"), ...shape12 }).strict().superRefine(validate11).transform((props) => ({ fn: props.fn, ...resolve3(props) }));
 function getClampingShaftCollarDimensions(input) {
   const p = clampingShaftCollarModelPropsSchema.parse(input);
   const threadDiameter = hexSocketBoltDimensions[p.metricSize].diameter;
@@ -6727,7 +6903,7 @@ function parseClampingShaftCollarModelParams(raw) {
     ...props
   });
 }
-var model14 = defineModel({
+var model16 = defineModel({
   name: "clampingshaftcollar",
   schema: clampingShaftCollarModelDefinitionSchema,
   parse: parseClampingShaftCollarModelParams,
@@ -6738,8 +6914,8 @@ var model14 = defineModel({
     omittedStringFlags4
   )
 });
-function register14(registry2) {
-  registry2.register(model14);
+function register16(registry2) {
+  registry2.register(model16);
 }
 var stringFlags5 = {
   closedground: "ends(closedground)",
@@ -6749,16 +6925,16 @@ var stringFlags5 = {
   free: "state(free)"
 };
 var omittedStringFlags5 = ["righthanded", "custom", "free"];
-var length6 = external_exports.union([
+var length8 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema).refine((value) => value > 0, "Length must be positive");
 var turnCount = external_exports.number().int().min(1).max(Number.MAX_SAFE_INTEGER);
-var shape11 = {
+var shape13 = {
   spec: external_exports.literal("custom").default("custom"),
-  outerDiameter: length6,
-  wireDiameter: length6,
-  freeLength: length6,
+  outerDiameter: length8,
+  wireDiameter: length8,
+  freeLength: length8,
   totalTurns: turnCount.min(3),
   /** Closed-ground ends have exactly one inactive turn at each end. */
   activeTurns: turnCount.optional(),
@@ -6766,7 +6942,7 @@ var shape11 = {
   hand: external_exports.enum(["right", "left"]).default("right"),
   state: external_exports.literal("free").default("free")
 };
-function validate10(props, context) {
+function validate12(props, context) {
   if (props.outerDiameter <= 2 * props.wireDiameter)
     context.addIssue({
       code: "custom",
@@ -6790,8 +6966,8 @@ function validate10(props, context) {
 function normalize2(props) {
   return { ...props, activeTurns: props.activeTurns ?? props.totalTurns - 2 };
 }
-var compressionSpringModelPropsSchema = external_exports.object(shape11).strict().superRefine(validate10).transform(normalize2);
-var compressionSpringModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("compressionspring"), ...shape11 }).strict().superRefine(validate10).transform(normalize2);
+var compressionSpringModelPropsSchema = external_exports.object(shape13).strict().superRefine(validate12).transform(normalize2);
+var compressionSpringModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("compressionspring"), ...shape13 }).strict().superRefine(validate12).transform(normalize2);
 function getCompressionSpringDimensions(input) {
   const props = compressionSpringModelPropsSchema.parse(input);
   return {
@@ -6818,8 +6994,8 @@ function getCompressionSpringCenterlinePoint(input, turn) {
   const radius = (props.outerDiameter - props.wireDiameter) / 2;
   const pitch = (props.freeLength - 2 * props.wireDiameter) / props.activeTurns;
   const phase = (props.hand === "right" ? 1 : -1) * 2 * Math.PI * (turn % 1);
-  const z43 = turn <= 1 ? props.wireDiameter * turn : turn >= props.totalTurns - 1 ? props.freeLength - props.wireDiameter * (props.totalTurns - turn) : props.wireDiameter + pitch * (turn - 1);
-  return { x: radius * Math.cos(phase), y: radius * Math.sin(phase), z: z43 };
+  const z49 = turn <= 1 ? props.wireDiameter * turn : turn >= props.totalTurns - 1 ? props.freeLength - props.wireDiameter * (props.totalTurns - turn) : props.wireDiameter + pitch * (turn - 1);
+  return { x: radius * Math.cos(phase), y: radius * Math.sin(phase), z: z49 };
 }
 function parseCompressionSpringModelParams(raw) {
   const tokens = splitModelStringTokens(
@@ -6866,7 +7042,7 @@ function parseCompressionSpringModelParams(raw) {
   }
   return compressionSpringModelDefinitionSchema.parse(props);
 }
-var model15 = defineModel({
+var model17 = defineModel({
   name: "compressionspring",
   schema: compressionSpringModelDefinitionSchema,
   parse: parseCompressionSpringModelParams,
@@ -6877,10 +7053,10 @@ var model15 = defineModel({
     omittedStringFlags5
   )
 });
-function register15(registry2) {
-  registry2.register(model15);
+function register17(registry2) {
+  registry2.register(model17);
 }
-var length7 = external_exports.union([
+var length9 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema).refine((value) => value > 0, "Length must be positive");
@@ -6936,16 +7112,16 @@ var near = (a, b) => Math.abs(a - b) <= 1e-9;
 function selectedDiameter(diameter) {
   return diameterValues.find((value) => near(value, diameter));
 }
-var shape12 = {
+var shape14 = {
   /** The pinned ISO contract is the default and cannot be disabled. */
   iso8734: external_exports.literal(true).default(true),
-  diameter: length7,
+  diameter: length9,
   /** Overall distance between the two flat end planes, including leads. */
-  length: length7,
-  endLeadLength: length7.optional(),
+  length: length9,
+  endLeadLength: length9.optional(),
   endLeadAngle: external_exports.number().finite().positive().optional()
 };
-function validate11(props, context) {
+function validate13(props, context) {
   const issue = (path, message) => context.addIssue({ code: "custom", path: [path], message });
   const diameter = selectedDiameter(props.diameter);
   if (diameter === void 0) {
@@ -6981,8 +7157,8 @@ function resolve4(props) {
     endLeadAngle: 15
   };
 }
-var dowelPinModelPropsSchema = external_exports.object(shape12).strict().superRefine(validate11).transform(resolve4);
-var dowelPinModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("dowelpin"), ...shape12 }).strict().superRefine(validate11).transform(resolve4);
+var dowelPinModelPropsSchema = external_exports.object(shape14).strict().superRefine(validate13).transform(resolve4);
+var dowelPinModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("dowelpin"), ...shape14 }).strict().superRefine(validate13).transform(resolve4);
 function getDowelPinDimensions(input) {
   const props = dowelPinModelPropsSchema.parse(input);
   return {
@@ -7030,13 +7206,13 @@ function parseDowelPinModelParams(raw) {
   }
   return dowelPinModelDefinitionSchema.parse(props);
 }
-var model16 = defineModel({
+var model18 = defineModel({
   name: "dowelpin",
   schema: dowelPinModelDefinitionSchema,
   parse: parseDowelPinModelParams
 });
-function register16(registry2) {
-  registry2.register(model16);
+function register18(registry2) {
+  registry2.register(model18);
 }
 var femaleStandoffMetricDimensions = {
   M2: { diameter: 2, threadPitch: 0.4, acrossFlats: 4 },
@@ -7049,26 +7225,26 @@ var femaleStandoffMetricDimensions = {
   M10: { diameter: 10, threadPitch: 1.5, acrossFlats: 17 },
   M12: { diameter: 12, threadPitch: 1.75, acrossFlats: 19 }
 };
-var length8 = external_exports.union([
+var length10 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema);
-var positiveLength2 = length8.refine(
+var positiveLength4 = length10.refine(
   (value) => value > 0,
   "Length must be positive"
 );
-var shape13 = {
+var shape15 = {
   metricSize: external_exports.enum(["M2", "M2.5", "M3", "M4", "M5", "M6", "M8", "M10", "M12"]).default("M3"),
-  acrossFlats: positiveLength2.optional(),
+  acrossFlats: positiveLength4.optional(),
   /** End-plane distance of the body; lower mounting face is Z=0. */
-  length: positiveLength2.default(10),
-  threadPitch: positiveLength2.optional(),
+  length: positiveLength4.default(10),
+  threadPitch: positiveLength4.optional(),
   hex: external_exports.literal(true).default(true),
   threadedThrough: external_exports.literal(true).default(true),
   leftHand: external_exports.boolean().default(false),
   showThreads: external_exports.boolean().default(true),
   /** Axial/radial 45-degree setback of the outer hex edges at both ends. */
-  endChamfer: length8.refine((value) => value >= 0).optional()
+  endChamfer: length10.refine((value) => value >= 0).optional()
 };
 function normalize3(props) {
   const defaults = femaleStandoffMetricDimensions[props.metricSize];
@@ -7081,7 +7257,7 @@ function normalize3(props) {
   );
   return { ...props, acrossFlats, threadPitch, endChamfer };
 }
-function validate12(props, context) {
+function validate14(props, context) {
   const resolved = normalize3(props);
   const diameter = femaleStandoffMetricDimensions[props.metricSize].diameter;
   const minor = diameter - 5 * Math.sqrt(3) / 8 * resolved.threadPitch;
@@ -7101,8 +7277,8 @@ function validate12(props, context) {
       "Length must leave positive thread length between the bore chamfers"
     );
 }
-var femaleStandoffModelPropsSchema = external_exports.object(shape13).strict().superRefine(validate12).transform(normalize3);
-var femaleStandoffModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("femalestandoff"), ...shape13 }).strict().superRefine(validate12).transform(normalize3);
+var femaleStandoffModelPropsSchema = external_exports.object(shape15).strict().superRefine(validate14).transform(normalize3);
+var femaleStandoffModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("femalestandoff"), ...shape15 }).strict().superRefine(validate14).transform(normalize3);
 function getFemaleStandoffDimensions(input) {
   const props = femaleStandoffModelPropsSchema.parse(input);
   const diameter = femaleStandoffMetricDimensions[props.metricSize].diameter;
@@ -7179,15 +7355,15 @@ function parseFemaleStandoffModelParams(raw) {
   }
   return femaleStandoffModelDefinitionSchema.parse(props);
 }
-var model17 = defineModel({
+var model19 = defineModel({
   name: "femalestandoff",
   schema: femaleStandoffModelDefinitionSchema,
   parse: parseFemaleStandoffModelParams
 });
-function register17(registry2) {
-  registry2.register(model17);
+function register19(registry2) {
+  registry2.register(model19);
 }
-var positiveLength3 = external_exports.union([
+var positiveLength5 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^(?:\d+(?:\.\d+)?|\.\d+)(?:mm|cm|m|in|inch)?$/i).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema).refine((value) => value > 0, "Length must be positive");
@@ -7258,30 +7434,30 @@ var flangeboltDimensions = {
   }
 };
 var flangeboltMetricSizeSchema = external_exports.enum(["M5", "M6", "M8", "M10"]);
-var shape14 = {
+var shape16 = {
   iso4162: external_exports.literal(true).default(true),
   metricSize: flangeboltMetricSizeSchema,
-  length: positiveLength3,
+  length: positiveLength5,
   fullThread: external_exports.literal(true).default(true),
   plainFace: external_exports.literal(true).default(true),
   leftHand: external_exports.boolean().default(false),
   showThreads: external_exports.boolean().default(true),
-  diameter: positiveLength3.optional(),
-  threadPitch: positiveLength3.optional(),
-  headAcrossFlats: positiveLength3.optional(),
-  headHeight: positiveLength3.optional(),
-  flangeDiameter: positiveLength3.optional(),
-  flangeThickness: positiveLength3.optional(),
-  underHeadRadius: positiveLength3.optional(),
-  tipChamfer: positiveLength3.optional(),
+  diameter: positiveLength5.optional(),
+  threadPitch: positiveLength5.optional(),
+  headAcrossFlats: positiveLength5.optional(),
+  headHeight: positiveLength5.optional(),
+  flangeDiameter: positiveLength5.optional(),
+  flangeThickness: positiveLength5.optional(),
+  underHeadRadius: positiveLength5.optional(),
+  tipChamfer: positiveLength5.optional(),
   headChamferAngle: external_exports.number().finite().positive().optional(),
-  headChamferDiameter: positiveLength3.optional(),
-  headCornerDiameter: positiveLength3.optional(),
+  headChamferDiameter: positiveLength5.optional(),
+  headCornerDiameter: positiveLength5.optional(),
   flangeSlopeAngle: external_exports.number().finite().positive().optional(),
-  threadRootDiameter: positiveLength3.optional(),
-  threadPitchDiameter: positiveLength3.optional()
+  threadRootDiameter: positiveLength5.optional(),
+  threadPitchDiameter: positiveLength5.optional()
 };
-var validate13 = (props, context) => {
+var validate15 = (props, context) => {
   const dimensions5 = flangeboltDimensions[props.metricSize];
   for (const key of Object.keys(dimensions5)) {
     if (props[key] !== void 0 && Math.abs(props[key] - dimensions5[key]) > 1e-9)
@@ -7298,15 +7474,15 @@ var validate13 = (props, context) => {
       message: "Length must leave material between fixed end features"
     });
 };
-var flangeboltModelPropsSchema = external_exports.object(shape14).strict().superRefine(validate13).transform((props) => ({
+var flangeboltModelPropsSchema = external_exports.object(shape16).strict().superRefine(validate15).transform((props) => ({
   ...props,
   ...flangeboltDimensions[props.metricSize]
 }));
-var flangeboltModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("flangebolt"), ...shape14 }).strict().superRefine(validate13).transform((props) => ({
+var flangeboltModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("flangebolt"), ...shape16 }).strict().superRefine(validate15).transform((props) => ({
   ...props,
   ...flangeboltDimensions[props.metricSize]
 }));
-var aliases2 = {
+var aliases4 = {
   m: "metricSize",
   metricsize: "metricSize",
   l: "length",
@@ -7363,7 +7539,7 @@ function parseFlangeBoltModelParams(raw) {
         throw new Error(
           "ISO 4162 is the default head/flange envelope; use the bare iso4162 flag or omit it. Full threading is an extension of ISO 4162"
         );
-      property = aliases2[key] ?? "";
+      property = aliases4[key] ?? "";
       if (!property || !value)
         throw new Error(`Unknown or missing flangebolt token ${token}`);
       if (property === "metricSize") {
@@ -7386,32 +7562,32 @@ function parseFlangeBoltModelParams(raw) {
   }
   return flangeboltModelDefinitionSchema.parse({ fn: "flangebolt", ...props });
 }
-var model18 = defineModel({
+var model20 = defineModel({
   name: "flangebolt",
   schema: flangeboltModelDefinitionSchema,
   parse: parseFlangeBoltModelParams
 });
-function register18(registry2) {
-  registry2.register(model18);
+function register20(registry2) {
+  registry2.register(model20);
 }
 var stringFlags6 = {
   plainclosed: "style(plainclosed)"
 };
 var omittedStringFlags6 = ["plainclosed"];
-var positiveLength4 = external_exports.union([
+var positiveLength6 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema).refine((value) => value > 0);
-var shape15 = {
-  innerDiameter: positiveLength4,
-  outerDiameter: positiveLength4,
-  flangeDiameter: positiveLength4,
+var shape17 = {
+  innerDiameter: positiveLength6,
+  outerDiameter: positiveLength6,
+  flangeDiameter: positiveLength6,
   /** Overall end-plane distance including the integral flange. */
-  length: positiveLength4,
-  flangeThickness: positiveLength4,
+  length: positiveLength6,
+  flangeThickness: positiveLength6,
   style: external_exports.literal("plainclosed").default("plainclosed")
 };
-function validate14(props, context) {
+function validate16(props, context) {
   if (props.outerDiameter <= props.innerDiameter)
     context.addIssue({
       code: "custom",
@@ -7431,8 +7607,8 @@ function validate14(props, context) {
       message: "Flange thickness must leave a positive projecting sleeve length"
     });
 }
-var flangedBushingModelPropsSchema = external_exports.object(shape15).strict().superRefine(validate14);
-var flangedBushingModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("flangedbushing"), ...shape15 }).strict().superRefine(validate14);
+var flangedBushingModelPropsSchema = external_exports.object(shape17).strict().superRefine(validate16);
+var flangedBushingModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("flangedbushing"), ...shape17 }).strict().superRefine(validate16);
 function getFlangedBushingDimensions(input) {
   const props = flangedBushingModelPropsSchema.parse(input);
   return {
@@ -7489,7 +7665,7 @@ function parseFlangedBushingModelParams(raw) {
   }
   return flangedBushingModelDefinitionSchema.parse(props);
 }
-var model19 = defineModel({
+var model21 = defineModel({
   name: "flangedbushing",
   schema: flangedBushingModelDefinitionSchema,
   parse: parseFlangedBushingModelParams,
@@ -7500,8 +7676,8 @@ var model19 = defineModel({
     omittedStringFlags6
   )
 });
-function register19(registry2) {
-  registry2.register(model19);
+function register21(registry2) {
+  registry2.register(model21);
 }
 var flangeNutDimensions = {
   M5: {
@@ -7603,20 +7779,20 @@ var flangeNutMetricSizeSchema = external_exports.enum([
   "M16",
   "M20"
 ]);
-var positiveLength5 = external_exports.union([
+var positiveLength7 = external_exports.union([
   external_exports.number().finite(),
   external_exports.string().regex(/^[+]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema).refine((value) => value > 0, "Length must be positive");
-var shape16 = {
+var shape18 = {
   iso4161: external_exports.literal(true).default(true),
   metricSize: flangeNutMetricSizeSchema,
   plainFace: external_exports.literal(true).default(true),
-  threadPitch: positiveLength5.optional(),
+  threadPitch: positiveLength7.optional(),
   rightHanded: external_exports.literal(true).default(true),
   threadClass: external_exports.literal("6H").default("6H"),
   showThreads: external_exports.boolean().default(true)
 };
-function validate15(props, context) {
+function validate17(props, context) {
   if (props.threadPitch !== void 0 && Math.abs(
     props.threadPitch - flangeNutDimensions[props.metricSize].threadPitch
   ) > 1e-9)
@@ -7632,8 +7808,8 @@ function normalize4(props) {
     threadPitch: flangeNutDimensions[props.metricSize].threadPitch
   };
 }
-var flangeNutModelPropsSchema = external_exports.object(shape16).strict().superRefine(validate15).transform(normalize4);
-var flangeNutModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("flangenut"), ...shape16 }).strict().superRefine(validate15).transform(normalize4);
+var flangeNutModelPropsSchema = external_exports.object(shape18).strict().superRefine(validate17).transform(normalize4);
+var flangeNutModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("flangenut"), ...shape18 }).strict().superRefine(validate17).transform(normalize4);
 function getFlangeNutDimensions(input) {
   const props = flangeNutModelPropsSchema.parse(input);
   const d = flangeNutDimensions[props.metricSize];
@@ -7693,13 +7869,13 @@ function parseFlangeNutModelParams(raw) {
   }
   return flangeNutModelDefinitionSchema.parse(props);
 }
-var model20 = defineModel({
+var model22 = defineModel({
   name: "flangenut",
   schema: flangeNutModelDefinitionSchema,
   parse: parseFlangeNutModelParams
 });
-function register20(registry2) {
-  registry2.register(model20);
+function register22(registry2) {
+  registry2.register(model22);
 }
 var stringFlags7 = {
   hexsocket: "drive(hexsocket)",
@@ -7849,7 +8025,7 @@ var flatHeadScrewModelDefinitionSchema = external_exports.object({
   ...props,
   ...flatHeadScrewDimensions[props.metricSize]
 }));
-var aliases3 = {
+var aliases5 = {
   m: "metricSize",
   metricsize: "metricSize",
   l: "length",
@@ -7915,7 +8091,7 @@ var parseFlatHeadScrewModelParams = (raw) => {
       property = "showThreads";
       parsed = key === "threads";
     } else {
-      property = key ? aliases3[key] ?? "" : "";
+      property = key ? aliases5[key] ?? "" : "";
       if (!property || !value)
         throw new Error(`Unknown or missing flatheadscrew token "${token}"`);
       if (selectors2.has(property)) {
@@ -7945,7 +8121,7 @@ var parseFlatHeadScrewModelParams = (raw) => {
     ...props
   });
 };
-var model21 = defineModel({
+var model23 = defineModel({
   name: "flatheadscrew",
   schema: flatHeadScrewModelDefinitionSchema,
   parse: parseFlatHeadScrewModelParams,
@@ -7956,10 +8132,10 @@ var model21 = defineModel({
     omittedStringFlags7
   )
 });
-function register21(registry2) {
-  registry2.register(model21);
+function register23(registry2) {
+  registry2.register(model23);
 }
-var positiveLength6 = external_exports.union([
+var positiveLength8 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^(?:\d+(?:\.\d+)?|\.\d+)(?:mm|cm|m|in|inch)?$/i).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema).refine((value) => value > 0, "Length must be positive");
@@ -7970,21 +8146,21 @@ var heatSetInsertCoarsePitches = {
   M6: 1
 };
 var heatSetInsertMetricSizeSchema = external_exports.enum(["M3", "M4", "M5", "M6"]);
-var shape17 = {
+var shape19 = {
   metricSize: heatSetInsertMetricSizeSchema,
-  outerDiameter: positiveLength6,
-  length: positiveLength6,
-  knurlDepth: positiveLength6,
-  knurlPitch: positiveLength6,
+  outerDiameter: positiveLength8,
+  length: positiveLength8,
+  knurlDepth: positiveLength8,
+  knurlPitch: positiveLength8,
   knurlTeeth: external_exports.number().int().min(3).max(96),
   diamondKnurl: external_exports.literal(true).default(true),
   leftHand: external_exports.boolean().default(false),
   showThreads: external_exports.boolean().default(true),
-  diameter: positiveLength6.optional(),
-  threadPitch: positiveLength6.optional(),
-  threadMinorDiameter: positiveLength6.optional(),
-  threadPitchDiameter: positiveLength6.optional(),
-  rootOuterDiameter: positiveLength6.optional()
+  diameter: positiveLength8.optional(),
+  threadPitch: positiveLength8.optional(),
+  threadMinorDiameter: positiveLength8.optional(),
+  threadPitchDiameter: positiveLength8.optional(),
+  rootOuterDiameter: positiveLength8.optional()
 };
 function dimensions4(p) {
   const diameter = Number(p.metricSize.slice(1)), threadPitch = heatSetInsertCoarsePitches[p.metricSize];
@@ -7997,7 +8173,7 @@ function dimensions4(p) {
     rootOuterDiameter: p.outerDiameter - 2 * p.knurlDepth
   };
 }
-function validate16(p, context) {
+function validate18(p, context) {
   const d = dimensions4(p);
   for (const key of Object.keys(d))
     if (p[key] !== void 0 && Math.abs(p[key] - d[key]) > 1e-9)
@@ -8019,9 +8195,9 @@ function validate16(p, context) {
       message: "Insert exceeds the 1000-repeat contract limit"
     });
 }
-var heatSetInsertModelPropsSchema = external_exports.object(shape17).strict().superRefine(validate16).transform((p) => ({ ...p, ...dimensions4(p) }));
-var heatSetInsertModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("heatsetinsert"), ...shape17 }).strict().superRefine(validate16).transform((p) => ({ ...p, ...dimensions4(p) }));
-var aliases4 = {
+var heatSetInsertModelPropsSchema = external_exports.object(shape19).strict().superRefine(validate18).transform((p) => ({ ...p, ...dimensions4(p) }));
+var heatSetInsertModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("heatsetinsert"), ...shape19 }).strict().superRefine(validate18).transform((p) => ({ ...p, ...dimensions4(p) }));
+var aliases6 = {
   m: "metricSize",
   metricsize: "metricSize",
   od: "outerDiameter",
@@ -8060,7 +8236,7 @@ function parseHeatSetInsertModelParams(raw) {
       property = flags3[key];
       parsed = !["righthanded", "nothreads"].includes(key);
     } else {
-      property = aliases4[key] ?? "";
+      property = aliases6[key] ?? "";
       if (!property || !value)
         throw new Error(`Unknown or missing heatsetinsert token ${token}`);
       if (property === "metricSize") {
@@ -8086,13 +8262,13 @@ function parseHeatSetInsertModelParams(raw) {
     ...props
   });
 }
-var model22 = defineModel({
+var model24 = defineModel({
   name: "heatsetinsert",
   schema: heatSetInsertModelDefinitionSchema,
   parse: parseHeatSetInsertModelParams
 });
-function register22(registry2) {
-  registry2.register(model22);
+function register24(registry2) {
+  registry2.register(model24);
 }
 var stringFlags8 = {
   righthanded: "threadhand(right)"
@@ -8327,17 +8503,17 @@ var hexNutImperialSizeSchema = external_exports.enum([
   "7/8",
   "1"
 ]);
-var length9 = external_exports.union([
+var length11 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema).refine((value) => value > 0, "Length must be positive");
-var shape18 = {
+var shape20 = {
   iso4032: external_exports.boolean().optional(),
   din934: external_exports.boolean().optional(),
   asmeb1822: external_exports.boolean().optional(),
   metricSize: hexNutMetricSizeSchema.optional(),
   imperialSize: hexNutImperialSizeSchema.optional(),
-  threadPitch: length9.optional(),
+  threadPitch: length11.optional(),
   threadHand: external_exports.literal("right").default("right"),
   threadClass: external_exports.enum(["6H", "2B"]).optional(),
   showThreads: external_exports.boolean().default(true)
@@ -8360,7 +8536,7 @@ function selectedDimensions(props) {
   if (!props.metricSize) return void 0;
   return family.din934 ? hexNutDinDimensions[props.metricSize] : hexNutDimensions[props.metricSize];
 }
-function validate17(props, context) {
+function validate19(props, context) {
   const issue = (path, message) => context.addIssue({ code: "custom", path: [path], message });
   if (!!props.metricSize === !!props.imperialSize)
     issue("metricSize", "Select exactly one metric or imperial size");
@@ -8394,8 +8570,8 @@ function normalize5(props) {
     threadClass: props.threadClass ?? (selectedFamily(props).asmeb1822 ? "2B" : "6H")
   };
 }
-var hexNutModelPropsSchema = external_exports.object(shape18).strict().superRefine(validate17).transform(normalize5);
-var hexNutModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("hexnut"), ...shape18 }).strict().superRefine(validate17).transform(normalize5);
+var hexNutModelPropsSchema = external_exports.object(shape20).strict().superRefine(validate19).transform(normalize5);
+var hexNutModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("hexnut"), ...shape20 }).strict().superRefine(validate19).transform(normalize5);
 function getHexNutDimensions(input) {
   const props = hexNutModelPropsSchema.parse(input);
   const dims = selectedDimensions(props);
@@ -8478,7 +8654,7 @@ function parseHexNutModelParams(raw) {
   }
   return hexNutModelDefinitionSchema.parse(props);
 }
-var model23 = defineModel({
+var model25 = defineModel({
   name: "hexnut",
   schema: hexNutModelDefinitionSchema,
   parse: parseHexNutModelParams,
@@ -8489,19 +8665,19 @@ var model23 = defineModel({
     omittedStringFlags8
   )
 });
-function register23(registry2) {
-  registry2.register(model23);
+function register25(registry2) {
+  registry2.register(model25);
 }
-var length10 = external_exports.union([
+var length12 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema);
-var positive4 = length10.refine((value) => value > 0, "Length must be positive");
-var nonnegative3 = length10.refine(
+var positive4 = length12.refine((value) => value > 0, "Length must be positive");
+var nonnegative3 = length12.refine(
   (value) => value >= 0,
   "Length cannot be negative"
 );
-var shape19 = {
+var shape21 = {
   /** Diameter at the rib crests. All lengths normalize to millimeters. */
   outerDiameter: positive4.default(6),
   innerDiameter: positive4.default(4),
@@ -8515,7 +8691,7 @@ var shape19 = {
   /** Radial distance from crest to root; zero produces a smooth tube. */
   ribDepth: nonnegative3.default(0.25)
 };
-function validate18(props, context) {
+function validate20(props, context) {
   if (props.outerDiameter - 2 * props.ribDepth <= props.innerDiameter)
     context.addIssue({
       code: "custom",
@@ -8535,8 +8711,8 @@ function validate18(props, context) {
       message: "Centerline length must be finite and positive"
     });
 }
-var hollowPositioningArmTubeModelPropsSchema = external_exports.object(shape19).strict().superRefine(validate18);
-var hollowPositioningArmTubeModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("hollowpositioningarmtube"), ...shape19 }).strict().superRefine(validate18);
+var hollowPositioningArmTubeModelPropsSchema = external_exports.object(shape21).strict().superRefine(validate20);
+var hollowPositioningArmTubeModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("hollowpositioningarmtube"), ...shape21 }).strict().superRefine(validate20);
 function getHollowPositioningArmTubeDimensions(input) {
   const props = hollowPositioningArmTubeModelPropsSchema.parse(input);
   const bendLength = props.bendRadius * (props.bendAngle * Math.PI / 180);
@@ -8606,23 +8782,23 @@ function parseHollowPositioningArmTubeModelParams(raw) {
   }
   return hollowPositioningArmTubeModelDefinitionSchema.parse(props);
 }
-var model24 = defineModel({
+var model26 = defineModel({
   name: "hollowpositioningarmtube",
   schema: hollowPositioningArmTubeModelDefinitionSchema,
   parse: parseHollowPositioningArmTubeModelParams
 });
-function register24(registry2) {
-  registry2.register(model24);
+function register26(registry2) {
+  registry2.register(model26);
 }
-var length11 = external_exports.union([
+var length13 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema);
-var positiveLength7 = length11.refine(
+var positiveLength9 = length13.refine(
   (value) => value > 0,
   "Length must be positive"
 );
-var nonnegativeLength = length11.refine(
+var nonnegativeLength3 = length13.refine(
   (value) => value >= 0,
   "Length cannot be negative"
 );
@@ -8648,21 +8824,21 @@ var maleFemaleStandoffMetricSizeSchema = external_exports.enum([
   "M10",
   "M12"
 ]);
-var shape20 = {
+var shape22 = {
   metricSize: maleFemaleStandoffMetricSizeSchema,
-  acrossFlats: positiveLength7,
+  acrossFlats: positiveLength9,
   /** Body height above its lower mounting plane Z=0, excluding the stud. */
-  length: positiveLength7,
-  studLength: positiveLength7,
+  length: positiveLength9,
+  studLength: positiveLength9,
   /** Blind female socket depth measured down from the upper mounting plane. */
-  femaleDepth: positiveLength7,
+  femaleDepth: positiveLength9,
   hex: external_exports.literal(true).default(true),
-  threadPitch: positiveLength7.optional(),
+  threadPitch: positiveLength9.optional(),
   leftHand: external_exports.boolean().default(false),
   showThreads: external_exports.boolean().default(true),
-  bodyChamfer: nonnegativeLength.optional(),
-  studChamfer: nonnegativeLength.optional(),
-  mouthChamfer: nonnegativeLength.optional()
+  bodyChamfer: nonnegativeLength3.optional(),
+  studChamfer: nonnegativeLength3.optional(),
+  mouthChamfer: nonnegativeLength3.optional()
 };
 function resolve5(props) {
   const diameter = Number(props.metricSize.slice(1));
@@ -8682,7 +8858,7 @@ function resolve5(props) {
     mouthChamfer: props.mouthChamfer ?? chamfer
   };
 }
-function validate19(props, context) {
+function validate21(props, context) {
   const p = resolve5(props);
   const diameter = Number(p.metricSize.slice(1));
   const externalMinorDiameter = diameter - 17 * Math.sqrt(3) / 24 * p.threadPitch;
@@ -8712,8 +8888,8 @@ function validate19(props, context) {
       "Hex body and chamfers must leave material around the socket and stud"
     );
 }
-var maleFemaleStandoffModelPropsSchema = external_exports.object(shape20).strict().superRefine(validate19).transform(resolve5);
-var maleFemaleStandoffModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("malefemalestandoff"), ...shape20 }).strict().superRefine(validate19).transform(resolve5);
+var maleFemaleStandoffModelPropsSchema = external_exports.object(shape22).strict().superRefine(validate21).transform(resolve5);
+var maleFemaleStandoffModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("malefemalestandoff"), ...shape22 }).strict().superRefine(validate21).transform(resolve5);
 function getMaleFemaleStandoffDimensions(input) {
   const props = maleFemaleStandoffModelPropsSchema.parse(input);
   const diameter = Number(props.metricSize.slice(1));
@@ -8792,13 +8968,13 @@ function parseMaleFemaleStandoffModelParams(raw) {
   }
   return maleFemaleStandoffModelDefinitionSchema.parse(props);
 }
-var model25 = defineModel({
+var model27 = defineModel({
   name: "malefemalestandoff",
   schema: maleFemaleStandoffModelDefinitionSchema,
   parse: parseMaleFemaleStandoffModelParams
 });
-function register25(registry2) {
-  registry2.register(model25);
+function register27(registry2) {
+  registry2.register(model27);
 }
 var nylonLockNutDimensions = {
   M5: {
@@ -8849,22 +9025,22 @@ var nylonLockNutMetricSizeSchema = external_exports.enum([
   "M10",
   "M12"
 ]);
-var length12 = external_exports.union([
+var length14 = external_exports.union([
   external_exports.number().finite(),
   external_exports.string().regex(/^[+]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema).refine(
   (value) => Number.isFinite(value) && value > 0,
   "Length must be finite and positive"
 );
-var shape21 = {
+var shape23 = {
   iso7040: external_exports.literal(true).default(true),
   metricSize: nylonLockNutMetricSizeSchema,
-  threadPitch: length12.optional(),
+  threadPitch: length14.optional(),
   rightHanded: external_exports.literal(true).default(true),
   threadClass: external_exports.literal("6H").default("6H"),
   showThreads: external_exports.boolean().default(true)
 };
-function validate20(props, context) {
+function validate22(props, context) {
   const expected = nylonLockNutDimensions[props.metricSize].threadPitch;
   if (props.threadPitch !== void 0 && Math.abs(props.threadPitch - expected) > 1e-9)
     context.addIssue({
@@ -8879,8 +9055,8 @@ function normalize6(props) {
     threadPitch: nylonLockNutDimensions[props.metricSize].threadPitch
   };
 }
-var nylonLockNutModelPropsSchema = external_exports.object(shape21).strict().superRefine(validate20).transform(normalize6);
-var nylonLockNutModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("nylonlocknut"), ...shape21 }).strict().superRefine(validate20).transform(normalize6);
+var nylonLockNutModelPropsSchema = external_exports.object(shape23).strict().superRefine(validate22).transform(normalize6);
+var nylonLockNutModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("nylonlocknut"), ...shape23 }).strict().superRefine(validate22).transform(normalize6);
 function getNylonLockNutDimensions(input) {
   const props = nylonLockNutModelPropsSchema.parse(input);
   const d = nylonLockNutDimensions[props.metricSize];
@@ -8943,13 +9119,13 @@ function parseNylonLockNutModelParams(raw) {
   }
   return nylonLockNutModelDefinitionSchema.parse(props);
 }
-var model26 = defineModel({
+var model28 = defineModel({
   name: "nylonlocknut",
   schema: nylonLockNutModelDefinitionSchema,
   parse: parseNylonLockNutModelParams
 });
-function register26(registry2) {
-  registry2.register(model26);
+function register28(registry2) {
+  registry2.register(model28);
 }
 var stringFlags9 = {
   phillips: "drive(phillips)",
@@ -9148,7 +9324,7 @@ var panScrewModelDefinitionSchema = external_exports.object({
   fn: external_exports.literal("panscrew"),
   ...panScrewModelPropsShape
 }).strict().superRefine(validatePanScrew).transform((props) => ({ ...props, ...panScrewDimensions[props.metricSize] }));
-var aliases5 = {
+var aliases7 = {
   m: "metricSize",
   metricsize: "metricSize",
   l: "length",
@@ -9223,7 +9399,7 @@ var parsePanScrewModelParams = (raw) => {
       property = "showThreads";
       parsed = key === "threads";
     } else {
-      property = key ? aliases5[key] ?? "" : "";
+      property = key ? aliases7[key] ?? "" : "";
       if (!property || !value)
         throw new Error(`Unknown or missing panscrew token "${token}"`);
       if (selectors3.has(property)) {
@@ -9256,7 +9432,7 @@ var parsePanScrewModelParams = (raw) => {
   }
   return panScrewModelDefinitionSchema.parse({ fn: "panscrew", ...props });
 };
-var model27 = defineModel({
+var model29 = defineModel({
   name: "panscrew",
   schema: panScrewModelDefinitionSchema,
   parse: parsePanScrewModelParams,
@@ -9267,28 +9443,121 @@ var model27 = defineModel({
     omittedStringFlags9
   )
 });
-function register27(registry2) {
-  registry2.register(model27);
+function register29(registry2) {
+  registry2.register(model29);
+}
+var length15 = external_exports.union([
+  external_exports.number(),
+  external_exports.string().regex(/^[+]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
+]).pipe(modelLengthSchema);
+var positiveLength10 = length15.refine(
+  (value) => value > 0,
+  "Length must be positive"
+);
+var nonnegativeLength4 = length15.refine(
+  (value) => value >= 0,
+  "Length cannot be negative"
+);
+var shape24 = {
+  length: positiveLength10,
+  width: positiveLength10,
+  thickness: positiveLength10,
+  holeDiameter: positiveLength10,
+  pitchX: positiveLength10,
+  pitchY: positiveLength10,
+  edgeX: positiveLength10,
+  edgeY: positiveLength10,
+  stagger: nonnegativeLength4.default(0)
+};
+function validate23(p, context) {
+  if (p.holeDiameter >= Math.min(p.pitchX, p.pitchY))
+    context.addIssue({
+      code: "custom",
+      message: "Invalid perforatedsheet dimensions: constraint 1"
+    });
+  if (2 * p.edgeX > p.length || 2 * p.edgeY > p.width)
+    context.addIssue({
+      code: "custom",
+      message: "Invalid perforatedsheet dimensions: constraint 2"
+    });
+  if (Math.min(p.edgeX, p.edgeY) <= p.holeDiameter / 2)
+    context.addIssue({
+      code: "custom",
+      message: "Invalid perforatedsheet dimensions: constraint 3"
+    });
+  if (p.stagger >= p.pitchX)
+    context.addIssue({
+      code: "custom",
+      message: "Invalid perforatedsheet dimensions: constraint 4"
+    });
+  if (Math.floor((p.length - 2 * p.edgeX) / p.pitchX + 1) * Math.floor((p.width - 2 * p.edgeY) / p.pitchY + 1) > 2500)
+    context.addIssue({
+      code: "custom",
+      message: "Invalid perforatedsheet dimensions: constraint 5"
+    });
+}
+var perforatedSheetModelPropsSchema = external_exports.object(shape24).strict().superRefine(validate23);
+var perforatedSheetModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("perforatedsheet"), ...shape24 }).strict().superRefine(validate23);
+var aliases8 = {
+  l: "length",
+  w: "width",
+  t: "thickness",
+  hole: "holeDiameter",
+  pitchx: "pitchX",
+  pitchy: "pitchY",
+  edgex: "edgeX",
+  edgey: "edgeY",
+  stagger: "stagger",
+  length: "length",
+  width: "width",
+  thickness: "thickness",
+  holediameter: "holeDiameter"
+};
+function parsePerforatedSheetModelParams(raw) {
+  const [name, ...tokens] = splitModelStringTokens(raw.string);
+  if (raw.fn !== "perforatedsheet" || name?.toLowerCase() !== "perforatedsheet")
+    throw new Error("Expected perforatedsheet without inline values");
+  const props = { fn: "perforatedsheet" };
+  for (const token of tokens) {
+    const match = token.match(/^([a-z]+)(.*)$/i);
+    const key = match?.[1]?.toLowerCase();
+    const value = match?.[2];
+    if (!key || !Object.hasOwn(aliases8, key) || !value)
+      throw new Error(`Unknown or malformed perforatedsheet token "${token}"`);
+    const property = aliases8[key];
+    if (Object.hasOwn(props, property))
+      throw new Error(`Duplicate perforatedsheet property "${property}"`);
+    props[property] = value;
+  }
+  return perforatedSheetModelDefinitionSchema.parse(props);
+}
+var model30 = defineModel({
+  name: "perforatedsheet",
+  schema: perforatedSheetModelDefinitionSchema,
+  parse: parsePerforatedSheetModelParams
+});
+function register30(registry2) {
+  registry2.register(model30);
 }
 var stringFlags10 = {
   plainclosed: "style(plainclosed)"
 };
 var omittedStringFlags10 = ["plainclosed"];
-var length13 = external_exports.union([
+var length16 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema);
-var positiveLength8 = length13.refine((value) => value > 0);
-var shape22 = {
-  innerDiameter: positiveLength8,
-  outerDiameter: positiveLength8,
+var positiveLength11 = length16.refine((value) => value > 0);
+var shape25 = {
+  innerDiameter: positiveLength11,
+  outerDiameter: positiveLength11,
   /** Overall end-plane distance, including the chamfers. */
-  length: positiveLength8,
+  length: positiveLength11,
   style: external_exports.literal("plainclosed").default("plainclosed"),
   /** Equal axial/radial setbacks of all four 45-degree bore/outside rim chamfers. */
-  edgeChamfer: length13.refine((value) => value >= 0).default(0)
+  edgeChamfer: length16.refine((value) => value >= 0).default(0)
 };
-function validate21(props, context) {
+function validate24(props, context) {
   if (props.outerDiameter <= props.innerDiameter)
     context.addIssue({
       code: "custom",
@@ -9308,8 +9577,8 @@ function validate21(props, context) {
       message: "The two end chamfers must leave positive straight bore length"
     });
 }
-var plainBushingModelPropsSchema = external_exports.object(shape22).strict().superRefine(validate21);
-var plainBushingModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("plainbushing"), ...shape22 }).strict().superRefine(validate21);
+var plainBushingModelPropsSchema = external_exports.object(shape25).strict().superRefine(validate24);
+var plainBushingModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("plainbushing"), ...shape25 }).strict().superRefine(validate24);
 function getPlainBushingDimensions(input) {
   const props = plainBushingModelPropsSchema.parse(input);
   return {
@@ -9355,26 +9624,237 @@ function parsePlainBushingModelParams(raw) {
       parsed = style[1].toLowerCase();
     } else throw new Error(`Unknown plain bushing token "${token}"`);
     if (Object.hasOwn(props, property))
-      throw new Error(
-        `Plain bushing property "${property}" is set more than once`
-      );
-    props[property] = parsed;
+      throw new Error(
+        `Plain bushing property "${property}" is set more than once`
+      );
+    props[property] = parsed;
+  }
+  return plainBushingModelDefinitionSchema.parse(props);
+}
+var model31 = defineModel({
+  name: "plainbushing",
+  schema: plainBushingModelDefinitionSchema,
+  parse: parsePlainBushingModelParams,
+  normalizeString: (value) => normalizeModelStringFlags(
+    value,
+    stringFlags10,
+    parsePlainBushingModelParams,
+    omittedStringFlags10
+  )
+});
+function register31(registry2) {
+  registry2.register(model31);
+}
+var length17 = external_exports.union([
+  external_exports.number(),
+  external_exports.string().regex(/^[+]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
+]).pipe(modelLengthSchema);
+var positiveLength12 = length17.refine(
+  (value) => value > 0,
+  "Length must be positive"
+);
+var shape26 = {
+  tubeDiameter: positiveLength12,
+  length: positiveLength12,
+  headDiameter: positiveLength12,
+  headThickness: positiveLength12
+};
+function validate25(p, context) {
+  if (p.headDiameter <= p.tubeDiameter)
+    context.addIssue({
+      code: "custom",
+      message: "Invalid pushfitplug dimensions: constraint 1"
+    });
+  if (p.headThickness >= p.length)
+    context.addIssue({
+      code: "custom",
+      message: "Invalid pushfitplug dimensions: constraint 2"
+    });
+}
+var pushFitPlugModelPropsSchema = external_exports.object(shape26).strict().superRefine(validate25);
+var pushFitPlugModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("pushfitplug"), ...shape26 }).strict().superRefine(validate25);
+var aliases9 = {
+  tubeod: "tubeDiameter",
+  l: "length",
+  headod: "headDiameter",
+  headt: "headThickness",
+  tubediameter: "tubeDiameter",
+  length: "length",
+  headdiameter: "headDiameter",
+  headthickness: "headThickness"
+};
+function parsePushFitPlugModelParams(raw) {
+  const [name, ...tokens] = splitModelStringTokens(raw.string);
+  if (raw.fn !== "pushfitplug" || name?.toLowerCase() !== "pushfitplug")
+    throw new Error("Expected pushfitplug without inline values");
+  const props = { fn: "pushfitplug" };
+  for (const token of tokens) {
+    const match = token.match(/^([a-z]+)(.*)$/i);
+    const key = match?.[1]?.toLowerCase();
+    const value = match?.[2];
+    if (!key || !Object.hasOwn(aliases9, key) || !value)
+      throw new Error(`Unknown or malformed pushfitplug token "${token}"`);
+    const property = aliases9[key];
+    if (Object.hasOwn(props, property))
+      throw new Error(`Duplicate pushfitplug property "${property}"`);
+    props[property] = value;
+  }
+  return pushFitPlugModelDefinitionSchema.parse(props);
+}
+var model32 = defineModel({
+  name: "pushfitplug",
+  schema: pushFitPlugModelDefinitionSchema,
+  parse: parsePushFitPlugModelParams
+});
+function register32(registry2) {
+  registry2.register(model32);
+}
+var length18 = external_exports.union([
+  external_exports.number(),
+  external_exports.string().regex(/^[+]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
+]).pipe(modelLengthSchema);
+var positiveLength13 = length18.refine(
+  (value) => value > 0,
+  "Length must be positive"
+);
+var nonnegativeLength5 = length18.refine(
+  (value) => value >= 0,
+  "Length cannot be negative"
+);
+var shape27 = {
+  width: positiveLength13,
+  height: positiveLength13,
+  length: positiveLength13,
+  cornerRadius: nonnegativeLength5.default(0)
+};
+function validate26(p, context) {
+  if (p.cornerRadius * 2 >= Math.min(p.width, p.height))
+    context.addIssue({
+      code: "custom",
+      message: "Invalid rectangularbar dimensions: constraint 1"
+    });
+}
+var rectangularBarModelPropsSchema = external_exports.object(shape27).strict().superRefine(validate26);
+var rectangularBarModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("rectangularbar"), ...shape27 }).strict().superRefine(validate26);
+var aliases10 = {
+  w: "width",
+  h: "height",
+  l: "length",
+  cornerr: "cornerRadius",
+  width: "width",
+  height: "height",
+  length: "length",
+  cornerradius: "cornerRadius"
+};
+function parseRectangularBarModelParams(raw) {
+  const [name, ...tokens] = splitModelStringTokens(raw.string);
+  if (raw.fn !== "rectangularbar" || name?.toLowerCase() !== "rectangularbar")
+    throw new Error("Expected rectangularbar without inline values");
+  const props = { fn: "rectangularbar" };
+  for (const token of tokens) {
+    const match = token.match(/^([a-z]+)(.*)$/i);
+    const key = match?.[1]?.toLowerCase();
+    const value = match?.[2];
+    if (!key || !Object.hasOwn(aliases10, key) || !value)
+      throw new Error(`Unknown or malformed rectangularbar token "${token}"`);
+    const property = aliases10[key];
+    if (Object.hasOwn(props, property))
+      throw new Error(`Duplicate rectangularbar property "${property}"`);
+    props[property] = value;
+  }
+  return rectangularBarModelDefinitionSchema.parse(props);
+}
+var model33 = defineModel({
+  name: "rectangularbar",
+  schema: rectangularBarModelDefinitionSchema,
+  parse: parseRectangularBarModelParams
+});
+function register33(registry2) {
+  registry2.register(model33);
+}
+var length19 = external_exports.union([
+  external_exports.number(),
+  external_exports.string().regex(/^[+]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
+]).pipe(modelLengthSchema);
+var positiveLength14 = length19.refine(
+  (value) => value > 0,
+  "Length must be positive"
+);
+var nonnegativeLength6 = length19.refine(
+  (value) => value >= 0,
+  "Length cannot be negative"
+);
+var shape28 = {
+  width: positiveLength14,
+  height: positiveLength14,
+  wallThickness: positiveLength14,
+  length: positiveLength14,
+  outerRadius: nonnegativeLength6.default(0),
+  innerRadius: nonnegativeLength6.default(0)
+};
+function validate27(p, context) {
+  if (2 * p.wallThickness >= Math.min(p.width, p.height))
+    context.addIssue({
+      code: "custom",
+      message: "Invalid rectangulartube dimensions: constraint 1"
+    });
+  if (2 * p.outerRadius >= Math.min(p.width, p.height))
+    context.addIssue({
+      code: "custom",
+      message: "Invalid rectangulartube dimensions: constraint 2"
+    });
+  if (2 * p.innerRadius >= Math.min(p.width, p.height) - 2 * p.wallThickness)
+    context.addIssue({
+      code: "custom",
+      message: "Invalid rectangulartube dimensions: constraint 3"
+    });
+  if (p.wallThickness <= (1 - Math.SQRT1_2) * (p.outerRadius - p.innerRadius))
+    context.addIssue({
+      code: "custom",
+      message: "Invalid rectangulartube dimensions: constraint 4"
+    });
+}
+var rectangularTubeModelPropsSchema = external_exports.object(shape28).strict().superRefine(validate27);
+var rectangularTubeModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("rectangulartube"), ...shape28 }).strict().superRefine(validate27);
+var aliases11 = {
+  w: "width",
+  h: "height",
+  wall: "wallThickness",
+  l: "length",
+  outerr: "outerRadius",
+  innerr: "innerRadius",
+  width: "width",
+  height: "height",
+  wallthickness: "wallThickness",
+  length: "length",
+  outerradius: "outerRadius",
+  innerradius: "innerRadius"
+};
+function parseRectangularTubeModelParams(raw) {
+  const [name, ...tokens] = splitModelStringTokens(raw.string);
+  if (raw.fn !== "rectangulartube" || name?.toLowerCase() !== "rectangulartube")
+    throw new Error("Expected rectangulartube without inline values");
+  const props = { fn: "rectangulartube" };
+  for (const token of tokens) {
+    const match = token.match(/^([a-z]+)(.*)$/i);
+    const key = match?.[1]?.toLowerCase();
+    const value = match?.[2];
+    if (!key || !Object.hasOwn(aliases11, key) || !value)
+      throw new Error(`Unknown or malformed rectangulartube token "${token}"`);
+    const property = aliases11[key];
+    if (Object.hasOwn(props, property))
+      throw new Error(`Duplicate rectangulartube property "${property}"`);
+    props[property] = value;
   }
-  return plainBushingModelDefinitionSchema.parse(props);
+  return rectangularTubeModelDefinitionSchema.parse(props);
 }
-var model28 = defineModel({
-  name: "plainbushing",
-  schema: plainBushingModelDefinitionSchema,
-  parse: parsePlainBushingModelParams,
-  normalizeString: (value) => normalizeModelStringFlags(
-    value,
-    stringFlags10,
-    parsePlainBushingModelParams,
-    omittedStringFlags10
-  )
+var model34 = defineModel({
+  name: "rectangulartube",
+  schema: rectangularTubeModelDefinitionSchema,
+  parse: parseRectangularTubeModelParams
 });
-function register28(registry2) {
-  registry2.register(model28);
+function register34(registry2) {
+  registry2.register(model34);
 }
 var stringFlags11 = {
   setscrew: "mount(setscrew)",
@@ -9382,19 +9862,19 @@ var stringFlags11 = {
   righthanded: "threadhand(right)"
 };
 var omittedStringFlags11 = ["righthanded"];
-var length14 = external_exports.union([
+var length20 = external_exports.union([
   external_exports.number().finite(),
   external_exports.string().regex(
     /^[+]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i,
     "Expected a complete length with a supported unit"
   ).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema);
-var positive5 = length14.refine((value) => value > 0, "Length must be positive");
-var nonnegative4 = length14.refine(
+var positive5 = length20.refine((value) => value > 0, "Length must be positive");
+var nonnegative4 = length20.refine(
   (value) => value >= 0,
   "Length cannot be negative"
 );
-var shape23 = {
+var shape29 = {
   boreDiameter: positive5,
   outerDiameter: positive5,
   boreBDiameter: positive5.optional(),
@@ -9419,7 +9899,7 @@ function resolve6(props) {
     screwAngle: (props.screwAngle % 360 + 360) % 360
   };
 }
-function validate22(props, context) {
+function validate28(props, context) {
   const p = resolve6(props);
   const issue = (message) => context.addIssue({ code: "custom", message });
   const diameter = hexSocketBoltDimensions[p.metricSize].diameter;
@@ -9443,8 +9923,8 @@ function validate22(props, context) {
   if (p.length - 2 * p.screwEndOffset <= diameter)
     issue("Each end must have a separate, nonintersecting screw-hole plane");
 }
-var rigidCouplerModelPropsSchema = external_exports.object(shape23).strict().superRefine(validate22).transform(resolve6);
-var rigidCouplerModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("rigidcoupler"), ...shape23 }).strict().superRefine(validate22).transform((props) => ({ fn: props.fn, ...resolve6(props) }));
+var rigidCouplerModelPropsSchema = external_exports.object(shape29).strict().superRefine(validate28).transform(resolve6);
+var rigidCouplerModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("rigidcoupler"), ...shape29 }).strict().superRefine(validate28).transform((props) => ({ fn: props.fn, ...resolve6(props) }));
 function getRigidCouplerDimensions(input) {
   const p = rigidCouplerModelPropsSchema.parse(input);
   const threadDiameter = hexSocketBoltDimensions[p.metricSize].diameter;
@@ -9544,7 +10024,7 @@ function parseRigidCouplerModelParams(raw) {
     ...props
   });
 }
-var model29 = defineModel({
+var model35 = defineModel({
   name: "rigidcoupler",
   schema: rigidCouplerModelDefinitionSchema,
   parse: parseRigidCouplerModelParams,
@@ -9555,10 +10035,10 @@ var model29 = defineModel({
     omittedStringFlags11
   )
 });
-function register29(registry2) {
-  registry2.register(model29);
+function register35(registry2) {
+  registry2.register(model35);
 }
-var positiveLength9 = external_exports.union([
+var positiveLength15 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^(?:\d+(?:\.\d+)?|\.\d+)(?:mm|cm|m|in|inch)?$/i).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema).refine((value) => value > 0, "Length must be positive");
@@ -9613,26 +10093,26 @@ var setscrewDimensions = {
   }
 };
 var setscrewMetricSizeSchema = external_exports.enum(["M3", "M4", "M5", "M6"]);
-var shape24 = {
+var shape30 = {
   iso4029: external_exports.literal(true).default(true),
   metricSize: setscrewMetricSizeSchema,
-  length: positiveLength9,
+  length: positiveLength15,
   hexSocket: external_exports.literal(true).default(true),
   cupPoint: external_exports.literal(true).default(true),
   leftHand: external_exports.boolean().default(false),
   showThreads: external_exports.boolean().default(true),
-  diameter: positiveLength9.optional(),
-  threadPitch: positiveLength9.optional(),
-  socketAcrossFlats: positiveLength9.optional(),
-  socketDepth: positiveLength9.optional(),
-  cupDiameter: positiveLength9.optional(),
-  cupDepth: positiveLength9.optional(),
-  pointTaperLength: positiveLength9.optional(),
-  mouthChamfer: positiveLength9.optional(),
-  threadRootDiameter: positiveLength9.optional(),
-  threadPitchDiameter: positiveLength9.optional()
-};
-var validate23 = (props, context) => {
+  diameter: positiveLength15.optional(),
+  threadPitch: positiveLength15.optional(),
+  socketAcrossFlats: positiveLength15.optional(),
+  socketDepth: positiveLength15.optional(),
+  cupDiameter: positiveLength15.optional(),
+  cupDepth: positiveLength15.optional(),
+  pointTaperLength: positiveLength15.optional(),
+  mouthChamfer: positiveLength15.optional(),
+  threadRootDiameter: positiveLength15.optional(),
+  threadPitchDiameter: positiveLength15.optional()
+};
+var validate29 = (props, context) => {
   const dimensions5 = setscrewDimensions[props.metricSize];
   for (const key of Object.keys(dimensions5)) {
     if (props[key] !== void 0 && Math.abs(props[key] - dimensions5[key]) > 1e-9)
@@ -9649,9 +10129,9 @@ var validate23 = (props, context) => {
       message: "Length must leave material between fixed end features"
     });
 };
-var setscrewModelPropsSchema = external_exports.object(shape24).strict().superRefine(validate23).transform((props) => ({ ...props, ...setscrewDimensions[props.metricSize] }));
-var setscrewModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("setscrew"), ...shape24 }).strict().superRefine(validate23).transform((props) => ({ ...props, ...setscrewDimensions[props.metricSize] }));
-var aliases6 = {
+var setscrewModelPropsSchema = external_exports.object(shape30).strict().superRefine(validate29).transform((props) => ({ ...props, ...setscrewDimensions[props.metricSize] }));
+var setscrewModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("setscrew"), ...shape30 }).strict().superRefine(validate29).transform((props) => ({ ...props, ...setscrewDimensions[props.metricSize] }));
+var aliases12 = {
   m: "metricSize",
   metricsize: "metricSize",
   l: "length",
@@ -9700,7 +10180,7 @@ function parseSetScrewModelParams(raw) {
       property = flags5[key];
       parsed = !["righthanded", "nothreads"].includes(key);
     } else {
-      property = aliases6[key] ?? "";
+      property = aliases12[key] ?? "";
       if (!property || !value)
         throw new Error(`Unknown or missing setscrew token ${token}`);
       if (property === "metricSize") {
@@ -9723,13 +10203,13 @@ function parseSetScrewModelParams(raw) {
   }
   return setscrewModelDefinitionSchema.parse({ fn: "setscrew", ...props });
 }
-var model30 = defineModel({
+var model36 = defineModel({
   name: "setscrew",
   schema: setscrewModelDefinitionSchema,
   parse: parseSetScrewModelParams
 });
-function register30(registry2) {
-  registry2.register(model30);
+function register36(registry2) {
+  registry2.register(model36);
 }
 var stringFlags12 = {
   setscrew: "mount(setscrew)",
@@ -9737,19 +10217,19 @@ var stringFlags12 = {
   righthanded: "threadhand(right)"
 };
 var omittedStringFlags12 = ["righthanded"];
-var length15 = external_exports.union([
+var length21 = external_exports.union([
   external_exports.number().finite(),
   external_exports.string().regex(
     /^[+]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i,
     "Expected a complete length with a supported unit"
   ).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema);
-var positive6 = length15.refine((value) => value > 0, "Length must be positive");
-var nonnegative5 = length15.refine(
+var positive6 = length21.refine((value) => value > 0, "Length must be positive");
+var nonnegative5 = length21.refine(
   (value) => value >= 0,
   "Length cannot be negative"
 );
-var shape25 = {
+var shape31 = {
   boreDiameter: positive6,
   outerDiameter: positive6,
   width: positive6,
@@ -9771,7 +10251,7 @@ function resolve7(props) {
     screwAngle: (props.screwAngle % 360 + 360) % 360
   };
 }
-function validate24(props, context) {
+function validate30(props, context) {
   const p = resolve7(props);
   const issue = (message) => context.addIssue({ code: "custom", message });
   const diameter = hexSocketBoltDimensions[p.metricSize].diameter;
@@ -9788,8 +10268,8 @@ function validate24(props, context) {
   if (p.screwZ - diameter / 2 <= p.chamfer || p.screwZ + diameter / 2 >= p.width - p.chamfer)
     issue("Screw hole must clear both end faces and chamfers");
 }
-var shaftCollarModelPropsSchema = external_exports.object(shape25).strict().superRefine(validate24).transform(resolve7);
-var shaftCollarModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("shaftcollar"), ...shape25 }).strict().superRefine(validate24).transform((props) => ({ fn: props.fn, ...resolve7(props) }));
+var shaftCollarModelPropsSchema = external_exports.object(shape31).strict().superRefine(validate30).transform(resolve7);
+var shaftCollarModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("shaftcollar"), ...shape31 }).strict().superRefine(validate30).transform((props) => ({ fn: props.fn, ...resolve7(props) }));
 function getShaftCollarDimensions(input) {
   const p = shaftCollarModelPropsSchema.parse(input);
   const threadDiameter = hexSocketBoltDimensions[p.metricSize].diameter;
@@ -9863,7 +10343,7 @@ function parseShaftCollarModelParams(raw) {
   }
   return shaftCollarModelDefinitionSchema.parse({ fn: "shaftcollar", ...props });
 }
-var model31 = defineModel({
+var model37 = defineModel({
   name: "shaftcollar",
   schema: shaftCollarModelDefinitionSchema,
   parse: parseShaftCollarModelParams,
@@ -9874,27 +10354,27 @@ var model31 = defineModel({
     omittedStringFlags12
   )
 });
-function register31(registry2) {
-  registry2.register(model31);
+function register37(registry2) {
+  registry2.register(model37);
 }
-var length16 = external_exports.union([
+var length22 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema);
-var positiveLength10 = length16.refine(
+var positiveLength16 = length22.refine(
   (value) => value > 0,
   "Length must be positive"
 );
-var shape26 = {
-  innerDiameter: positiveLength10,
-  outerDiameter: positiveLength10,
+var shape32 = {
+  innerDiameter: positiveLength16,
+  outerDiameter: positiveLength16,
   /** End-plane distance, including the rim chamfers. */
-  length: positiveLength10,
+  length: positiveLength16,
   round: external_exports.literal(true).default(true),
   /** Equal axial/radial setbacks at all four 45-degree rims. */
-  chamfer: length16.refine((value) => value >= 0, "Chamfer cannot be negative").default(0)
+  chamfer: length22.refine((value) => value >= 0, "Chamfer cannot be negative").default(0)
 };
-function validate25(props, context) {
+function validate31(props, context) {
   if (props.outerDiameter <= props.innerDiameter)
     context.addIssue({
       code: "custom",
@@ -9914,9 +10394,9 @@ function validate25(props, context) {
       message: "Chamfers must leave positive straight bore length"
     });
 }
-var spacerModelPropsSchema = external_exports.object(shape26).strict().superRefine(validate25);
-var spacerModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("spacer"), ...shape26 }).strict().superRefine(validate25);
-var aliases7 = {
+var spacerModelPropsSchema = external_exports.object(shape32).strict().superRefine(validate31);
+var spacerModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("spacer"), ...shape32 }).strict().superRefine(validate31);
+var aliases13 = {
   id: "innerDiameter",
   innerdiameter: "innerDiameter",
   od: "outerDiameter",
@@ -9940,8 +10420,8 @@ function parseSpacerModelParams(raw) {
     if (key === "round" && value === "") {
       property = "round";
       parsed = true;
-    } else if (key && Object.hasOwn(aliases7, key) && value) {
-      property = aliases7[key];
+    } else if (key && Object.hasOwn(aliases13, key) && value) {
+      property = aliases13[key];
       parsed = value;
     } else throw new Error(`Unknown or malformed spacer token "${token}"`);
     if (Object.hasOwn(props, property))
@@ -9950,34 +10430,34 @@ function parseSpacerModelParams(raw) {
   }
   return spacerModelDefinitionSchema.parse(props);
 }
-var model32 = defineModel({
+var model38 = defineModel({
   name: "spacer",
   schema: spacerModelDefinitionSchema,
   parse: parseSpacerModelParams
 });
-function register32(registry2) {
-  registry2.register(model32);
+function register38(registry2) {
+  registry2.register(model38);
 }
-var length17 = external_exports.union([
+var length23 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i)
 ]).pipe(modelLengthSchema);
-var positiveLength11 = length17.refine(
+var positiveLength17 = length23.refine(
   (value) => value > 0,
   "Length must be positive"
 );
-var shape27 = {
-  innerDiameter: positiveLength11,
-  outerDiameter: positiveLength11,
+var shape33 = {
+  innerDiameter: positiveLength17,
+  outerDiameter: positiveLength17,
   /** Axial thickness of the rectangular radial/vertical section. */
-  thickness: positiveLength11,
+  thickness: positiveLength17,
   /** End-to-end axial displacement, independent of section thickness. */
-  rise: length17.refine((value) => value >= 0, "Rise cannot be negative"),
+  rise: length23.refine((value) => value >= 0, "Rise cannot be negative"),
   gapAngle: external_exports.number().finite().gt(0).lt(360),
   rectangular: external_exports.literal(true).default(true),
   leftHanded: external_exports.boolean().default(false)
 };
-function validate26(p, context) {
+function validate32(p, context) {
   if (p.innerDiameter >= p.outerDiameter)
     context.addIssue({
       code: "custom",
@@ -9990,8 +10470,8 @@ function validate26(p, context) {
       message: "The washer envelope and volume must remain finite"
     });
 }
-var splitWasherModelPropsSchema = external_exports.object(shape27).strict().superRefine(validate26);
-var splitWasherModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("splitwasher"), ...shape27 }).strict().superRefine(validate26);
+var splitWasherModelPropsSchema = external_exports.object(shape33).strict().superRefine(validate32);
+var splitWasherModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("splitwasher"), ...shape33 }).strict().superRefine(validate32);
 var lengths16 = {
   id: "innerDiameter",
   innerdiameter: "innerDiameter",
@@ -10036,20 +10516,20 @@ function parseSplitWasherModelParams(raw) {
   }
   return splitWasherModelDefinitionSchema.parse(props);
 }
-var model33 = defineModel({
+var model39 = defineModel({
   name: "splitwasher",
   schema: splitWasherModelDefinitionSchema,
   parse: parseSplitWasherModelParams
 });
-function register33(registry2) {
-  registry2.register(model33);
+function register39(registry2) {
+  registry2.register(model39);
 }
-var length18 = external_exports.union([
+var length24 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema);
-var positiveLength12 = length18.refine((value) => value > 0);
-var nonnegativeLength2 = length18.refine((value) => value >= 0);
+var positiveLength18 = length24.refine((value) => value > 0);
+var nonnegativeLength7 = length24.refine((value) => value >= 0);
 var threadedRodCoarsePitches = {
   M2: 0.4,
   "M2.5": 0.45,
@@ -10076,13 +10556,13 @@ var threadedRodMetricSizeSchema = external_exports.enum([
   "M16",
   "M20"
 ]);
-var shape28 = {
+var shape34 = {
   metricSize: threadedRodMetricSizeSchema,
   /** Overall end-plane distance, including terminal chamfers. */
-  length: positiveLength12,
+  length: positiveLength18,
   /** Equal axial and radial setbacks of the two 45-degree outer chamfers. */
-  chamfer: nonnegativeLength2.default(0),
-  threadPitch: positiveLength12.optional(),
+  chamfer: nonnegativeLength7.default(0),
+  threadPitch: positiveLength18.optional(),
   leftHand: external_exports.boolean().default(false)
 };
 function resolve8(props) {
@@ -10091,7 +10571,7 @@ function resolve8(props) {
     threadPitch: props.threadPitch ?? threadedRodCoarsePitches[props.metricSize]
   };
 }
-function validate27(props, context) {
+function validate33(props, context) {
   const diameter = Number(props.metricSize.slice(1));
   const pitch = resolve8(props).threadPitch;
   if (diameter - 1.226869 * pitch <= 0)
@@ -10107,8 +10587,8 @@ function validate27(props, context) {
       message: "Chamfer must leave flat end faces and separate end chamfers"
     });
 }
-var threadedRodModelPropsSchema = external_exports.object(shape28).strict().superRefine(validate27).transform(resolve8);
-var threadedRodModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("threadedrod"), ...shape28 }).strict().superRefine(validate27).transform((model392) => ({ fn: model392.fn, ...resolve8(model392) }));
+var threadedRodModelPropsSchema = external_exports.object(shape34).strict().superRefine(validate33).transform(resolve8);
+var threadedRodModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("threadedrod"), ...shape34 }).strict().superRefine(validate33).transform((model452) => ({ fn: model452.fn, ...resolve8(model452) }));
 function getThreadedRodDimensions(input) {
   const props = threadedRodModelPropsSchema.parse(input);
   const diameter = Number(props.metricSize.slice(1));
@@ -10176,21 +10656,21 @@ function normalizeThreadedRodModelString(value) {
     return [lower === "lefthanded" ? lower : token];
   }).join("_");
 }
-var model34 = defineModel({
+var model40 = defineModel({
   name: "threadedrod",
   schema: threadedRodModelDefinitionSchema,
   parse: parseThreadedRodModelParams,
   normalizeString: normalizeThreadedRodModelString
 });
-function register34(registry2) {
-  registry2.register(model34);
+function register40(registry2) {
+  registry2.register(model40);
 }
-var length19 = external_exports.union([
+var length25 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema);
-var positive7 = length19.refine((value) => value > 0, "Length must be positive");
-var shape29 = {
+var positive7 = length25.refine((value) => value > 0, "Length must be positive");
+var shape35 = {
   outerDiameter: positive7.default(8),
   wireDiameter: positive7.default(0.8),
   /** Fractional turns set the relative leg direction. */
@@ -10204,7 +10684,7 @@ var shape29 = {
 function normalize7(p) {
   return { ...p, pitch: p.pitch ?? p.wireDiameter * 1.25 };
 }
-function validate28(p, context) {
+function validate34(p, context) {
   if (p.outerDiameter < 3 * p.wireDiameter)
     context.addIssue({
       code: "custom",
@@ -10226,8 +10706,8 @@ function validate28(p, context) {
       message: "Spring dimensions must remain finite"
     });
 }
-var torsionSpringModelPropsSchema = external_exports.object(shape29).strict().superRefine(validate28).transform(normalize7);
-var torsionSpringModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("torsionspring"), ...shape29 }).strict().superRefine(validate28).transform((p) => ({ ...normalize7(p), fn: p.fn }));
+var torsionSpringModelPropsSchema = external_exports.object(shape35).strict().superRefine(validate34).transform(normalize7);
+var torsionSpringModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("torsionspring"), ...shape35 }).strict().superRefine(validate34).transform((p) => ({ ...normalize7(p), fn: p.fn }));
 function getTorsionSpringDimensions(input) {
   const p = torsionSpringModelPropsSchema.parse(input);
   const meanRadius = (p.outerDiameter - p.wireDiameter) / 2;
@@ -10312,19 +10792,19 @@ function parseTorsionSpringModelParams(raw) {
   }
   return torsionSpringModelDefinitionSchema.parse(props);
 }
-var model35 = defineModel({
+var model41 = defineModel({
   name: "torsionspring",
   schema: torsionSpringModelDefinitionSchema,
   parse: parseTorsionSpringModelParams
 });
-function register35(registry2) {
-  registry2.register(model35);
+function register41(registry2) {
+  registry2.register(model41);
 }
 var stringFlags13 = {
   fourtsolid: "profile(fourtsolid)"
 };
 var omittedStringFlags13 = [];
-var shape30 = {
+var shape36 = {
   width: positiveGearLengthSchema.default(20),
   height: positiveGearLengthSchema.default(20),
   length: positiveGearLengthSchema.default(100),
@@ -10337,7 +10817,7 @@ var shape30 = {
   boreDiameter: nonnegativeGearLengthSchema.default(0),
   cornerRadius: nonnegativeGearLengthSchema.default(0)
 };
-function validate29(props, context) {
+function validate35(props, context) {
   const issue = (message, path) => context.addIssue({ code: "custom", message, path: [path] });
   const halfSize = Math.min(props.width, props.height) / 2;
   const depth = props.lipThickness + props.pocketDepth;
@@ -10365,8 +10845,8 @@ function validate29(props, context) {
       "boreDiameter"
     );
 }
-var tSlotExtrusionModelPropsSchema = external_exports.object(shape30).strict().superRefine(validate29);
-var tSlotExtrusionModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("tslotextrusion"), ...shape30 }).strict().superRefine(validate29);
+var tSlotExtrusionModelPropsSchema = external_exports.object(shape36).strict().superRefine(validate35);
+var tSlotExtrusionModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("tslotextrusion"), ...shape36 }).strict().superRefine(validate35);
 var lengths19 = {
   w: "width",
   width: "width",
@@ -10411,7 +10891,7 @@ function parseTSlotExtrusionModelParams(raw) {
   }
   return tSlotExtrusionModelDefinitionSchema.parse(props);
 }
-var model36 = defineModel({
+var model42 = defineModel({
   name: "tslotextrusion",
   schema: tSlotExtrusionModelDefinitionSchema,
   parse: parseTSlotExtrusionModelParams,
@@ -10422,14 +10902,14 @@ var model36 = defineModel({
     omittedStringFlags13
   )
 });
-function register36(registry2) {
-  registry2.register(model36);
+function register42(registry2) {
+  registry2.register(model42);
 }
 var stringFlags14 = {
   righttriangle: "shape(righttriangle)"
 };
 var omittedStringFlags14 = [];
-var shape31 = {
+var shape37 = {
   width: positiveGearLengthSchema.default(40),
   height: positiveGearLengthSchema.default(40),
   thickness: positiveGearLengthSchema.default(4),
@@ -10442,22 +10922,22 @@ var shape31 = {
   /** Ligament between each slot and its parallel outer plate edge. */
   edgeMargin: positiveGearLengthSchema.default(1)
 };
-function validate30(props, context) {
+function validate36(props, context) {
   const issue = (message, path) => context.addIssue({ code: "custom", message, path: [path] });
-  const [width10, length20] = props.slot;
-  if (length20 < width10) {
+  const [width10, length26] = props.slot;
+  if (length26 < width10) {
     issue("Slot length must be at least its width", "slot");
     return;
   }
   const radius = width10 / 2;
-  const halfStraight = (length20 - width10) / 2;
+  const halfStraight = (length26 - width10) / 2;
   const inset = props.edgeMargin + radius;
   const [x, y] = props.centers;
   if (!Number.isFinite(inset)) {
     issue("Derived slot centers must be finite", "edgeMargin");
     return;
   }
-  if (x <= length20 / 2 || y <= length20 / 2)
+  if (x <= length26 / 2 || y <= length26 / 2)
     issue("Slots must leave material at the right-angle corner", "centers");
   const normalRatio = Math.min(props.width, props.height) / Math.max(props.width, props.height);
   const capSupport = radius / Math.min(props.width, props.height) * Math.hypot(1, normalRatio);
@@ -10473,18 +10953,18 @@ function validate30(props, context) {
   if (Math.hypot(dx, dy) <= width10)
     issue("The two slots must retain a positive separating ligament", "centers");
 }
-var tSlotGussetModelPropsSchema = external_exports.object(shape31).strict().superRefine(validate30);
-var tSlotGussetModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("tslotgusset"), ...shape31 }).strict().superRefine(validate30);
+var tSlotGussetModelPropsSchema = external_exports.object(shape37).strict().superRefine(validate36);
+var tSlotGussetModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("tslotgusset"), ...shape37 }).strict().superRefine(validate36);
 function getTSlotGussetMountingSlots(input = {}) {
   const props = tSlotGussetModelPropsSchema.parse(input);
-  const [width10, length20] = props.slot;
+  const [width10, length26] = props.slot;
   const inset = props.edgeMargin + width10 / 2;
   return [
     {
       center: { x: props.centers[0], y: inset, z: 0 },
       orientation: 0,
       width: width10,
-      length: length20,
+      length: length26,
       depth: props.thickness,
       direction: { x: 0, y: 0, z: 1 }
     },
@@ -10492,7 +10972,7 @@ function getTSlotGussetMountingSlots(input = {}) {
       center: { x: inset, y: props.centers[1], z: 0 },
       orientation: 90,
       width: width10,
-      length: length20,
+      length: length26,
       depth: props.thickness,
       direction: { x: 0, y: 0, z: 1 }
     }
@@ -10539,7 +11019,7 @@ function parseTSlotGussetModelParams(raw) {
   }
   return tSlotGussetModelDefinitionSchema.parse(props);
 }
-var model37 = defineModel({
+var model43 = defineModel({
   name: "tslotgusset",
   schema: tSlotGussetModelDefinitionSchema,
   parse: parseTSlotGussetModelParams,
@@ -10550,10 +11030,10 @@ var model37 = defineModel({
     omittedStringFlags14
   )
 });
-function register37(registry2) {
-  registry2.register(model37);
+function register43(registry2) {
+  registry2.register(model43);
 }
-var shape32 = {
+var shape38 = {
   width: positiveGearLengthSchema.default(20),
   /** Equal leg extents from the virtual intersection of the inside flats. */
   legLength: positiveGearLengthSchema.default(40),
@@ -10565,7 +11045,7 @@ var shape32 = {
   holeOffset: positiveGearLengthSchema.default(20),
   bendRadius: nonnegativeGearLengthSchema.default(0)
 };
-function validate31(props, context) {
+function validate37(props, context) {
   const issue = (message, path) => context.addIssue({ code: "custom", message, path: [path] });
   if (!Number.isFinite(props.bendRadius + props.thickness)) {
     issue("Outside bend radius must be finite", "bendRadius");
@@ -10583,8 +11063,8 @@ function validate31(props, context) {
   if (props.holeOffset + radius >= props.legLength)
     issue("Holes must leave material at the free leg ends", "holeOffset");
 }
-var tSlotInsideCornerModelPropsSchema = external_exports.object(shape32).strict().superRefine(validate31);
-var tSlotInsideCornerModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("tslotinsidecorner"), ...shape32 }).strict().superRefine(validate31);
+var tSlotInsideCornerModelPropsSchema = external_exports.object(shape38).strict().superRefine(validate37);
+var tSlotInsideCornerModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("tslotinsidecorner"), ...shape38 }).strict().superRefine(validate37);
 var lengths21 = {
   w: "width",
   width: "width",
@@ -10622,13 +11102,13 @@ function parseTSlotInsideCornerModelParams(raw) {
   }
   return tSlotInsideCornerModelDefinitionSchema.parse(props);
 }
-var model38 = defineModel({
+var model44 = defineModel({
   name: "tslotinsidecorner",
   schema: tSlotInsideCornerModelDefinitionSchema,
   parse: parseTSlotInsideCornerModelParams
 });
-function register38(registry2) {
-  registry2.register(model38);
+function register44(registry2) {
+  registry2.register(model44);
 }
 function getNemaMotorReferencePoints(input) {
   const p = nemaMotorModelPropsSchema.parse(input);
@@ -10712,7 +11192,13 @@ var modelDefinitionSchema = external_exports.union([
   model35.schema,
   model36.schema,
   model37.schema,
-  model38.schema
+  model38.schema,
+  model39.schema,
+  model40.schema,
+  model41.schema,
+  model42.schema,
+  model43.schema,
+  model44.schema
 ]);
 function registerAllModels(registry2) {
   register(registry2);
@@ -10753,6 +11239,12 @@ function registerAllModels(registry2) {
   register36(registry2);
   register37(registry2);
   register38(registry2);
+  register39(registry2);
+  register40(registry2);
+  register41(registry2);
+  register42(registry2);
+  register43(registry2);
+  register44(registry2);
 }
 var registry = new ModelRegistry();
 registerAllModels(registry);
@@ -10935,24 +11427,24 @@ var FootprintPlatedHole = ({
 };
 
 // lib/model-registry.ts
-function defineModelRenderer(model76) {
-  return model76;
+function defineModelRenderer(model88) {
+  return model88;
 }
 var ModelRendererRegistry = class {
   models = /* @__PURE__ */ new Map();
-  register(model76) {
-    if (typeof model76.name !== "string" || !/^[a-z]+$/.test(model76.name)) {
+  register(model88) {
+    if (typeof model88.name !== "string" || !/^[a-z]+$/.test(model88.name)) {
       throw new Error(
         "Model renderer names must contain only lowercase letters"
       );
     }
-    if (this.models.has(model76.name)) {
-      throw new Error(`Model renderer "${model76.name}" is already registered`);
+    if (this.models.has(model88.name)) {
+      throw new Error(`Model renderer "${model88.name}" is already registered`);
     }
-    if (model76.pads !== "none" && model76.pads !== "footprinter") {
+    if (model88.pads !== "none" && model88.pads !== "footprinter") {
       throw new Error('Model renderer pads must be "none" or "footprinter"');
     }
-    const { name, schema, render: render2, pads } = model76;
+    const { name, schema, render: render2, pads } = model88;
     this.models.set(name, {
       name,
       schema,
@@ -10978,8 +11470,118 @@ var ModelRendererRegistry = class {
   }
 };
 
-// lib/mechanical/indexedMeshToGeom3.ts
+// 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 = (shape39, height10) => extrusions.extrudeLinear({ height: height10 }, shape39);
+function filletProfile(points, radii, width10, height10) {
+  const outline = [];
+  for (let i = 0; i < points.length; i++) {
+    const a = points[(i + points.length - 1) % points.length];
+    const b = points[i];
+    const c = points[(i + 1) % points.length];
+    const radius = radii[i];
+    if (!radius) {
+      outline.push([b[0] - width10 / 2, b[1] - height10 / 2]);
+      continue;
+    }
+    const al = Math.hypot(a[0] - b[0], a[1] - b[1]);
+    const cl = Math.hypot(c[0] - b[0], c[1] - b[1]);
+    const u = [(a[0] - b[0]) / al, (a[1] - b[1]) / al];
+    const v = [(c[0] - b[0]) / cl, (c[1] - b[1]) / cl];
+    const center = [
+      b[0] + radius * (u[0] + v[0]),
+      b[1] + radius * (u[1] + v[1])
+    ];
+    const start = Math.atan2(
+      b[1] + radius * u[1] - center[1],
+      b[0] + radius * u[0] - center[0]
+    );
+    const turn = u[1] * v[0] - u[0] * v[1] > 0 ? 1 : -1;
+    for (let j = 0; j <= 16; j++) {
+      const angle = start + turn * j * Math.PI / 32;
+      outline.push([
+        center[0] + radius * Math.cos(angle) - width10 / 2,
+        center[1] + radius * Math.sin(angle) - height10 / 2
+      ]);
+    }
+  }
+  return polygon({ points: outline });
+}
+function createAngleBarGeom(input) {
+  const p = angleBarModelPropsSchema.parse(input);
+  return profile(
+    filletProfile(
+      [
+        [0, 0],
+        [p.width, 0],
+        [p.width, p.thickness],
+        [p.thickness, p.thickness],
+        [p.thickness, p.height],
+        [0, p.height]
+      ],
+      [0, p.tipRadius, p.tipRadius, p.innerRadius, p.tipRadius, p.tipRadius],
+      p.width,
+      p.height
+    ),
+    p.length
+  );
+}
+function createAngleBarMesh(input) {
+  const geom = generalize(
+    { snap: true, triangulate: true },
+    createAngleBarGeom(input)
+  );
+  const epsilon = Math.max(...measurements.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 geometries.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/anglebar/AngleBar.tsx
+function AngleBar({ color = "#929da9", ...props }) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createAngleBarGeom(props) }) });
+}
+
+// lib/models/anglebar/register.tsx
+var model45 = defineModelRenderer({
+  name: "anglebar",
+  schema: angleBarModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(AngleBar, { ...props }),
+  pads: "none"
+});
+function register45(registry2) {
+  registry2.register(model45);
+}
+
+// lib/mechanical/indexedMeshToGeom3.ts
+import jscad2 from "@jscad/modeling";
 function indexedMeshToGeom3(mesh) {
   const polygons = [];
   for (let i = 0; i < mesh.indices.length; i += 3)
@@ -10990,7 +11592,7 @@ function indexedMeshToGeom3(mesh) {
         mesh.positions[index * 3 + 2]
       ])
     );
-  return jscad.geometries.geom3.fromPoints(polygons);
+  return jscad2.geometries.geom3.fromPoints(polygons);
 }
 
 // lib/models/ballbearing/mesh.ts
@@ -11106,7 +11708,7 @@ function createBallBearingMesh(input = {}, options = {}) {
     if (face2 === "open") continue;
     const t = d.closureThickness;
     const ri = d.innerRaceOuterRadius, ro = d.outerRaceInnerRadius;
-    const shape33 = face2 === "shielded" ? [
+    const shape39 = face2 === "shielded" ? [
       [ro, 0],
       [ro, t * 0.45],
       [ri, t * 0.45],
@@ -11119,11 +11721,11 @@ function createBallBearingMesh(input = {}, options = {}) {
       [ri + 0.15 * (ro - ri), 0.5 * t],
       [ro - 0.15 * (ro - ri), 0.5 * t]
     ];
-    const profile = sign === -1 ? shape33 : shape33.map(([r, z]) => [r, d.width - z]).reverse();
+    const profile6 = sign === -1 ? shape39 : shape39.map(([r, z]) => [r, d.width - z]).reverse();
     parts.push({
       name: `${face2} ${sign < 0 ? "lower" : "upper"}`,
       color: face2 === "sealed" ? "#252a30" : "#b5bbc3",
-      mesh: revolve(profile, segments)
+      mesh: revolve(profile6, segments)
     });
   }
   return { ...combine(parts), parts };
@@ -11140,21 +11742,21 @@ function checkPrecision(lengths22) {
       "Bearing dimensions exceed the renderer's numerical resolution"
     );
 }
-function revolve(profile, segments) {
+function revolve(profile6, segments) {
   const positions = [];
   const indices = [];
-  for (const [radius, z] of profile)
+  for (const [radius, z] of profile6)
     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 < profile.length; j++)
+  for (let j = 0; j < profile6.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) % profile.length * segments + (i + 1) % segments;
-      const e = (j + 1) % profile.length * segments + i;
+      const c = (j + 1) % profile6.length * segments + (i + 1) % segments;
+      const e = (j + 1) % profile6.length * segments + i;
       indices.push(a, b, c, a, c, e);
     }
   return { positions, indices };
@@ -11165,7 +11767,7 @@ function annularSector(inner, outer, z0, z1, start, end, segments) {
     Math.ceil((end - start) / (2 * Math.PI) * segments)
   );
   const count = steps + 1;
-  const profile = [
+  const profile6 = [
     [outer, z0],
     [outer, z1],
     [inner, z1],
@@ -11173,7 +11775,7 @@ function annularSector(inner, outer, z0, z1, start, end, segments) {
   ];
   const positions = [];
   const indices = [];
-  for (const [r, z] of profile)
+  for (const [r, z] of profile6)
     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);
@@ -11243,14 +11845,14 @@ function BallBearing({ color, ...props }) {
 }
 
 // lib/models/ballbearing/register.tsx
-var model39 = defineModelRenderer({
+var model46 = defineModelRenderer({
   name: "ballbearing",
   schema: ballBearingModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(BallBearing, { ...props }),
   pads: "none"
 });
-function register39(registry2) {
-  registry2.register(model39);
+function register46(registry2) {
+  registry2.register(model46);
 }
 
 // lib/models/balltransferunit/mesh.ts
@@ -11364,7 +11966,7 @@ function createBallTransferUnitMesh(input = {}) {
     );
   const segments = 96;
   const latitude = 48;
-  const profile = [
+  const profile6 = [
     [d.bodyRadius, 0],
     [d.bodyRadius, d.flangeBottomZ],
     [d.flangeRadius, d.flangeBottomZ],
@@ -11377,12 +11979,12 @@ function createBallTransferUnitMesh(input = {}) {
   for (let j = 1; j < latitude; j++) {
     const angle = j * Math.PI / latitude;
     if ((angle - openingAngle) * d.socketRadius > resolution7)
-      profile.push([
+      profile6.push([
         d.socketRadius * Math.sin(angle),
         d.ballCenterZ + d.socketRadius * Math.cos(angle)
       ]);
   }
-  profile.push([0, d.socketBottomZ], [0, 0]);
+  profile6.push([0, d.socketBottomZ], [0, 0]);
   const holes = d.mountingHoles.map(
     ({ x, y, diameter }) => circularProfile(x, y, diameter / 2, segments)
   );
@@ -11390,7 +11992,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(profile, segments, /* @__PURE__ */ new Set([1, 3])),
+    revolve2(profile6, segments, /* @__PURE__ */ new Set([1, 3])),
     cap(
       flangeOutline,
       [circularProfile(0, 0, d.bodyRadius, segments), ...holes],
@@ -11427,10 +12029,10 @@ function createBallTransferUnitMesh(input = {}) {
   ];
   return { positions, indices, parts };
 }
-function revolve2(profile, segments, omittedEdges = /* @__PURE__ */ new Set()) {
+function revolve2(profile6, segments, omittedEdges = /* @__PURE__ */ new Set()) {
   const positions = [];
   const indices = [];
-  const rings = profile.map(([radius, z]) => {
+  const rings = profile6.map(([radius, z]) => {
     const start = positions.length / 3;
     const count = radius === 0 ? 1 : segments;
     for (let i = 0; i < count; i++) {
@@ -11499,14 +12101,14 @@ function BallTransferUnit({ color, ...props }) {
 }
 
 // lib/models/balltransferunit/register.tsx
-var model40 = defineModelRenderer({
+var model47 = defineModelRenderer({
   name: "balltransferunit",
   schema: ballTransferUnitModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(BallTransferUnit, { ...props }),
   pads: "none"
 });
-function register40(registry2) {
-  registry2.register(model40);
+function register47(registry2) {
+  registry2.register(model47);
 }
 
 // lib/models/buttonscrew/mesh.ts
@@ -11626,14 +12228,14 @@ function ButtonScrew({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/buttonscrew/register.tsx
-var model41 = defineModelRenderer({
+var model48 = defineModelRenderer({
   name: "buttonscrew",
   schema: buttonScrewModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(ButtonScrew, { ...props }),
   pads: "none"
 });
-function register41(registry2) {
-  registry2.register(model41);
+function register48(registry2) {
+  registry2.register(model48);
 }
 
 // lib/models/cablegrommet/mesh.ts
@@ -11701,21 +12303,142 @@ function CableGrommet({
 }
 
 // lib/models/cablegrommet/register.tsx
-var model42 = defineModelRenderer({
+var model49 = defineModelRenderer({
   name: "cablegrommet",
   schema: cableGrommetModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(CableGrommet, { ...props }),
   pads: "none"
 });
-function register42(registry2) {
-  registry2.register(model42);
+function register49(registry2) {
+  registry2.register(model49);
 }
 
-// lib/models/clampingshaftcollar/mesh.ts
+// 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 = (shape39, height10) => extrusions2.extrudeLinear({ height: height10 }, shape39);
+function filletProfile2(points, radii, width10, height10) {
+  const outline = [];
+  for (let i = 0; i < points.length; i++) {
+    const a = points[(i + points.length - 1) % points.length];
+    const b = points[i];
+    const c = points[(i + 1) % points.length];
+    const radius = radii[i];
+    if (!radius) {
+      outline.push([b[0] - width10 / 2, b[1] - height10 / 2]);
+      continue;
+    }
+    const al = Math.hypot(a[0] - b[0], a[1] - b[1]);
+    const cl = Math.hypot(c[0] - b[0], c[1] - b[1]);
+    const u = [(a[0] - b[0]) / al, (a[1] - b[1]) / al];
+    const v = [(c[0] - b[0]) / cl, (c[1] - b[1]) / cl];
+    const center = [
+      b[0] + radius * (u[0] + v[0]),
+      b[1] + radius * (u[1] + v[1])
+    ];
+    const start = Math.atan2(
+      b[1] + radius * u[1] - center[1],
+      b[0] + radius * u[0] - center[0]
+    );
+    const turn = u[1] * v[0] - u[0] * v[1] > 0 ? 1 : -1;
+    for (let j = 0; j <= 16; j++) {
+      const angle = start + turn * j * Math.PI / 32;
+      outline.push([
+        center[0] + radius * Math.cos(angle) - width10 / 2,
+        center[1] + radius * Math.sin(angle) - height10 / 2
+      ]);
+    }
+  }
+  return polygon2({ points: outline });
+}
+function createChannelBarGeom(input) {
+  const p = channelBarModelPropsSchema.parse(input);
+  return profile2(
+    filletProfile2(
+      [
+        [0, 0],
+        [p.width, 0],
+        [p.width, p.height],
+        [p.width - p.flangeThickness, p.height],
+        [p.width - p.flangeThickness, p.webThickness],
+        [p.flangeThickness, p.webThickness],
+        [p.flangeThickness, p.height],
+        [0, p.height]
+      ],
+      [
+        0,
+        0,
+        p.tipRadius,
+        p.tipRadius,
+        p.innerRadius,
+        p.innerRadius,
+        p.tipRadius,
+        p.tipRadius
+      ],
+      p.width,
+      p.height
+    ),
+    p.length
+  );
+}
+function createChannelBarMesh(input) {
+  const geom = generalize2(
+    { snap: true, triangulate: true },
+    createChannelBarGeom(input)
+  );
+  const epsilon = Math.max(...measurements2.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 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]);
+      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/channelbar/ChannelBar.tsx
+function ChannelBar({ color = "#929da9", ...props }) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createChannelBarGeom(props) }) });
+}
+
+// lib/models/channelbar/register.tsx
+var model50 = defineModelRenderer({
+  name: "channelbar",
+  schema: channelBarModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(ChannelBar, { ...props }),
+  pads: "none"
+});
+function register50(registry2) {
+  registry2.register(model50);
+}
+
+// lib/models/clampingshaftcollar/mesh.ts
+import jscad5 from "@jscad/modeling";
 
 // lib/mechanical/shaft-mount-geometry.ts
-import jscad2 from "@jscad/modeling";
+import jscad4 from "@jscad/modeling";
 var bodySegments = 64;
 var threadSegments = 24;
 var samplesPerTurn = 12;
@@ -11736,9 +12459,9 @@ function createAnnularSleeve({
   outerRadius,
   boreARadius,
   boreBRadius = boreARadius,
-  length: length20,
+  length: length26,
   chamfer,
-  stepZ = length20 / 2
+  stepZ = length26 / 2
 }) {
   const halfAngle = Math.PI / bodySegments;
   const cosine = Math.cos(halfAngle);
@@ -11749,31 +12472,31 @@ function createAnnularSleeve({
   const raw = [
     [0, outerRadius - chamfer, false],
     [chamfer, outerRadius, false],
-    [length20 - chamfer, outerRadius, false],
-    [length20, outerRadius - chamfer, false],
-    [length20, boreBRadius + chamfer, true],
-    [length20 - chamfer, boreBRadius, true],
+    [length26 - chamfer, outerRadius, false],
+    [length26, outerRadius - chamfer, false],
+    [length26, boreBRadius + chamfer, true],
+    [length26 - chamfer, boreBRadius, true],
     [stepZ, boreBRadius, true],
     [stepZ, boreARadius, true],
     [chamfer, boreARadius, true],
     [0, boreARadius + chamfer, true]
   ];
-  const profile = raw.filter(
+  const profile6 = raw.filter(
     ([z, r], i) => i === 0 || z !== raw[i - 1][0] || r !== raw[i - 1][1]
   );
   const positions = [];
   const indices = [];
-  for (const [z, r, isBore] of profile)
+  for (const [z, r, isBore] of profile6)
     for (let i = 0; i < bodySegments; i++) {
       const angle = (i + (isBore ? 0.5 : 0)) * Math.PI * 2 / bodySegments;
       const radius = isBore ? r / cosine : r;
       positions.push(radius * Math.cos(angle), radius * Math.sin(angle), z);
     }
-  for (let row = 0; row < profile.length; row++)
+  for (let row = 0; row < profile6.length; row++)
     for (let i = 0; i < bodySegments; i++) {
       const next = (i + 1) % bodySegments;
       const a = row * bodySegments + i, b = row * bodySegments + next;
-      const c = (row + 1) % profile.length * bodySegments + next, d = (row + 1) % profile.length * bodySegments + i;
+      const c = (row + 1) % profile6.length * bodySegments + next, d = (row + 1) % profile6.length * bodySegments + i;
       indices.push(a, b, c, a, c, d);
     }
   return indexedMeshToGeom3({ positions, indices });
@@ -11831,10 +12554,10 @@ function createMountingHoleCutter(hole) {
 function subtractShaftMountParts(body, ...cutters) {
   const factor = 100;
   const scaled = [body, ...cutters].map(
-    (geometry) => jscad2.transforms.scale([factor, factor, factor], geometry)
+    (geometry) => jscad4.transforms.scale([factor, factor, factor], geometry)
   );
-  const result = jscad2.booleans.subtract(scaled[0], ...scaled.slice(1));
-  return jscad2.transforms.scale([1 / factor, 1 / factor, 1 / factor], result);
+  const result = jscad4.booleans.subtract(scaled[0], ...scaled.slice(1));
+  return jscad4.transforms.scale([1 / factor, 1 / factor, 1 / factor], result);
 }
 function finishShaftMountMesh(geometry) {
   const positions = [];
@@ -11860,8 +12583,8 @@ function finishShaftMountMesh(geometry) {
     vertices.set(key, [...vertices.get(key) ?? [], index]);
     return index;
   };
-  const polygons = jscad2.geometries.geom3.toPolygons(geometry).map(
-    (polygon) => polygon.vertices.map(weld).filter((id, i, ids) => id !== ids[(i + ids.length - 1) % ids.length])
+  const polygons = jscad4.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;
     let origin = [];
@@ -11885,9 +12608,9 @@ function finishShaftMountMesh(geometry) {
   });
   const edgeKey = (a, b) => `${Math.min(a, b)},${Math.max(a, b)}`;
   const edges = /* @__PURE__ */ new Map();
-  for (const polygon of polygons)
-    for (let i = 0; i < polygon.length; i++) {
-      const a = polygon[i], b = polygon[(i + 1) % polygon.length], key = edgeKey(a, b);
+  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 edge = edges.get(key) ?? { a, b, count: 0 };
       edge.count++;
       edges.set(key, edge);
@@ -11918,10 +12641,10 @@ function finishShaftMountMesh(geometry) {
     splits.set(`${b},${a}`, points.map((p) => p.id).reverse());
   }
   const indices = [];
-  for (const polygon of polygons) {
-    const perimeter = polygon.flatMap((a, i) => [
+  for (const polygon4 of polygons) {
+    const perimeter = polygon4.flatMap((a, i) => [
       a,
-      ...(splits.get(`${a},${polygon[(i + 1) % polygon.length]}`) ?? []).filter((id) => !polygon.includes(id))
+      ...(splits.get(`${a},${polygon4[(i + 1) % polygon4.length]}`) ?? []).filter((id) => !polygon4.includes(id))
     ]);
     const unique = perimeter.filter(
       (id, i) => id !== perimeter[(i + perimeter.length - 1) % perimeter.length]
@@ -11968,7 +12691,7 @@ function createClampingShaftCollarMesh(input) {
   });
   const s = dimensions5.split;
   const epsilon = 1e-4;
-  const slit = jscad3.primitives.cuboid({
+  const slit = jscad5.primitives.cuboid({
     size: [
       s.xMax - s.xMin + epsilon,
       s.yMax - s.yMin,
@@ -12002,14 +12725,14 @@ function ClampingShaftCollar({
 }
 
 // lib/models/clampingshaftcollar/register.tsx
-var model43 = defineModelRenderer({
+var model51 = defineModelRenderer({
   name: "clampingshaftcollar",
   schema: clampingShaftCollarModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(ClampingShaftCollar, { ...props }),
   pads: "none"
 });
-function register43(registry2) {
-  registry2.register(model43);
+function register51(registry2) {
+  registry2.register(model51);
 }
 
 // lib/mechanical/clip-mesh-to-z-range.ts
@@ -12047,12 +12770,12 @@ function clipMeshToZRange(mesh, lower, upper) {
     }
     return point;
   };
-  const clip = (polygon, plane, keepAbove) => {
+  const clip = (polygon4, plane, keepAbove) => {
     const result = [];
     const inside = (point) => keepAbove ? point.coordinates[2] >= plane : point.coordinates[2] <= plane;
-    for (let index = 0; index < polygon.length; index++) {
-      const a = polygon[index];
-      const b = polygon[(index + 1) % polygon.length];
+    for (let index = 0; index < polygon4.length; index++) {
+      const a = polygon4[index];
+      const b = polygon4[(index + 1) % polygon4.length];
       if (inside(a)) result.push(a);
       if (inside(a) !== inside(b)) result.push(crossing(a, b, plane));
     }
@@ -12074,9 +12797,9 @@ function clipMeshToZRange(mesh, lower, upper) {
   };
   for (let index = 0; index < mesh.indices.length; index += 3) {
     const triangle = mesh.indices.slice(index, index + 3).map((i) => originals[i]);
-    const polygon = clip(clip(triangle, lower, true), upper, false);
-    for (let corner = 1; corner + 1 < polygon.length; corner++) {
-      const points = [polygon[0], polygon[corner], polygon[corner + 1]];
+    const polygon4 = clip(clip(triangle, lower, true), upper, false);
+    for (let corner = 1; corner + 1 < polygon4.length; corner++) {
+      const points = [polygon4[0], polygon4[corner], polygon4[corner + 1]];
       if (new Set(points.map((point) => point.key)).size === 3)
         indices.push(...points.map(vertex));
     }
@@ -12205,14 +12928,14 @@ function CompressionSpring({
 }
 
 // lib/models/compressionspring/register.tsx
-var model44 = defineModelRenderer({
+var model52 = defineModelRenderer({
   name: "compressionspring",
   schema: compressionSpringModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(CompressionSpring, { ...props }),
   pads: "none"
 });
-function register44(registry2) {
-  registry2.register(model44);
+function register52(registry2) {
+  registry2.register(model52);
 }
 
 // lib/models/dowelpin/mesh.ts
@@ -12263,14 +12986,14 @@ function DowelPin({ color = "#929da9", ...props }) {
 }
 
 // lib/models/dowelpin/register.tsx
-var model45 = defineModelRenderer({
+var model53 = defineModelRenderer({
   name: "dowelpin",
   schema: dowelPinModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(DowelPin, { ...props }),
   pads: "none"
 });
-function register45(registry2) {
-  registry2.register(model45);
+function register53(registry2) {
+  registry2.register(model53);
 }
 
 // lib/models/femalestandoff/mesh.ts
@@ -12372,14 +13095,14 @@ function FemaleStandoff({
 }
 
 // lib/models/femalestandoff/register.tsx
-var model46 = defineModelRenderer({
+var model54 = defineModelRenderer({
   name: "femalestandoff",
   schema: femaleStandoffModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FemaleStandoff, { ...props }),
   pads: "none"
 });
-function register46(registry2) {
-  registry2.register(model46);
+function register54(registry2) {
+  registry2.register(model54);
 }
 
 // lib/models/flangebolt/mesh.ts
@@ -12526,14 +13249,14 @@ function FlangeBolt({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/flangebolt/register.tsx
-var model47 = defineModelRenderer({
+var model55 = defineModelRenderer({
   name: "flangebolt",
   schema: flangeboltModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlangeBolt, { ...props }),
   pads: "none"
-});
-function register47(registry2) {
-  registry2.register(model47);
+});
+function register55(registry2) {
+  registry2.register(model55);
 }
 
 // lib/models/flangedbushing/mesh.ts
@@ -12543,7 +13266,7 @@ function createFlangedBushingMesh(input) {
   const ri = d.innerDiameter / 2;
   const ro = d.outerDiameter / 2;
   const rf = d.flangeDiameter / 2;
-  const profile = [
+  const profile6 = [
     [rf, 0],
     [rf, d.shoulderZ],
     [ro, d.shoulderZ],
@@ -12554,14 +13277,14 @@ function createFlangedBushingMesh(input) {
   const segments = 96;
   const positions = [];
   const indices = [];
-  for (const [radius, z] of profile)
+  for (const [radius, z] of profile6)
     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 < profile.length; ring++) {
+  for (let ring = 0; ring < profile6.length; ring++) {
     const a = ring * segments;
-    const b = (ring + 1) % profile.length * segments;
+    const b = (ring + 1) % profile6.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);
@@ -12582,14 +13305,14 @@ function FlangedBushing({
 }
 
 // lib/models/flangedbushing/register.tsx
-var model48 = defineModelRenderer({
+var model56 = defineModelRenderer({
   name: "flangedbushing",
   schema: flangedBushingModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlangedBushing, { ...props }),
   pads: "none"
 });
-function register48(registry2) {
-  registry2.register(model48);
+function register56(registry2) {
+  registry2.register(model56);
 }
 
 // lib/models/flangenut/mesh.ts
@@ -12695,14 +13418,14 @@ function FlangeNut({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/flangenut/register.tsx
-var model49 = defineModelRenderer({
+var model57 = defineModelRenderer({
   name: "flangenut",
   schema: flangeNutModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlangeNut, { ...props }),
   pads: "none"
 });
-function register49(registry2) {
-  registry2.register(model49);
+function register57(registry2) {
+  registry2.register(model57);
 }
 
 // lib/models/flatheadscrew/mesh.ts
@@ -12829,14 +13552,14 @@ function FlatHeadScrew({
 }
 
 // lib/models/flatheadscrew/register.tsx
-var model50 = defineModelRenderer({
+var model58 = defineModelRenderer({
   name: "flatheadscrew",
   schema: flatHeadScrewModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlatHeadScrew, { ...props }),
   pads: "none"
 });
-function register50(registry2) {
-  registry2.register(model50);
+function register58(registry2) {
+  registry2.register(model58);
 }
 
 // lib/Screen.tsx
@@ -13511,14 +14234,14 @@ var FlexScreen = (props) => {
 };
 
 // lib/models/flexscreen/register.tsx
-var model51 = defineModelRenderer({
+var model59 = defineModelRenderer({
   name: "flexscreen",
   schema: flexScreenModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlexScreen, { ...props }),
   pads: "footprinter"
 });
-function register51(registry2) {
-  registry2.register(model51);
+function register59(registry2) {
+  registry2.register(model59);
 }
 
 // lib/models/heatsetinsert/mesh.ts
@@ -13603,14 +14326,14 @@ function HeatSetInsert({
 }
 
 // lib/models/heatsetinsert/register.tsx
-var model52 = defineModelRenderer({
+var model60 = defineModelRenderer({
   name: "heatsetinsert",
   schema: heatSetInsertModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HeatSetInsert, { ...props }),
   pads: "none"
 });
-function register52(registry2) {
-  registry2.register(model52);
+function register60(registry2) {
+  registry2.register(model60);
 }
 
 // lib/mechanical/spur-gear-mesh.ts
@@ -13691,7 +14414,7 @@ function createTwistedSpurGearMesh(input, twist = 0, segmentsPerTurn = 32) {
     return start;
   };
   const circleSegments = Math.max(48, Math.min(256, props.toothCount * 4));
-  const circle2 = (radius) => Array.from({ length: circleSegments }, (_, segment) => {
+  const circle3 = (radius) => Array.from({ length: circleSegments }, (_, segment) => {
     const angle = phase + segment * Math.PI * 2 / circleSegments;
     return [radius * Math.cos(angle), radius * Math.sin(angle)];
   });
@@ -13754,7 +14477,7 @@ function createTwistedSpurGearMesh(input, twist = 0, segmentsPerTurn = 32) {
   }
   const hasHub = props.hubDiameter > 0 && props.hubLength > 0;
   const height10 = props.faceWidth + (hasHub ? props.hubLength : 0);
-  const bore = props.boreDiameter > 0 ? circle2(props.boreDiameter / 2) : void 0;
+  const bore = props.boreDiameter > 0 ? circle3(props.boreDiameter / 2) : void 0;
   const boreBottom = bore ? ring(bore, 0) : void 0;
   const boreTop = bore ? ring(bore, height10) : void 0;
   if (bore) connect(boreBottom, boreTop, bore.length, true);
@@ -13765,7 +14488,7 @@ function createTwistedSpurGearMesh(input, twist = 0, segmentsPerTurn = 32) {
     bore ? { points: bore, start: boreBottom } : void 0
   );
   if (hasHub) {
-    const hub = circle2(props.hubDiameter / 2);
+    const hub = circle3(props.hubDiameter / 2);
     const hubBottom = ring(hub, props.faceWidth);
     const hubTop = ring(hub, height10);
     cap2(topOutline, top, true, { points: hub, start: hubBottom });
@@ -13803,14 +14526,14 @@ function HelicalGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/helicalgear/register.tsx
-var model53 = defineModelRenderer({
+var model61 = defineModelRenderer({
   name: "helicalgear",
   schema: helicalGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HelicalGear, { ...props }),
   pads: "none"
 });
-function register53(registry2) {
-  registry2.register(model53);
+function register61(registry2) {
+  registry2.register(model61);
 }
 
 // lib/models/hexbolt/mesh.ts
@@ -13945,14 +14668,14 @@ function HexBolt({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/hexbolt/register.tsx
-var model54 = defineModelRenderer({
+var model62 = defineModelRenderer({
   name: "hexbolt",
   schema: hexBoltModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexBolt, { ...props }),
   pads: "none"
 });
-function register54(registry2) {
-  registry2.register(model54);
+function register62(registry2) {
+  registry2.register(model62);
 }
 
 // lib/models/hexnut/mesh.ts
@@ -14071,14 +14794,14 @@ function HexNut({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/hexnut/register.tsx
-var model55 = defineModelRenderer({
+var model63 = defineModelRenderer({
   name: "hexnut",
   schema: hexNutModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexNut, { ...props }),
   pads: "none"
 });
-function register55(registry2) {
-  registry2.register(model55);
+function register63(registry2) {
+  registry2.register(model63);
 }
 
 // lib/mechanical/hex-socket-bolt-mesh.ts
@@ -14092,9 +14815,9 @@ var createHexSocketBoltMesh = (input) => {
     socketWidth,
     socketDepth
   } = hexSocketBoltDimensions[props.metricSize];
-  const { length: length20, showThreads } = props;
+  const { length: length26, showThreads } = props;
   const segments = 96;
-  const steps = showThreads ? Math.max(2, Math.ceil(length20 / pitch * 24)) : 2;
+  const steps = showThreads ? Math.max(2, Math.ceil(length26 / pitch * 24)) : 2;
   if (steps > 24e3)
     throw new Error(
       "Bolt length exceeds mesh resolution limit (1000 thread turns)"
@@ -14104,7 +14827,7 @@ var createHexSocketBoltMesh = (input) => {
   const radius = diameter / 2;
   const depth = pitch * 0.61343;
   const bevel = Math.min(0.2, headHeight * 0.08);
-  const tipBevel = Math.min(pitch * 0.6, length20 / 3);
+  const tipBevel = Math.min(pitch * 0.6, length26 / 3);
   const ring = (z, radiusAt) => {
     const start = positions.length / 3;
     for (let i = 0; i < segments; i++) {
@@ -14132,8 +14855,8 @@ var createHexSocketBoltMesh = (input) => {
   let previous = -1;
   const shaftLevels = showThreads ? Array.from(
     { length: steps + 1 },
-    (_, step) => -length20 + length20 * step / steps
-  ) : [-length20, -length20 + tipBevel, 0];
+    (_, step) => -length26 + length26 * step / steps
+  ) : [-length26, -length26 + tipBevel, 0];
   for (const z of shaftLevels) {
     const current = ring(z, (angle) => {
       const phase = ((z / pitch - angle / (2 * Math.PI)) % 1 + 1) % 1;
@@ -14144,10 +14867,10 @@ var createHexSocketBoltMesh = (input) => {
       );
       const endRamp = Math.min(
         1,
-        (z + length20) / tipBevel,
-        -z / Math.min(pitch / 2, length20 / 3)
+        (z + length26) / tipBevel,
+        -z / Math.min(pitch / 2, length26 / 3)
       );
-      const tipCut = tipBevel * Math.max(0, 1 - (z + length20) / tipBevel);
+      const tipCut = tipBevel * Math.max(0, 1 - (z + length26) / tipBevel);
       return radius - (showThreads ? groove * endRamp : 0) - tipCut;
     });
     if (previous < 0) cap2(current, z, false);
@@ -14183,14 +14906,14 @@ function HexSocketBolt({
 }
 
 // lib/models/hexsocketbolt/register.tsx
-var model56 = defineModelRenderer({
+var model64 = defineModelRenderer({
   name: "hexsocketbolt",
   schema: hexSocketBoltModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexSocketBolt, { ...props }),
   pads: "none"
 });
-function register56(registry2) {
-  registry2.register(model56);
+function register64(registry2) {
+  registry2.register(model64);
 }
 
 // lib/models/hollowpositioningarmtube/mesh.ts
@@ -14303,14 +15026,14 @@ function HollowPositioningArmTube({
 }
 
 // lib/models/hollowpositioningarmtube/register.tsx
-var model57 = defineModelRenderer({
+var model65 = defineModelRenderer({
   name: "hollowpositioningarmtube",
   schema: hollowPositioningArmTubeModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HollowPositioningArmTube, { ...props }),
   pads: "none"
 });
-function register57(registry2) {
-  registry2.register(model57);
+function register65(registry2) {
+  registry2.register(model65);
 }
 
 // lib/models/malefemalestandoff/mesh.ts
@@ -14442,21 +15165,21 @@ function MaleFemaleStandoff({
 }
 
 // lib/models/malefemalestandoff/register.tsx
-var model58 = defineModelRenderer({
+var model66 = defineModelRenderer({
   name: "malefemalestandoff",
   schema: maleFemaleStandoffModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(MaleFemaleStandoff, { ...props }),
   pads: "none"
 });
-function register58(registry2) {
-  registry2.register(model58);
+function register66(registry2) {
+  registry2.register(model66);
 }
 
 // lib/NemaMotor.tsx
-import jscad5 from "@jscad/modeling";
+import jscad7 from "@jscad/modeling";
 
 // lib/utils/nemaMotorWireGeometry.ts
-import jscad4 from "@jscad/modeling";
+import jscad6 from "@jscad/modeling";
 
 // lib/utils/nemaMotorParameters.ts
 var resolveNemaMotorProps = nemaMotorModelPropsSchema.parse.bind(nemaMotorModelPropsSchema);
@@ -14467,9 +15190,9 @@ function createNemaMotorWireGeometry(input) {
   if (p.wireConnection === "none") return [];
   const { position } = getNemaMotorReferencePoints(p).wireside;
   const angle = p.wireSideAngle * Math.PI / 180;
-  const place = (geometry) => jscad4.transforms.translate(
+  const place = (geometry) => jscad6.transforms.translate(
     [position.x, position.y, position.z],
-    jscad4.transforms.rotateZ(angle, geometry)
+    jscad6.transforms.rotateZ(angle, geometry)
   );
   if (p.wireConnection === "stubs") {
     const colors = [
@@ -14485,15 +15208,15 @@ function createNemaMotorWireGeometry(input) {
     return Array.from({ length: p.wireCount }, (_, i) => ({
       color: colors[i],
       geometry: place(
-        jscad4.transforms.translate(
+        jscad6.transforms.translate(
           [
             (p.wireLength - 0.15) / 2,
             (i - (p.wireCount - 1) / 2) * p.wireDiameter * 1.5,
             0
           ],
-          jscad4.transforms.rotateY(
+          jscad6.transforms.rotateY(
             Math.PI / 2,
-            jscad4.primitives.cylinder({
+            jscad6.primitives.cylinder({
               height: p.wireLength + 0.15,
               radius: p.wireDiameter / 2,
               segments: 24
@@ -14508,12 +15231,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 = jscad4.booleans.subtract(
-    jscad4.primitives.cuboid({
+  const shell = jscad6.booleans.subtract(
+    jscad6.primitives.cuboid({
       size: [matingDepth + 0.1, bodyWidth, bodyHeight],
       center: [(matingDepth - 0.1) / 2, 0, 0]
     }),
-    jscad4.primitives.cuboid({
+    jscad6.primitives.cuboid({
       size: [matingDepth - 0.5, bodyWidth - 2 * wall, bodyHeight - 2 * wall],
       center: [matingDepth / 2 + 0.55, 0, 0]
     })
@@ -14523,7 +15246,7 @@ function createNemaMotorWireGeometry(input) {
     ...Array.from({ length: pinCount }, (_, i) => ({
       color: "#b8bec6",
       geometry: place(
-        jscad4.primitives.cuboid({
+        jscad6.primitives.cuboid({
           size: [contactLength, contactSize, contactSize],
           center: [contactLength / 2, (i - (pinCount - 1) / 2) * pitch, 0]
         })
@@ -14615,12 +15338,12 @@ function createNemaMotorSections(input) {
   else {
     const cut = r - p.shaftFlatDepth;
     const angle = Math.acos(cut / r);
-    const profile = Array.from({ length: 97 }, (_, i) => {
+    const profile6 = 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 = profile.map(([x, y]) => [
+    const d = profile6.map(([x, y]) => [
       x * Math.cos(rotation) - y * Math.sin(rotation),
       x * Math.sin(rotation) + y * Math.cos(rotation)
     ]);
@@ -14631,7 +15354,7 @@ function createNemaMotorSections(input) {
 }
 
 // lib/NemaMotor.tsx
-var generalize = jscad5.modifiers.generalize;
+var generalize3 = jscad7.modifiers.generalize;
 function NemaMotor({
   bodyColor = "#242830",
   capColor = "#aeb5bd",
@@ -14640,7 +15363,7 @@ function NemaMotor({
   ...props
 }) {
   const p = resolveNemaMotorProps(props);
-  const screw = p.backFace === "screws" ? jscad5.transforms.rotateX(
+  const screw = p.backFace === "screws" ? jscad7.transforms.rotateX(
     Math.PI,
     createHexSocketBoltGeom({
       metricSize: p.backFaceScrewSize,
@@ -14651,16 +15374,16 @@ function NemaMotor({
   const halfPitch = p.backFaceHoleSpacing / 2;
   return /* @__PURE__ */ jsxs(Fragment2, { children: [
     createNemaMotorSections(p).map((section, index) => {
-      const outline = jscad5.geometries.geom2.fromPoints(section.outline);
-      const profile = section.holes.length ? jscad5.booleans.subtract(
+      const outline = jscad7.geometries.geom2.fromPoints(section.outline);
+      const profile6 = section.holes.length ? jscad7.booleans.subtract(
         outline,
-        ...section.holes.map((h2) => jscad5.geometries.geom2.fromPoints(h2))
+        ...section.holes.map((h2) => jscad7.geometries.geom2.fromPoints(h2))
       ) : outline;
-      const geometry = jscad5.transforms.translate(
+      const geometry = jscad7.transforms.translate(
         [0, 0, section.zMin],
-        jscad5.extrusions.extrudeLinear(
+        jscad7.extrusions.extrudeLinear(
           { height: section.zMax - section.zMin },
-          profile
+          profile6
         )
       );
       return /* @__PURE__ */ jsx(
@@ -14668,7 +15391,7 @@ function NemaMotor({
         {
           material: section.name === "body" ? componentMaterials.moldedPlastic : section.name === "shaft" ? componentMaterials.steel : componentMaterials.brushedMetal,
           color: section.name === "body" ? bodyColor : section.name === "shaft" ? shaftColor : capColor,
-          children: /* @__PURE__ */ jsx(Custom, { geometry: generalize({ simplify: true }, geometry) })
+          children: /* @__PURE__ */ jsx(Custom, { geometry: generalize3({ simplify: true }, geometry) })
         },
         `${section.name}-${index}`
       );
@@ -14678,7 +15401,7 @@ function NemaMotor({
       {
         material: componentMaterials.rubber,
         color,
-        children: /* @__PURE__ */ jsx(Custom, { geometry: generalize({ simplify: true }, geometry) })
+        children: /* @__PURE__ */ jsx(Custom, { geometry: generalize3({ simplify: true }, geometry) })
       },
       `wire-${index}`
     )),
@@ -14691,9 +15414,9 @@ function NemaMotor({
           children: /* @__PURE__ */ jsx(
             Custom,
             {
-              geometry: jscad5.transforms.translate(
+              geometry: jscad7.transforms.translate(
                 [x, y, -p.bodyLength],
-                generalize({ simplify: true }, screw)
+                generalize3({ simplify: true }, screw)
               )
             }
           )
@@ -14708,14 +15431,14 @@ var NEMA17 = (props) => /* @__PURE__ */ jsx(NemaMotor, { ...props, nemaSize: 17
 var NEMA23 = (props) => /* @__PURE__ */ jsx(NemaMotor, { ...props, nemaSize: 23 });
 
 // lib/models/nema/register.tsx
-var model59 = defineModelRenderer({
+var model67 = defineModelRenderer({
   name: "nema",
   schema: nemaMotorModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(NemaMotor, { ...props }),
   pads: "none"
 });
-function register59(registry2) {
-  registry2.register(model59);
+function register67(registry2) {
+  registry2.register(model67);
 }
 
 // lib/models/nylonlocknut/mesh.ts
@@ -14851,14 +15574,14 @@ function NylonLockNut({
 }
 
 // lib/models/nylonlocknut/register.tsx
-var model60 = defineModelRenderer({
+var model68 = defineModelRenderer({
   name: "nylonlocknut",
   schema: nylonLockNutModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(NylonLockNut, { ...props }),
   pads: "none"
 });
-function register60(registry2) {
-  registry2.register(model60);
+function register68(registry2) {
+  registry2.register(model68);
 }
 
 // lib/models/panscrew/mesh.ts
@@ -15064,14 +15787,107 @@ function PanScrew({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/panscrew/register.tsx
-var model61 = defineModelRenderer({
+var model69 = defineModelRenderer({
   name: "panscrew",
   schema: panScrewModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(PanScrew, { ...props }),
   pads: "none"
 });
-function register61(registry2) {
-  registry2.register(model61);
+function register69(registry2) {
+  registry2.register(model69);
+}
+
+// lib/models/perforatedsheet/geometry.ts
+import jscad8 from "@jscad/modeling";
+var {
+  booleans,
+  primitives: primitives3,
+  extrusions: extrusions3,
+  geometries: geometries3,
+  modifiers: modifiers3,
+  measurements: measurements3
+} = jscad8;
+var generalize4 = modifiers3.generalize;
+var { subtract } = booleans;
+var { rectangle: rectangle3, roundedRectangle: roundedRectangle3, circle: circle2 } = primitives3;
+var profile3 = (shape39, height10) => extrusions3.extrudeLinear({ height: height10 }, shape39);
+function perforated(p) {
+  const holes = [];
+  const rows = Math.floor((p.width - 2 * p.edgeY) / p.pitchY + 1 + 1e-10);
+  const cols = Math.floor((p.length - 2 * p.edgeX) / p.pitchX + 1 + 1e-10);
+  for (let row = 0; row < rows; row++)
+    for (let col = 0; col < cols; col++) {
+      const x = p.edgeX + col * p.pitchX + (row % 2 ? p.stagger : 0);
+      if (x > p.length - p.edgeX + 1e-10) continue;
+      holes.push(
+        circle2({
+          radius: p.holeDiameter / 2,
+          segments: 48,
+          center: [x - p.length / 2, p.edgeY + row * p.pitchY - p.width / 2]
+        })
+      );
+    }
+  return profile3(
+    subtract(rectangle3({ size: [p.length, p.width] }), ...holes),
+    p.thickness
+  );
+}
+function createPerforatedSheetGeom(input) {
+  const p = perforatedSheetModelPropsSchema.parse(input);
+  return perforated(p);
+}
+function createPerforatedSheetMesh(input) {
+  const geom = generalize4(
+    { snap: true, triangulate: true },
+    createPerforatedSheetGeom(input)
+  );
+  const epsilon = Math.max(...measurements3.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 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]);
+      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/perforatedsheet/PerforatedSheet.tsx
+function PerforatedSheet({
+  color = "#929da9",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createPerforatedSheetGeom(props) }) });
+}
+
+// lib/models/perforatedsheet/register.tsx
+var model70 = defineModelRenderer({
+  name: "perforatedsheet",
+  schema: perforatedSheetModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(PerforatedSheet, { ...props }),
+  pads: "none"
+});
+function register70(registry2) {
+  registry2.register(model70);
 }
 
 // lib/models/plainbushing/mesh.ts
@@ -15081,7 +15897,7 @@ function createPlainBushingMesh(input) {
   const ri = d.innerDiameter / 2;
   const ro = d.outerDiameter / 2;
   const c = props.edgeChamfer;
-  const profile = c > 0 ? [
+  const profile6 = c > 0 ? [
     [d.endOuterDiameter / 2, 0],
     [ro, c],
     [ro, d.length - c],
@@ -15099,14 +15915,14 @@ function createPlainBushingMesh(input) {
   const segments = 96;
   const positions = [];
   const indices = [];
-  for (const [radius, z] of profile)
+  for (const [radius, z] of profile6)
     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 < profile.length; ring++) {
+  for (let ring = 0; ring < profile6.length; ring++) {
     const a = ring * segments;
-    const b = (ring + 1) % profile.length * segments;
+    const b = (ring + 1) % profile6.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);
@@ -15127,14 +15943,242 @@ function PlainBushing({
 }
 
 // lib/models/plainbushing/register.tsx
-var model62 = defineModelRenderer({
+var model71 = defineModelRenderer({
   name: "plainbushing",
   schema: plainBushingModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(PlainBushing, { ...props }),
   pads: "none"
 });
-function register62(registry2) {
-  registry2.register(model62);
+function register71(registry2) {
+  registry2.register(model71);
+}
+
+// lib/models/pushfitplug/geometry.ts
+import jscad9 from "@jscad/modeling";
+var { primitives: primitives4, extrusions: extrusions4, geometries: geometries4, modifiers: modifiers4, measurements: measurements4 } = jscad9;
+var generalize5 = modifiers4.generalize;
+var { rectangle: rectangle4, roundedRectangle: roundedRectangle4, polygon: polygon3 } = primitives4;
+function createPushFitPlugGeom(input) {
+  const p = pushFitPlugModelPropsSchema.parse(input);
+  return extrusions4.extrudeRotate(
+    { segments: 64 },
+    polygon3({
+      points: [
+        [0, 0],
+        [p.tubeDiameter / 2, 0],
+        [p.tubeDiameter / 2, p.length - p.headThickness],
+        [p.headDiameter / 2, p.length - p.headThickness],
+        [p.headDiameter / 2, p.length],
+        [0, p.length]
+      ]
+    })
+  );
+}
+function createPushFitPlugMesh(input) {
+  const geom = generalize5(
+    { snap: true, triangulate: true },
+    createPushFitPlugGeom(input)
+  );
+  const epsilon = Math.max(...measurements4.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 geometries4.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/pushfitplug/PushFitPlug.tsx
+function PushFitPlug({ color = "#929da9", ...props }) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createPushFitPlugGeom(props) }) });
+}
+
+// lib/models/pushfitplug/register.tsx
+var model72 = defineModelRenderer({
+  name: "pushfitplug",
+  schema: pushFitPlugModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(PushFitPlug, { ...props }),
+  pads: "none"
+});
+function register72(registry2) {
+  registry2.register(model72);
+}
+
+// lib/models/rectangularbar/geometry.ts
+import jscad10 from "@jscad/modeling";
+var { primitives: primitives5, extrusions: extrusions5, geometries: geometries5, modifiers: modifiers5, measurements: measurements5 } = jscad10;
+var generalize6 = modifiers5.generalize;
+var { rectangle: rectangle5, roundedRectangle: roundedRectangle5 } = primitives5;
+var profile4 = (shape39, height10) => extrusions5.extrudeLinear({ height: height10 }, shape39);
+var roundedRect = (width10, height10, radius) => radius ? roundedRectangle5({
+  size: [width10, height10],
+  roundRadius: radius,
+  segments: 64
+}) : rectangle5({ size: [width10, height10] });
+function createRectangularBarGeom(input) {
+  const p = rectangularBarModelPropsSchema.parse(input);
+  return profile4(roundedRect(p.width, p.height, p.cornerRadius), p.length);
+}
+function createRectangularBarMesh(input) {
+  const geom = generalize6(
+    { snap: true, triangulate: true },
+    createRectangularBarGeom(input)
+  );
+  const epsilon = Math.max(...measurements5.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 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]);
+      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/rectangularbar/RectangularBar.tsx
+function RectangularBar({
+  color = "#929da9",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createRectangularBarGeom(props) }) });
+}
+
+// lib/models/rectangularbar/register.tsx
+var model73 = defineModelRenderer({
+  name: "rectangularbar",
+  schema: rectangularBarModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(RectangularBar, { ...props }),
+  pads: "none"
+});
+function register73(registry2) {
+  registry2.register(model73);
+}
+
+// lib/models/rectangulartube/geometry.ts
+import jscad11 from "@jscad/modeling";
+var {
+  booleans: booleans2,
+  primitives: primitives6,
+  extrusions: extrusions6,
+  geometries: geometries6,
+  modifiers: modifiers6,
+  measurements: measurements6
+} = jscad11;
+var generalize7 = modifiers6.generalize;
+var { subtract: subtract2 } = booleans2;
+var { rectangle: rectangle6, roundedRectangle: roundedRectangle6 } = primitives6;
+var profile5 = (shape39, height10) => extrusions6.extrudeLinear({ height: height10 }, shape39);
+var roundedRect2 = (width10, height10, radius) => radius ? roundedRectangle6({
+  size: [width10, height10],
+  roundRadius: radius,
+  segments: 64
+}) : rectangle6({ size: [width10, height10] });
+function createRectangularTubeGeom(input) {
+  const p = rectangularTubeModelPropsSchema.parse(input);
+  return profile5(
+    subtract2(
+      roundedRect2(p.width, p.height, p.outerRadius),
+      roundedRect2(
+        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(...measurements6.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 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]);
+      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
+function RectangularTube({
+  color = "#929da9",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createRectangularTubeGeom(props) }) });
+}
+
+// lib/models/rectangulartube/register.tsx
+var model74 = defineModelRenderer({
+  name: "rectangulartube",
+  schema: rectangularTubeModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(RectangularTube, { ...props }),
+  pads: "none"
+});
+function register74(registry2) {
+  registry2.register(model74);
 }
 
 // lib/models/rigidcoupler/mesh.ts
@@ -15171,14 +16215,14 @@ function RigidCoupler({
 }
 
 // lib/models/rigidcoupler/register.tsx
-var model63 = defineModelRenderer({
+var model75 = defineModelRenderer({
   name: "rigidcoupler",
   schema: rigidCouplerModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(RigidCoupler, { ...props }),
   pads: "none"
 });
-function register63(registry2) {
-  registry2.register(model63);
+function register75(registry2) {
+  registry2.register(model75);
 }
 
 // lib/models/setscrew/mesh.ts
@@ -15293,14 +16337,14 @@ function SetScrew({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/setscrew/register.tsx
-var model64 = defineModelRenderer({
+var model76 = defineModelRenderer({
   name: "setscrew",
   schema: setscrewModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SetScrew, { ...props }),
   pads: "none"
 });
-function register64(registry2) {
-  registry2.register(model64);
+function register76(registry2) {
+  registry2.register(model76);
 }
 
 // lib/models/shaftcollar/mesh.ts
@@ -15332,14 +16376,14 @@ function ShaftCollar({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/shaftcollar/register.tsx
-var model65 = defineModelRenderer({
+var model77 = defineModelRenderer({
   name: "shaftcollar",
   schema: shaftCollarModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(ShaftCollar, { ...props }),
   pads: "none"
 });
-function register65(registry2) {
-  registry2.register(model65);
+function register77(registry2) {
+  registry2.register(model77);
 }
 
 // lib/mechanical/sheet-metal-mesh.ts
@@ -15365,7 +16409,7 @@ function holeOutline(hole) {
 }
 function createSheetMetalMesh(input) {
   const props = sheetMetalModelPropsSchema.parse(input);
-  const { width: width10, baseLength, flangeHeight, thickness, profile } = props;
+  const { width: width10, baseLength, flangeHeight, thickness, profile: profile6 } = props;
   const radius = props.insideBendRadius + thickness / 2;
   const positions = [];
   const indices = [];
@@ -15378,13 +16422,13 @@ function createSheetMetalMesh(input) {
     addTriangle([vertices[0], vertices[1], vertices[2]], reverse);
     addTriangle([vertices[0], vertices[2], vertices[3]], reverse);
   };
-  const panels = profile === "plate" ? ["base"] : profile === "angle" ? ["base", "right"] : ["base", "left", "right"];
+  const panels = profile6 === "plate" ? ["base"] : profile6 === "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 ${profile}`);
+      throw new Error(`No ${hole.panel} panel on ${profile6}`);
   }
   for (const panel of panels) {
-    const length20 = panel === "base" ? baseLength : flangeHeight;
+    const length26 = panel === "base" ? baseLength : flangeHeight;
     const holes = props.holes.filter((hole) => hole.panel === panel).map(holeOutline);
     const bounds = holes.map((outline2) => ({
       minU: Math.min(...outline2.map((p) => p.u)),
@@ -15393,17 +16437,17 @@ function createSheetMetalMesh(input) {
       maxV: Math.max(...outline2.map((p) => p.v))
     }));
     for (const [i, box] of bounds.entries()) {
-      if (box.minU <= -length20 / 2 || box.maxU >= length20 / 2 || box.minV <= -width10 / 2 || box.maxV >= width10 / 2)
+      if (box.minU <= -length26 / 2 || box.maxU >= length26 / 2 || box.minV <= -width10 / 2 || box.maxV >= width10 / 2)
         throw new Error(`Hole crosses ${panel} panel edge or bend tangent`);
       for (const previous of bounds.slice(0, i))
         if (box.minU <= previous.maxU && box.maxU >= previous.minU && box.minV <= previous.maxV && box.maxV >= previous.minV)
           throw new Error("Hole bounding boxes must not overlap");
     }
     const outline = [
-      { u: -length20 / 2, v: -width10 / 2 },
-      { u: length20 / 2, v: -width10 / 2 },
-      { u: length20 / 2, v: width10 / 2 },
-      { u: -length20 / 2, v: width10 / 2 }
+      { u: -length26 / 2, v: -width10 / 2 },
+      { u: length26 / 2, v: -width10 / 2 },
+      { u: length26 / 2, v: width10 / 2 },
+      { u: -length26 / 2, v: width10 / 2 }
     ];
     const loops = [outline, ...holes.map((hole) => [...hole].reverse())];
     const points = loops.flat();
@@ -15432,7 +16476,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 && profile !== "plate" || a.u < 0 && profile === "channel") || panel !== "base" && a.u < 0))
+        if (loopIndex === 0 && a.u === b.u && (panel === "base" && (a.u > 0 && profile6 !== "plate" || a.u < 0 && profile6 === "channel") || panel !== "base" && a.u < 0))
           continue;
         addQuad(
           [
@@ -15445,7 +16489,7 @@ function createSheetMetalMesh(input) {
         );
       }
   }
-  const sides = profile === "plate" ? [] : profile === "angle" ? [1] : [-1, 1];
+  const sides = profile6 === "plate" ? [] : profile6 === "angle" ? [1] : [-1, 1];
   for (const side of sides) {
     const project = (angle, crossSection) => {
       const r = radius - crossSection.offset;
@@ -15493,14 +16537,14 @@ function SheetMetal({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/sheetmetal/register.tsx
-var model66 = defineModelRenderer({
+var model78 = defineModelRenderer({
   name: "sheetmetal",
   schema: sheetMetalModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SheetMetal, { ...props }),
   pads: "none"
 });
-function register66(registry2) {
-  registry2.register(model66);
+function register78(registry2) {
+  registry2.register(model78);
 }
 
 // lib/models/spacer/mesh.ts
@@ -15523,14 +16567,14 @@ function Spacer({ color = "#a18450", ...props }) {
 }
 
 // lib/models/spacer/register.tsx
-var model67 = defineModelRenderer({
+var model79 = defineModelRenderer({
   name: "spacer",
   schema: spacerModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(Spacer, { ...props }),
   pads: "none"
 });
-function register67(registry2) {
-  registry2.register(model67);
+function register79(registry2) {
+  registry2.register(model79);
 }
 
 // lib/models/splitwasher/mesh.ts
@@ -15593,14 +16637,14 @@ function SplitWasher({ color = "#929ba6", ...props }) {
 }
 
 // lib/models/splitwasher/register.tsx
-var model68 = defineModelRenderer({
+var model80 = defineModelRenderer({
   name: "splitwasher",
   schema: splitWasherModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SplitWasher, { ...props }),
   pads: "none"
 });
-function register68(registry2) {
-  registry2.register(model68);
+function register80(registry2) {
+  registry2.register(model80);
 }
 
 // lib/SpurGear.tsx
@@ -15612,14 +16656,14 @@ function SpurGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/spurgear/register.tsx
-var model69 = defineModelRenderer({
+var model81 = defineModelRenderer({
   name: "spurgear",
   schema: spurGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SpurGear, { ...props }),
   pads: "none"
 });
-function register69(registry2) {
-  registry2.register(model69);
+function register81(registry2) {
+  registry2.register(model81);
 }
 
 // lib/models/threadedrod/mesh.ts
@@ -15709,14 +16753,14 @@ function ThreadedRod({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/threadedrod/register.tsx
-var model70 = defineModelRenderer({
+var model82 = defineModelRenderer({
   name: "threadedrod",
   schema: threadedRodModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(ThreadedRod, { ...props }),
   pads: "none"
 });
-function register70(registry2) {
-  registry2.register(model70);
+function register82(registry2) {
+  registry2.register(model82);
 }
 
 // lib/models/torsionspring/mesh.ts
@@ -15805,20 +16849,20 @@ function TorsionSpring({
 }
 
 // lib/models/torsionspring/register.tsx
-var model71 = defineModelRenderer({
+var model83 = defineModelRenderer({
   name: "torsionspring",
   schema: torsionSpringModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(TorsionSpring, { ...props }),
   pads: "none"
 });
-function register71(registry2) {
-  registry2.register(model71);
+function register83(registry2) {
+  registry2.register(model83);
 }
 
 // lib/models/tslotextrusion/mesh.ts
 function createTSlotExtrusionMesh(input = {}) {
   const props = tSlotExtrusionModelPropsSchema.parse(input);
-  const { width: width10, height: height10, length: length20, cornerRadius, lipThickness, pocketDepth } = props;
+  const { width: width10, height: height10, length: length26, cornerRadius, lipThickness, pocketDepth } = props;
   const slot = props.slotWidth / 2;
   const pocket = props.pocketWidth / 2;
   const depth = lipThickness + pocketDepth;
@@ -15855,7 +16899,7 @@ function createTSlotExtrusionMesh(input = {}) {
     outer,
     holes: props.boreDiameter > 0 ? [circularProfile(0, 0, props.boreDiameter / 2)] : [],
     start: 0,
-    end: length20
+    end: length26
   });
 }
 
@@ -15871,14 +16915,14 @@ function TSlotExtrusion({
 }
 
 // lib/models/tslotextrusion/register.tsx
-var model72 = defineModelRenderer({
+var model84 = defineModelRenderer({
   name: "tslotextrusion",
   schema: tSlotExtrusionModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(TSlotExtrusion, { ...props }),
   pads: "none"
 });
-function register72(registry2) {
-  registry2.register(model72);
+function register84(registry2) {
+  registry2.register(model84);
 }
 
 // lib/models/tslotgusset/mesh.ts
@@ -15924,14 +16968,14 @@ function TSlotGusset({ color = "#8995a3", ...props }) {
 }
 
 // lib/models/tslotgusset/register.tsx
-var model73 = defineModelRenderer({
+var model85 = defineModelRenderer({
   name: "tslotgusset",
   schema: tSlotGussetModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(TSlotGusset, { ...props }),
   pads: "none"
 });
-function register73(registry2) {
-  registry2.register(model73);
+function register85(registry2) {
+  registry2.register(model85);
 }
 
 // lib/models/tslotinsidecorner/mesh.ts
@@ -16005,14 +17049,14 @@ function TSlotInsideCorner({
 }
 
 // lib/models/tslotinsidecorner/register.tsx
-var model74 = defineModelRenderer({
+var model86 = defineModelRenderer({
   name: "tslotinsidecorner",
   schema: tSlotInsideCornerModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(TSlotInsideCorner, { ...props }),
   pads: "none"
 });
-function register74(registry2) {
-  registry2.register(model74);
+function register86(registry2) {
+  registry2.register(model86);
 }
 
 // lib/mechanical/worm-gear-mesh.ts
@@ -16066,17 +17110,17 @@ var createWormGearMesh = (input) => {
         fractions.push(fraction);
     }
   }
-  const profile = [];
+  const profile6 = [];
   for (let start = 0; start < props.starts; start++) {
     for (const fraction of fractions) {
       const distance2 = Math.min(fraction, 1 - fraction) * axialPitch;
-      profile.push({
+      profile6.push({
         angle: (start + fraction) * Math.PI * 2 / props.starts,
         radius: distance2 <= tipHalfWidth ? outsideRadius : distance2 >= rootHalfWidth ? rootRadius : pitchRadius + (toothThickness / 2 - distance2) / pressureTangent
       });
     }
   }
-  const count = profile.length;
+  const count = profile6.length;
   const positions = [];
   const indices = [];
   const phase = props.phase % 360 * Math.PI / 180;
@@ -16084,7 +17128,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 profile) {
+    for (const sample of profile6) {
       const angle = sample.angle + rotation;
       positions.push(
         sample.radius * Math.cos(angle),
@@ -16197,24 +17241,18 @@ function WormGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/wormgear/register.tsx
-var model75 = defineModelRenderer({
+var model87 = defineModelRenderer({
   name: "wormgear",
   schema: wormGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(WormGear, { ...props }),
   pads: "none"
 });
-function register75(registry2) {
-  registry2.register(model75);
+function register87(registry2) {
+  registry2.register(model87);
 }
 
 // lib/generated/model-renderers.ts
 function registerAllModelRenderers(registry2) {
-  register39(registry2);
-  register40(registry2);
-  register41(registry2);
-  register42(registry2);
-  register43(registry2);
-  register44(registry2);
   register45(registry2);
   register46(registry2);
   register47(registry2);
@@ -16246,6 +17284,18 @@ function registerAllModelRenderers(registry2) {
   register73(registry2);
   register74(registry2);
   register75(registry2);
+  register76(registry2);
+  register77(registry2);
+  register78(registry2);
+  register79(registry2);
+  register80(registry2);
+  register81(registry2);
+  register82(registry2);
+  register83(registry2);
+  register84(registry2);
+  register85(registry2);
+  register86(registry2);
+  register87(registry2);
 }
 
 // lib/default-model-registry.ts
@@ -16587,7 +17637,7 @@ import { fp as fp10 } from "@tscircuit/footprinter";
 var ChipBody = ({
   center,
   width: width10,
-  length: length20,
+  length: length26,
   height: height10,
   heightAboveSurface: heightAboveSurface2 = 0.15,
   color = "#555",
@@ -16604,24 +17654,24 @@ var ChipBody = ({
 }) => {
   const straightHeight = height10 * straightHeightRatio;
   const taperHeight = height10 - straightHeight;
-  const taperInset = Math.min(width10, length20) * taperRatio;
+  const taperInset = Math.min(width10, length26) * taperRatio;
   const faceWidth = Math.max(width10 - taperInset, width10 * faceRatio);
-  const faceLength = Math.max(length20 - taperInset, length20 * faceRatio);
-  const defaultNotchRadius = Math.min(width10, length20) * 0.12;
+  const faceLength = Math.max(length26 - taperInset, length26 * faceRatio);
+  const defaultNotchRadius = Math.min(width10, length26) * 0.12;
   const actualNotchRadius = notchRadius ?? defaultNotchRadius;
   const defaultNotchPosition = {
     x: 0,
-    y: length20 / 2 - actualNotchRadius * 0.25,
+    y: length26 / 2 - actualNotchRadius * 0.25,
     z: height10
   };
   const actualNotchPosition = notchPosition ?? defaultNotchPosition;
   const body = /* @__PURE__ */ jsxs(Union, { children: [
     /* @__PURE__ */ jsxs(Hull, { children: [
       /* @__PURE__ */ jsx(Translate, { z: 5e-3, children: /* @__PURE__ */ jsx(Cuboid, { size: [faceWidth, faceLength, 0.01] }) }),
-      /* @__PURE__ */ jsx(Translate, { z: straightHeight, children: /* @__PURE__ */ jsx(Cuboid, { size: [width10, length20, 0.01] }) })
+      /* @__PURE__ */ jsx(Translate, { z: straightHeight, children: /* @__PURE__ */ jsx(Cuboid, { size: [width10, length26, 0.01] }) })
     ] }),
     /* @__PURE__ */ jsxs(Hull, { children: [
-      /* @__PURE__ */ jsx(Translate, { z: straightHeight, children: /* @__PURE__ */ jsx(Cuboid, { size: [width10, length20, 0.01] }) }),
+      /* @__PURE__ */ jsx(Translate, { z: straightHeight, children: /* @__PURE__ */ jsx(Cuboid, { size: [width10, length26, 0.01] }) }),
       /* @__PURE__ */ jsx(Translate, { z: straightHeight + taperHeight, children: /* @__PURE__ */ jsx(Cuboid, { size: [faceWidth, faceLength, 0.01] }) })
     ] })
   ] });
@@ -16638,7 +17688,7 @@ var ChipBody = ({
   let finalBody = body;
   if (chamferSize > 0) {
     const xOffset = width10 / 2;
-    const yOffset = length20 / 2;
+    const yOffset = length26 / 2;
     finalBody = /* @__PURE__ */ jsxs(Subtract, { children: [
       body,
       chamferCutout(xOffset, yOffset),
@@ -16668,8 +17718,8 @@ function getExpandedStroke(strokeInput, width10) {
   function getNormal(p1, p2) {
     const dx = p2.x - p1.x;
     const dy = p2.y - p1.y;
-    const length20 = Math.sqrt(dx * dx + dy * dy);
-    return { x: -dy / length20, y: dx / length20 };
+    const length26 = Math.sqrt(dx * dx + dy * dy);
+    return { x: -dy / length26, y: dx / length26 };
   }
   function addPoint(point, normal, factor) {
     const newPoint = {
@@ -16844,8 +17894,8 @@ var SmdChipLead = (props) => {
   const { thickness, width: width10, padContactLength, bodyDistance, height: height10, rotation } = props;
   const N = 15;
   const points = Array.from({ length: N }).map((_, i) => i / (N - 1) * bodyDistance).map((x) => [x, calculateSCurve(x, props)]);
-  const polygon = getExpandedStroke(points, thickness);
-  return /* @__PURE__ */ jsx(Colorize, { color: "#c4c7ca", material: componentMaterials.tinnedLead, children: /* @__PURE__ */ jsx(Translate, { offset: { z: 0, y: 0, x: 0, ...props.position }, children: /* @__PURE__ */ jsx(Rotate, { rotation: ["90deg", 0, rotation ?? 0], children: /* @__PURE__ */ jsx(Translate, { offset: { x: 0, y: 0, z: -width10 / 2 }, children: /* @__PURE__ */ jsx(ExtrudeLinear, { height: width10, children: /* @__PURE__ */ jsx(Polygon, { points: polygon.map((p) => [p.x, p.y]) }) }) }) }) }) });
+  const polygon4 = getExpandedStroke(points, thickness);
+  return /* @__PURE__ */ jsx(Colorize, { color: "#c4c7ca", material: componentMaterials.tinnedLead, children: /* @__PURE__ */ jsx(Translate, { offset: { z: 0, y: 0, x: 0, ...props.position }, children: /* @__PURE__ */ jsx(Rotate, { rotation: ["90deg", 0, rotation ?? 0], children: /* @__PURE__ */ jsx(Translate, { offset: { x: 0, y: 0, z: -width10 / 2 }, children: /* @__PURE__ */ jsx(ExtrudeLinear, { height: width10, children: /* @__PURE__ */ jsx(Polygon, { points: polygon4.map((p) => [p.x, p.y]) }) }) }) }) }) });
 };
 
 // lib/Tssop.tsx
@@ -18337,11 +19387,11 @@ var FemaleHeaderRow = ({
 // lib/PushButton.tsx
 var PushButton = ({
   width: width10,
-  length: length20,
+  length: length26,
   innerDiameter = 1
 }) => {
   const bodyWidth = width10;
-  const bodyLength10 = length20;
+  const bodyLength10 = length26;
   const bodyHeight = width10 * 0.7;
   const legWidth = innerDiameter / 2.5;
   return /* @__PURE__ */ jsxs(Fragment2, { children: [
@@ -18495,7 +19545,7 @@ var PushButtonLeg = (props) => {
     [-verticalLength / 5, horizontalLength / 4],
     [0, 0]
   ];
-  const polygon = getExpandedStroke(points, thickness);
+  const polygon4 = getExpandedStroke(points, thickness);
   return /* @__PURE__ */ jsx(Colorize, { color: "#f2f2f2", children: /* @__PURE__ */ jsx(
     Translate,
     {
@@ -18504,7 +19554,7 @@ var PushButtonLeg = (props) => {
         y: position?.y || 0,
         z: position?.z || 0
       },
-      children: /* @__PURE__ */ jsx(Rotate, { rotation: [0, 55, rotation], children: /* @__PURE__ */ jsx(ExtrudeLinear, { height: width10, children: /* @__PURE__ */ jsx(Polygon, { points: polygon.map((p) => [p.y, p.x]) }) }) })
+      children: /* @__PURE__ */ jsx(Rotate, { rotation: [0, 55, rotation], children: /* @__PURE__ */ jsx(ExtrudeLinear, { height: width10, children: /* @__PURE__ */ jsx(Polygon, { points: polygon4.map((p) => [p.y, p.x]) }) }) })
     }
   ) });
 };
@@ -22275,12 +23325,12 @@ var JstSh = ({ footprint = "jst6_sh" }) => {
 };
 
 // lib/Crystal.tsx
-var getTerminalPoints = ([centerX, centerY], width10, length20, chamfer, isPinOne) => {
+var getTerminalPoints = ([centerX, centerY], width10, length26, chamfer, isPinOne) => {
   const xDirection = Math.sign(centerX);
   const yDirection = Math.sign(centerY);
   const halfWidth = width10 / 2;
-  const halfLength = length20 / 2;
-  const innerChamfer = isPinOne ? Math.min(0.32, length20 * 0.36) : 0;
+  const halfLength = length26 / 2;
+  const innerChamfer = isPinOne ? Math.min(0.32, length26 * 0.36) : 0;
   const outerChamfer = Math.min(chamfer, halfWidth, halfLength);
   const points = [
     [-halfWidth, -halfLength],
@@ -22300,13 +23350,13 @@ var getTerminalPoints = ([centerX, centerY], width10, length20, chamfer, isPinOn
 };
 var getRoundedRectProfile = ({
   width: width10,
-  length: length20,
+  length: length26,
   radius,
   height: height10,
   z
 }) => {
   const x = width10 / 2 - radius;
-  const y = length20 / 2 - radius;
+  const y = length26 / 2 - radius;
   return [
     [-x, -y],
     [x, -y],
@@ -22450,12 +23500,12 @@ var FPC = ({
   const contactRows = Array.from({ length: pinCount }, (_, index) => {
     const isUpperRow = staggered && index % 2 === 1 !== reverse;
     const y = staggered ? isUpperRow ? rowPitch / 2 : -rowPitch / 2 : 0;
-    const length20 = isUpperRow ? topPadLength : bottomPadLength;
+    const length26 = isUpperRow ? topPadLength : bottomPadLength;
     return {
       index,
       x: contactStartX + index * pitch,
       y,
-      length: length20
+      length: length26
     };
   });
   const contactMaxY = Math.max(
@@ -23007,7 +24057,7 @@ var Led2835 = ({
 };
 
 // lib/RJ45.tsx
-var range2 = (length20) => Array.from({ length: length20 }, (_, index) => index);
+var range2 = (length26) => Array.from({ length: length26 }, (_, index) => index);
 var RJ45 = ({
   bodyWidth = 16.26,
   bodyDepth = 15.88,
@@ -23827,10 +24877,10 @@ var SOT143 = ({ footprint = "sot143" }) => {
 var Footprinter3d = ({ footprint }) => {
   const modelFn = mp.string(footprint.split("_", 1)[0]).params().fn;
   if (mp.getModelNames().includes(modelFn)) {
-    const model76 = mp.string(footprint).json();
-    const renderer = modelRendererRegistry.get(model76.fn);
+    const model88 = mp.string(footprint).json();
+    const renderer = modelRendererRegistry.get(model88.fn);
     if (renderer) {
-      return renderer.render(model76);
+      return renderer.render(model88);
     }
   }
   let normalizedFootprint = footprint;
@@ -24514,7 +25564,7 @@ var toVec3 = (v) => {
 };
 function renderNode(node, colorCtx, renderCtx) {
   const {
-    jscad: { primitives, booleans, hulls, geometries, extrusions, transforms }
+    jscad: { primitives: primitives7, booleans: booleans3, hulls, geometries: geometries7, extrusions: extrusions7, transforms }
   } = renderCtx;
   if (node == null || node === false) return [];
   if (Array.isArray(node))
@@ -24579,9 +25629,9 @@ function renderNode(node, colorCtx, renderCtx) {
     const geoms = entries.map((g) => g.geom);
     if (geoms.length === 0) return [];
     let geom;
-    if (type === Union) geom = booleans.union(geoms);
+    if (type === Union) geom = booleans3.union(geoms);
     else if (type === Subtract)
-      geom = booleans.subtract(geoms[0], geoms.slice(1));
+      geom = booleans3.subtract(geoms[0], geoms.slice(1));
     else geom = hulls.hull(geoms);
     return [
       {
@@ -24596,7 +25646,7 @@ function renderNode(node, colorCtx, renderCtx) {
   }
   if (type === Polygon) {
     const points = props?.points ?? [];
-    const g2 = geometries.geom2.fromPoints(points);
+    const g2 = geometries7.geom2.fromPoints(points);
     return [{ geom: g2, color: colorCtx ?? props?.color }];
   }
   if (type === ExtrudeLinear) {
@@ -24605,9 +25655,9 @@ function renderNode(node, colorCtx, renderCtx) {
     );
     const geoms2 = entries.map((g) => g.geom);
     if (geoms2.length === 0) return [];
-    const base2 = geoms2.length > 1 ? booleans.union(geoms2) : geoms2[0];
+    const base2 = geoms2.length > 1 ? booleans3.union(geoms2) : geoms2[0];
     const height10 = props?.height ?? props?.h ?? 1;
-    let g3 = extrusions.extrudeLinear({ height: height10 }, base2);
+    let g3 = extrusions7.extrudeLinear({ height: height10 }, base2);
     if (g3.polygons) {
       for (const poly of g3.polygons) {
         if (!poly.plane || !poly.vertices || poly.vertices.length < 3) continue;
@@ -24628,32 +25678,32 @@ function renderNode(node, colorCtx, renderCtx) {
       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 = primitives.cuboid({ size, center });
+      g = primitives7.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 = primitives.cube({ size, center });
+      g = primitives7.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 = primitives.cylinder({ height: height10, radius, center });
+      g = primitives7.cylinder({ height: height10, radius, center });
     } else if (type === Sphere) {
       const radius = props?.radius ?? 1;
       const center = props?.center ?? [0, 0, 0];
-      g = primitives.sphere({ radius, center });
+      g = primitives7.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 = primitives.roundedCylinder({ height: height10, radius, roundRadius, center });
+      g = primitives7.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 = primitives.roundedCuboid({ size, roundRadius, center });
+      g = primitives7.roundedCuboid({ size, roundRadius, center });
     }
     return [{ geom: g, color: colorCtx ?? props?.color }];
   }
@@ -24663,10 +25713,10 @@ function renderNode(node, colorCtx, renderCtx) {
   }
   return (children ?? []).flatMap((c) => renderNode(c, colorCtx, renderCtx));
 }
-function render(root, jscad8) {
-  const geometries = renderNode(root, void 0, { jscad: jscad8 });
+function render(root, jscad14) {
+  const geometries7 = renderNode(root, void 0, { jscad: jscad14 });
   return {
-    geometries: geometries.map(
+    geometries: geometries7.map(
       (entry) => entry.material ? { ...entry, geom: { ...entry.geom, material: entry.material } } : entry
     )
   };
@@ -24684,8 +25734,8 @@ function convertCSGToThreeGeom(csg) {
     const indices = [];
     const colors = [];
     let idx = 0;
-    for (const polygon of csg.polygons) {
-      for (const vertex of polygon.vertices) {
+    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) {
@@ -24695,10 +25745,10 @@ function convertCSGToThreeGeom(csg) {
         }
         idx++;
       }
-      const first = polygon.vertices[0].index;
-      for (let i = 2; i < polygon.vertices.length; i++) {
-        const second = polygon.vertices[i - 1].index;
-        const third = polygon.vertices[i].index;
+      const first = polygon4.vertices[0].index;
+      for (let i = 2; i < polygon4.vertices.length; i++) {
+        const second = polygon4.vertices[i - 1].index;
+        const third = polygon4.vertices[i].index;
         indices.push(first, second, third);
       }
     }
@@ -24756,35 +25806,37 @@ function convertCSGToThreeGeom(csg) {
 }
 
 // lib/vanilla/index.ts
-function getJscadModelForFootprint(footprint, jscad8) {
+function getJscadModelForFootprint(footprint, jscad14) {
   const vnode = h(Footprinter3d, { footprint });
-  return render(vnode, jscad8);
+  return render(vnode, jscad14);
 }
-function getJscadModelForFootprintWithPads(footprint, jscad8) {
+function getJscadModelForFootprintWithPads(footprint, jscad14) {
   const vnode = h(
     Fragment,
     {},
     h(Footprinter3d, { footprint }),
     h(ExtrudedPads, { footprint })
   );
-  return render(vnode, jscad8);
+  return render(vnode, jscad14);
 }
-function createJSCADRenderer(jscad8) {
+function createJSCADRenderer(jscad14) {
   function createJSCADRoot(container) {
     return {
       render(element) {
-        const { geometries } = render(element, jscad8);
-        container.splice(0, container.length, ...geometries);
+        const { geometries: geometries7 } = render(element, jscad14);
+        container.splice(0, container.length, ...geometries7);
       }
     };
   }
   return { createJSCADRoot };
 }
 export {
+  AngleBar,
   BallBearing,
   BallTransferUnit,
   ButtonScrew,
   CableGrommet,
+  ChannelBar,
   ClampingShaftCollar,
   CompressionSpring,
   DowelPin,
@@ -24807,7 +25859,11 @@ export {
   NemaMotor,
   NylonLockNut,
   PanScrew,
+  PerforatedSheet,
   PlainBushing,
+  PushFitPlug,
+  RectangularBar,
+  RectangularTube,
   RigidCoupler,
   SetScrew,
   ShaftCollar,
@@ -24822,6 +25878,8 @@ export {
   TorsionSpring,
   WormGear,
   convertCSGToThreeGeom,
+  createAngleBarGeom,
+  createAngleBarMesh,
   createBallBearingGeom,
   createBallBearingMesh,
   createBallTransferUnitGeom,
@@ -24830,6 +25888,8 @@ export {
   createButtonScrewMesh,
   createCableGrommetGeom,
   createCableGrommetMesh,
+  createChannelBarGeom,
+  createChannelBarMesh,
   createClampingShaftCollarGeom,
   createClampingShaftCollarMesh,
   createCompressionSpringGeom,
@@ -24867,8 +25927,16 @@ export {
   createNylonLockNutMeshes,
   createPanScrewGeom,
   createPanScrewMesh,
+  createPerforatedSheetGeom,
+  createPerforatedSheetMesh,
   createPlainBushingGeom,
   createPlainBushingMesh,
+  createPushFitPlugGeom,
+  createPushFitPlugMesh,
+  createRectangularBarGeom,
+  createRectangularBarMesh,
+  createRectangularTubeGeom,
+  createRectangularTubeMesh,
   createRigidCouplerGeom,
   createRigidCouplerMesh,
   createSetScrewGeom,