jscad-electronics 0.0.228 → 0.0.233

package/dist/vanilla.js

@@ -24,7 +24,7 @@ function h(type, props, ...restChildren) {
   };
 }
 
-// .model-contracts/generations/a2cdaa0ea42c20364c601d990971fef4f4e234fc-v2/node_modules/zod/v3/external.js
+// .model-contracts/generations/324045ff5a8d957b84ad80e3a428461bb10e4259-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/a2cdaa0ea42c20364c601d990971fef4f4e234fc-v2/node_modules/zod/v3/helpers/util.js
+// .model-contracts/generations/324045ff5a8d957b84ad80e3a428461bb10e4259-v2/node_modules/zod/v3/helpers/util.js
 var util;
 (function(util2) {
   util2.assertEqual = (_) => {
@@ -270,7 +270,7 @@ var getParsedType = (data) => {
   }
 };
 
-// .model-contracts/generations/a2cdaa0ea42c20364c601d990971fef4f4e234fc-v2/node_modules/zod/v3/ZodError.js
+// .model-contracts/generations/324045ff5a8d957b84ad80e3a428461bb10e4259-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/a2cdaa0ea42c20364c601d990971fef4f4e234fc-v2/node_modules/zod/v3/locales/en.js
+// .model-contracts/generations/324045ff5a8d957b84ad80e3a428461bb10e4259-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/a2cdaa0ea42c20364c601d990971fef4f4e234fc-v2/node_modules/zod/v3/errors.js
+// .model-contracts/generations/324045ff5a8d957b84ad80e3a428461bb10e4259-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/a2cdaa0ea42c20364c601d990971fef4f4e234fc-v2/node_modules/zod/v3/helpers/parseUtil.js
+// .model-contracts/generations/324045ff5a8d957b84ad80e3a428461bb10e4259-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/a2cdaa0ea42c20364c601d990971fef4f4e234fc-v2/node_modules/zod/v3/helpers/errorUtil.js
+// .model-contracts/generations/324045ff5a8d957b84ad80e3a428461bb10e4259-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/a2cdaa0ea42c20364c601d990971fef4f4e234fc-v2/node_modules/zod/v3/types.js
+// .model-contracts/generations/324045ff5a8d957b84ad80e3a428461bb10e4259-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 shape39 = this._def.shape();
-    const keys = util.objectKeys(shape39);
-    this._cached = { shape: shape39, keys };
+    const shape44 = this._def.shape();
+    const keys = util.objectKeys(shape44);
+    this._cached = { shape: shape44, 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: shape39, keys: shapeKeys } = this._getCached();
+    const { shape: shape44, 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 = shape39[key];
+      const keyValidator = shape44[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 shape39 = {};
+    const shape44 = {};
     for (const key of util.objectKeys(mask)) {
       if (mask[key] && this.shape[key]) {
-        shape39[key] = this.shape[key];
+        shape44[key] = this.shape[key];
       }
     }
     return new _ZodObject({
       ...this._def,
-      shape: () => shape39
+      shape: () => shape44
     });
   }
   omit(mask) {
-    const shape39 = {};
+    const shape44 = {};
     for (const key of util.objectKeys(this.shape)) {
       if (!mask[key]) {
-        shape39[key] = this.shape[key];
+        shape44[key] = this.shape[key];
       }
     }
     return new _ZodObject({
       ...this._def,
-      shape: () => shape39
+      shape: () => shape44
     });
   }
   /**
@@ -2703,27 +2703,27 @@ var ZodObject = class _ZodObject extends ZodType {
     return createZodEnum(util.objectKeys(this.shape));
   }
 };
-ZodObject.create = (shape39, params) => {
+ZodObject.create = (shape44, params) => {
   return new ZodObject({
-    shape: () => shape39,
+    shape: () => shape44,
     unknownKeys: "strip",
     catchall: ZodNever.create(),
     typeName: ZodFirstPartyTypeKind.ZodObject,
     ...processCreateParams(params)
   });
 };
-ZodObject.strictCreate = (shape39, params) => {
+ZodObject.strictCreate = (shape44, params) => {
   return new ZodObject({
-    shape: () => shape39,
+    shape: () => shape44,
     unknownKeys: "strict",
     catchall: ZodNever.create(),
     typeName: ZodFirstPartyTypeKind.ZodObject,
     ...processCreateParams(params)
   });
 };
-ZodObject.lazycreate = (shape39, params) => {
+ZodObject.lazycreate = (shape44, params) => {
   return new ZodObject({
-    shape: shape39,
+    shape: shape44,
     unknownKeys: "strip",
     catchall: ZodNever.create(),
     typeName: ZodFirstPartyTypeKind.ZodObject,
@@ -4065,7 +4065,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// .model-contracts/generations/a2cdaa0ea42c20364c601d990971fef4f4e234fc-v2/node_modules/@tscircuit/mm/dist/index.js
+// .model-contracts/generations/324045ff5a8d957b84ad80e3a428461bb10e4259-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/a2cdaa0ea42c20364c601d990971fef4f4e234fc-v2/index.js
+// .model-contracts/generations/324045ff5a8d957b84ad80e3a428461bb10e4259-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");
@@ -4148,21 +4148,21 @@ var parseModelStringParams = (definition) => {
   params.string = normalizedDefinition;
   return params;
 };
-function expandModelStringFlags(value, flags6) {
+function expandModelStringFlags(value, flags9) {
   return splitModelStringTokens(value).map(
-    (token, index) => index > 0 && Object.hasOwn(flags6, token.toLowerCase()) ? flags6[token.toLowerCase()] : token
+    (token, index) => index > 0 && Object.hasOwn(flags9, token.toLowerCase()) ? flags9[token.toLowerCase()] : token
   ).join("_");
 }
-function normalizeModelStringFlags(value, flags6, parse, omittedFlags) {
+function normalizeModelStringFlags(value, flags9, parse, omittedFlags) {
   const tokens = splitModelStringTokens(value);
-  if (!tokens.slice(1).some((token) => Object.hasOwn(flags6, token.toLowerCase())))
+  if (!tokens.slice(1).some((token) => Object.hasOwn(flags9, token.toLowerCase())))
     return value;
-  const expanded = expandModelStringFlags(value, flags6);
+  const expanded = expandModelStringFlags(value, flags9);
   parse(parseModelStringParams(expanded));
   const preferred = new Map(
-    Object.entries(flags6).map(([flag, selector]) => [selector, flag])
+    Object.entries(flags9).map(([flag, selector]) => [selector, flag])
   );
-  const omitted = new Set(omittedFlags.map((flag) => flags6[flag]));
+  const omitted = new Set(omittedFlags.map((flag) => flags9[flag]));
   return splitModelStringTokens(expanded).flatMap((token, index) => {
     if (index === 0) return [token.toLowerCase()];
     const lower = token.toLowerCase();
@@ -4178,55 +4178,55 @@ var stringFlags = {
   male: "threadgender(male)"
 };
 var omittedStringFlags = ["righthanded", "male"];
-function defineModel(model452) {
-  return model452;
+function defineModel(model502) {
+  return model502;
 }
 var ModelRegistry = class {
   models = /* @__PURE__ */ new Map();
-  register(model452) {
-    if (typeof model452.name !== "string" || !/^[a-z]+$/.test(model452.name)) {
+  register(model502) {
+    if (typeof model502.name !== "string" || !/^[a-z]+$/.test(model502.name)) {
       throw new Error("Model names must contain only lowercase letters");
     }
-    if (this.models.has(model452.name)) {
+    if (this.models.has(model502.name)) {
       throw new Error(
-        `Modelprinter function "${model452.name}" is already registered`
+        `Modelprinter function "${model502.name}" is already registered`
       );
     }
-    if (model452.normalizeString !== void 0 && typeof model452.normalizeString !== "function")
+    if (model502.normalizeString !== void 0 && typeof model502.normalizeString !== "function")
       throw new Error("Model string normalizer must be a function");
-    this.models.set(model452.name, {
-      name: model452.name,
-      schema: model452.schema,
-      parse: model452.parse,
-      normalizeString: model452.normalizeString
+    this.models.set(model502.name, {
+      name: model502.name,
+      schema: model502.schema,
+      parse: model502.parse,
+      normalizeString: model502.normalizeString
     });
   }
   getModelNames() {
     return [...this.models.keys()];
   }
   normalize(params) {
-    const model452 = this.models.get(params.fn);
-    if (!model452?.normalizeString) return params;
-    const value = model452.normalizeString(params.string);
+    const model502 = this.models.get(params.fn);
+    if (!model502?.normalizeString) return params;
+    const value = model502.normalizeString(params.string);
     if (typeof value !== "string")
-      throw new Error(`Normalizer for "${model452.name}" must return a string`);
+      throw new Error(`Normalizer for "${model502.name}" must return a string`);
     if (value === params.string) return params;
     const normalized = parseModelStringParams(value);
-    if (normalized.fn !== model452.name)
+    if (normalized.fn !== model502.name)
       throw new Error(
-        `Normalizer for "${model452.name}" must preserve the model name`
+        `Normalizer for "${model502.name}" must preserve the model name`
       );
     return normalized;
   }
   parse(params) {
-    const model452 = this.models.get(params.fn);
-    if (!model452) {
+    const model502 = this.models.get(params.fn);
+    if (!model502) {
       throw new Error(`Unsupported modelprinter function "${params.fn}"`);
     }
-    const definition = model452.parse(params);
-    if (definition === null || typeof definition !== "object" || Array.isArray(definition) || definition.fn !== model452.name) {
+    const definition = model502.parse(params);
+    if (definition === null || typeof definition !== "object" || Array.isArray(definition) || definition.fn !== model502.name) {
       throw new Error(
-        `Parser for "${model452.name}" must return a model with fn "${model452.name}"`
+        `Parser for "${model502.name}" must return a model with fn "${model502.name}"`
       );
     }
     return definition;
@@ -5155,12 +5155,12 @@ function parseSheetMetalFeature(feature, profile6) {
   }
   if (!("l" in values) || !("w" in values))
     throw new Error(`Slot requires l and w in ${feature}`);
-  const length26 = distance2("l"), width10 = distance2("w");
-  if (length26 < width10) throw new Error("Slot length must be at least its width");
+  const length29 = distance2("l"), width10 = distance2("w");
+  if (length29 < width10) throw new Error("Slot length must be at least its width");
   return sheetMetalHoleSchema.parse({
     ...position,
     shape: "slot",
-    length: length26,
+    length: length29,
     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((model452, context) => {
-  validateTailLengths(model452, context);
-  addOrientationShortcutIssue(model452, (path) => {
+}).strict().superRefine((model502, context) => {
+  validateTailLengths(model502, context);
+  addOrientationShortcutIssue(model502, (path) => {
     context.addIssue({
       code: "custom",
       message: "Only one FlexScreen orientation shortcut can be true",
@@ -6475,12 +6475,12 @@ function parseButtonScrewModelParams(raw) {
   if (raw.fn !== "buttonscrew" || tokens[0]?.toLowerCase() !== "buttonscrew")
     throw new Error("Expected buttonscrew without an inline argument");
   const props = { fn: "buttonscrew" };
-  const lengths22 = {
+  const lengths24 = {
     l: "length",
     length: "length",
     threadpitch: "threadPitch"
   };
-  const selectors4 = {
+  const selectors6 = {
     drive: "drive",
     thread: "thread",
     threadhand: "threadHand",
@@ -6502,9 +6502,9 @@ function parseButtonScrewModelParams(raw) {
     if (name === "m") {
       property = "metricSize";
       parsed = `M${value}`;
-    } else if (name in lengths22) property = lengths22[name];
-    else if (name in selectors4) {
-      property = selectors4[name];
+    } else if (name in lengths24) property = lengths24[name];
+    else if (name in selectors6) {
+      property = selectors6[name];
       if (!/^\([^()]+\)$/.test(value))
         throw new Error(`Expected a parenthesized ${name}`);
       parsed = value.slice(1, -1).toLowerCase();
@@ -6994,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 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 };
+  const z54 = 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: z54 };
 }
 function parseCompressionSpringModelParams(raw) {
   const tokens = splitModelStringTokens(
@@ -7004,14 +7004,14 @@ function parseCompressionSpringModelParams(raw) {
   if (raw.fn !== "compressionspring" || tokens[0]?.toLowerCase() !== "compressionspring")
     throw new Error("Expected compressionspring without an inline argument");
   const props = { fn: "compressionspring" };
-  const lengths22 = {
+  const lengths24 = {
     od: "outerDiameter",
     wire: "wireDiameter",
     l: "freeLength",
     length: "freeLength",
     freelength: "freeLength"
   };
-  const selectors4 = {
+  const selectors6 = {
     spec: "spec",
     ends: "ends",
     hand: "hand",
@@ -7024,14 +7024,14 @@ function parseCompressionSpringModelParams(raw) {
     const value = match[2];
     let property;
     let parsed = value;
-    if (name in lengths22) property = lengths22[name];
+    if (name in lengths24) property = lengths24[name];
     else if (name === "turns" || name === "active") {
       property = name === "turns" ? "totalTurns" : "activeTurns";
       if (!/^\d+$/.test(value))
         throw new Error(`${name} requires a unitless integer`);
       parsed = Number(value);
-    } else if (name in selectors4) {
-      property = selectors4[name];
+    } else if (name in selectors6) {
+      property = selectors6[name];
       if (!/^\([^()]+\)$/.test(value))
         throw new Error(`Expected a parenthesized ${name}`);
       parsed = value.slice(1, -1).toLowerCase();
@@ -8540,11 +8540,11 @@ 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");
-  const flags6 = ["iso4032", "din934", "asmeb1822"];
+  const flags9 = ["iso4032", "din934", "asmeb1822"];
   const family = selectedFamily(props);
-  if (flags6.filter((flag) => props[flag] === true).length > 1)
+  if (flags9.filter((flag) => props[flag] === true).length > 1)
     issue("iso4032", "Select only one ISO, DIN or ASME family");
-  for (const flag of flags6)
+  for (const flag of flags9)
     if (family[flag] && props[flag] === false)
       issue(
         flag,
@@ -8598,7 +8598,7 @@ function parseHexNutModelParams(raw) {
   if (raw.fn !== "hexnut" || tokens[0]?.toLowerCase() !== "hexnut")
     throw new Error("Expected hexnut without an inline argument");
   const props = { fn: "hexnut" };
-  const selectors4 = {
+  const selectors6 = {
     threadhand: "threadHand",
     threadclass: "threadClass"
   };
@@ -8637,8 +8637,8 @@ function parseHexNutModelParams(raw) {
         props.threadPitch = 25.4 / Number(parts[1]);
       }
     } else if (name === "threadpitch") property = "threadPitch";
-    else if (name in selectors4) {
-      property = selectors4[name];
+    else if (name in selectors6) {
+      property = selectors6[name];
       if (!/^\([^()]+\)$/.test(value))
         throw new Error(`Expected a parenthesized ${name}`);
       parsed = value.slice(1, -1).toLowerCase();
@@ -9774,7 +9774,10 @@ function register33(registry2) {
 }
 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())
+  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"
+  ).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema);
 var positiveLength14 = length19.refine(
   (value) => value > 0,
@@ -9787,12 +9790,120 @@ var nonnegativeLength6 = length19.refine(
 var shape28 = {
   width: positiveLength14,
   height: positiveLength14,
-  wallThickness: positiveLength14,
-  length: positiveLength14,
-  outerRadius: nonnegativeLength6.default(0),
-  innerRadius: nonnegativeLength6.default(0)
+  border: positiveLength14,
+  thickness: positiveLength14,
+  cornerRadius: nonnegativeLength6.default(0),
+  flatFrame: external_exports.literal(true).default(true)
 };
 function validate27(p, context) {
+  const issue = (message, path) => context.addIssue({ code: "custom", message, path: [path] });
+  if (2 * p.border >= Math.min(p.width, p.height))
+    issue(
+      "The border must leave a positive-width and positive-height opening",
+      "border"
+    );
+  if (2 * p.cornerRadius >= Math.min(p.width, p.height))
+    issue(
+      "Outside corner radius must be smaller than half the short side",
+      "cornerRadius"
+    );
+  if (!Number.isFinite(
+    8 * Math.max(p.width, p.height, p.border, p.thickness, p.cornerRadius) ** 3
+  ))
+    issue("Dimensions exceed finite derived geometry limits", "width");
+}
+var rectangularGasketModelPropsSchema = external_exports.object(shape28).strict().superRefine(validate27);
+var rectangularGasketModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("rectangulargasket"), ...shape28 }).strict().superRefine(validate27);
+function getRectangularGasketDimensions(input) {
+  const p = rectangularGasketModelPropsSchema.parse(input);
+  return {
+    ...p,
+    size: [p.width, p.height, p.thickness],
+    bottomZ: 0,
+    topZ: p.thickness,
+    innerWidth: p.width - 2 * p.border,
+    innerHeight: p.height - 2 * p.border,
+    innerCornerRadius: Math.max(0, p.cornerRadius - p.border),
+    nominalVolume: (p.width * p.height - (4 - Math.PI) * p.cornerRadius ** 2 - ((p.width - 2 * p.border) * (p.height - 2 * p.border) - (4 - Math.PI) * Math.max(0, p.cornerRadius - p.border) ** 2)) * p.thickness
+  };
+}
+var lengths16 = {
+  w: "width",
+  h: "height",
+  border: "border",
+  t: "thickness",
+  cornerr: "cornerRadius",
+  width: "width",
+  height: "height",
+  thickness: "thickness",
+  cornerradius: "cornerRadius"
+};
+var flags5 = { flatframe: "flatFrame" };
+var selectors4 = {
+  profile: { value: "flatframe", property: "flatFrame" }
+};
+var integers = {};
+var tuples = {};
+function parseRectangularGasketModelParams(raw) {
+  const [name, ...tokens] = splitModelStringTokens(raw.string);
+  if (raw.fn !== "rectangulargasket" || name?.toLowerCase() !== "rectangulargasket")
+    throw new Error("Expected rectangulargasket without inline values");
+  const props = { fn: "rectangulargasket" };
+  const assign = (property, value) => {
+    if (Object.hasOwn(props, property))
+      throw new Error(`Duplicate rectangulargasket property "${property}"`);
+    props[property] = value;
+  };
+  for (const token of tokens) {
+    const match = token.match(/^([a-z]+)(.*)$/i);
+    if (!match) throw new Error(`Malformed rectangulargasket token "${token}"`);
+    const key = match[1].toLowerCase(), value = match[2];
+    if (Object.hasOwn(lengths16, key) && value) assign(lengths16[key], value);
+    else if (Object.hasOwn(flags5, key) && !value) assign(flags5[key], true);
+    else if (Object.hasOwn(selectors4, key) && value.toLowerCase() === `(${selectors4[key].value})`)
+      assign(selectors4[key].property, true);
+    else if (Object.hasOwn(integers, key) && /^\d+$/.test(value))
+      assign(integers[key], Number(value));
+    else if (Object.hasOwn(tuples, key)) {
+      const pair = value.match(/^\(([^(),]+),([^(),]+)\)$/);
+      if (!pair)
+        throw new Error(`Token "${key}" requires two parenthesized lengths`);
+      assign(tuples[key][0], pair[1].trim());
+      assign(tuples[key][1], pair[2].trim());
+    } else
+      throw new Error(`Unknown or malformed rectangulargasket token "${token}"`);
+  }
+  return rectangularGasketModelDefinitionSchema.parse(props);
+}
+var model34 = defineModel({
+  name: "rectangulargasket",
+  schema: rectangularGasketModelDefinitionSchema,
+  parse: parseRectangularGasketModelParams
+});
+function register34(registry2) {
+  registry2.register(model34);
+}
+var length20 = 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 positiveLength15 = length20.refine(
+  (value) => value > 0,
+  "Length must be positive"
+);
+var nonnegativeLength7 = length20.refine(
+  (value) => value >= 0,
+  "Length cannot be negative"
+);
+var shape29 = {
+  width: positiveLength15,
+  height: positiveLength15,
+  wallThickness: positiveLength15,
+  length: positiveLength15,
+  outerRadius: nonnegativeLength7.default(0),
+  innerRadius: nonnegativeLength7.default(0)
+};
+function validate28(p, context) {
   if (2 * p.wallThickness >= Math.min(p.width, p.height))
     context.addIssue({
       code: "custom",
@@ -9814,8 +9925,8 @@ function validate27(p, context) {
       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 rectangularTubeModelPropsSchema = external_exports.object(shape29).strict().superRefine(validate28);
+var rectangularTubeModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("rectangulartube"), ...shape29 }).strict().superRefine(validate28);
 var aliases11 = {
   w: "width",
   h: "height",
@@ -9848,13 +9959,13 @@ function parseRectangularTubeModelParams(raw) {
   }
   return rectangularTubeModelDefinitionSchema.parse(props);
 }
-var model34 = defineModel({
+var model35 = defineModel({
   name: "rectangulartube",
   schema: rectangularTubeModelDefinitionSchema,
   parse: parseRectangularTubeModelParams
 });
-function register34(registry2) {
-  registry2.register(model34);
+function register35(registry2) {
+  registry2.register(model35);
 }
 var stringFlags11 = {
   setscrew: "mount(setscrew)",
@@ -9862,19 +9973,19 @@ var stringFlags11 = {
   righthanded: "threadhand(right)"
 };
 var omittedStringFlags11 = ["righthanded"];
-var length20 = 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 positive5 = length20.refine((value) => value > 0, "Length must be positive");
-var nonnegative4 = length20.refine(
+var positive5 = length21.refine((value) => value > 0, "Length must be positive");
+var nonnegative4 = length21.refine(
   (value) => value >= 0,
   "Length cannot be negative"
 );
-var shape29 = {
+var shape30 = {
   boreDiameter: positive5,
   outerDiameter: positive5,
   boreBDiameter: positive5.optional(),
@@ -9899,7 +10010,7 @@ function resolve6(props) {
     screwAngle: (props.screwAngle % 360 + 360) % 360
   };
 }
-function validate28(props, context) {
+function validate29(props, context) {
   const p = resolve6(props);
   const issue = (message) => context.addIssue({ code: "custom", message });
   const diameter = hexSocketBoltDimensions[p.metricSize].diameter;
@@ -9923,8 +10034,8 @@ function validate28(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(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) }));
+var rigidCouplerModelPropsSchema = external_exports.object(shape30).strict().superRefine(validate29).transform(resolve6);
+var rigidCouplerModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("rigidcoupler"), ...shape30 }).strict().superRefine(validate29).transform((props) => ({ fn: props.fn, ...resolve6(props) }));
 function getRigidCouplerDimensions(input) {
   const p = rigidCouplerModelPropsSchema.parse(input);
   const threadDiameter = hexSocketBoltDimensions[p.metricSize].diameter;
@@ -10024,7 +10135,7 @@ function parseRigidCouplerModelParams(raw) {
     ...props
   });
 }
-var model35 = defineModel({
+var model36 = defineModel({
   name: "rigidcoupler",
   schema: rigidCouplerModelDefinitionSchema,
   parse: parseRigidCouplerModelParams,
@@ -10035,10 +10146,10 @@ var model35 = defineModel({
     omittedStringFlags11
   )
 });
-function register35(registry2) {
-  registry2.register(model35);
+function register36(registry2) {
+  registry2.register(model36);
 }
-var positiveLength15 = external_exports.union([
+var positiveLength16 = 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");
@@ -10093,26 +10204,26 @@ var setscrewDimensions = {
   }
 };
 var setscrewMetricSizeSchema = external_exports.enum(["M3", "M4", "M5", "M6"]);
-var shape30 = {
+var shape31 = {
   iso4029: external_exports.literal(true).default(true),
   metricSize: setscrewMetricSizeSchema,
-  length: positiveLength15,
+  length: positiveLength16,
   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: 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) => {
+  diameter: positiveLength16.optional(),
+  threadPitch: positiveLength16.optional(),
+  socketAcrossFlats: positiveLength16.optional(),
+  socketDepth: positiveLength16.optional(),
+  cupDiameter: positiveLength16.optional(),
+  cupDepth: positiveLength16.optional(),
+  pointTaperLength: positiveLength16.optional(),
+  mouthChamfer: positiveLength16.optional(),
+  threadRootDiameter: positiveLength16.optional(),
+  threadPitchDiameter: positiveLength16.optional()
+};
+var validate30 = (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)
@@ -10129,8 +10240,8 @@ var validate29 = (props, context) => {
       message: "Length must leave material between fixed end features"
     });
 };
-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 setscrewModelPropsSchema = external_exports.object(shape31).strict().superRefine(validate30).transform((props) => ({ ...props, ...setscrewDimensions[props.metricSize] }));
+var setscrewModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("setscrew"), ...shape31 }).strict().superRefine(validate30).transform((props) => ({ ...props, ...setscrewDimensions[props.metricSize] }));
 var aliases12 = {
   m: "metricSize",
   metricsize: "metricSize",
@@ -10149,7 +10260,7 @@ var aliases12 = {
   threadrootdiameter: "threadRootDiameter",
   threadpitchdiameter: "threadPitchDiameter"
 };
-var flags5 = {
+var flags6 = {
   hexsocket: "hexSocket",
   cuppoint: "cupPoint",
   lefthanded: "leftHand",
@@ -10175,9 +10286,9 @@ function parseSetScrewModelParams(raw) {
     const value = match?.[2] ?? "";
     let property;
     let parsed;
-    if (flags5[key]) {
+    if (flags6[key]) {
       if (value) throw new Error(`Flag ${key} does not accept a value`);
-      property = flags5[key];
+      property = flags6[key];
       parsed = !["righthanded", "nothreads"].includes(key);
     } else {
       property = aliases12[key] ?? "";
@@ -10203,13 +10314,13 @@ function parseSetScrewModelParams(raw) {
   }
   return setscrewModelDefinitionSchema.parse({ fn: "setscrew", ...props });
 }
-var model36 = defineModel({
+var model37 = defineModel({
   name: "setscrew",
   schema: setscrewModelDefinitionSchema,
   parse: parseSetScrewModelParams
 });
-function register36(registry2) {
-  registry2.register(model36);
+function register37(registry2) {
+  registry2.register(model37);
 }
 var stringFlags12 = {
   setscrew: "mount(setscrew)",
@@ -10217,19 +10328,19 @@ var stringFlags12 = {
   righthanded: "threadhand(right)"
 };
 var omittedStringFlags12 = ["righthanded"];
-var length21 = external_exports.union([
+var length22 = 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 = length21.refine((value) => value > 0, "Length must be positive");
-var nonnegative5 = length21.refine(
+var positive6 = length22.refine((value) => value > 0, "Length must be positive");
+var nonnegative5 = length22.refine(
   (value) => value >= 0,
   "Length cannot be negative"
 );
-var shape31 = {
+var shape32 = {
   boreDiameter: positive6,
   outerDiameter: positive6,
   width: positive6,
@@ -10251,7 +10362,7 @@ function resolve7(props) {
     screwAngle: (props.screwAngle % 360 + 360) % 360
   };
 }
-function validate30(props, context) {
+function validate31(props, context) {
   const p = resolve7(props);
   const issue = (message) => context.addIssue({ code: "custom", message });
   const diameter = hexSocketBoltDimensions[p.metricSize].diameter;
@@ -10268,8 +10379,8 @@ function validate30(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(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) }));
+var shaftCollarModelPropsSchema = external_exports.object(shape32).strict().superRefine(validate31).transform(resolve7);
+var shaftCollarModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("shaftcollar"), ...shape32 }).strict().superRefine(validate31).transform((props) => ({ fn: props.fn, ...resolve7(props) }));
 function getShaftCollarDimensions(input) {
   const p = shaftCollarModelPropsSchema.parse(input);
   const threadDiameter = hexSocketBoltDimensions[p.metricSize].diameter;
@@ -10343,7 +10454,7 @@ function parseShaftCollarModelParams(raw) {
   }
   return shaftCollarModelDefinitionSchema.parse({ fn: "shaftcollar", ...props });
 }
-var model37 = defineModel({
+var model38 = defineModel({
   name: "shaftcollar",
   schema: shaftCollarModelDefinitionSchema,
   parse: parseShaftCollarModelParams,
@@ -10354,27 +10465,118 @@ var model37 = defineModel({
     omittedStringFlags12
   )
 });
-function register37(registry2) {
-  registry2.register(model37);
+function register38(registry2) {
+  registry2.register(model38);
 }
-var length22 = external_exports.union([
+var shape33 = {
+  width: positiveGearLengthSchema,
+  height: positiveGearLengthSchema,
+  thickness: positiveGearLengthSchema,
+  innerRadius: nonnegativeGearLengthSchema,
+  length: positiveGearLengthSchema,
+  slotCount: external_exports.number().finite().int().min(1).max(256),
+  slotWidth: positiveGearLengthSchema,
+  slotLength: positiveGearLengthSchema,
+  pitch: positiveGearLengthSchema,
+  endOffset: positiveGearLengthSchema
+};
+function validate32(p, context) {
+  const issue = (message, path) => context.addIssue({ code: "custom", message, path: [path] });
+  const largestDimension = Math.max(
+    ...Object.values(p).filter(
+      (value) => typeof value === "number"
+    )
+  );
+  if (!Number.isFinite((4 * largestDimension) ** 3)) {
+    issue(
+      "Dimensions must permit finite derived coordinates and volume",
+      "width"
+    );
+    return;
+  }
+  if (2 * (p.innerRadius + p.thickness) >= p.width)
+    issue("The web must retain a straight portion between both bends", "width");
+  if (p.innerRadius + p.thickness >= p.height)
+    issue("Bends must leave a straight portion on both upright legs", "height");
+  if (p.slotLength < p.slotWidth)
+    issue("Overall slot length must be at least the slot width", "slotLength");
+  if (p.slotWidth >= p.width - 2 * (p.innerRadius + p.thickness))
+    issue("Slots must lie wholly within the straight web", "slotWidth");
+  if (p.pitch <= p.slotLength && p.slotCount > 1)
+    issue("Slot pitch must leave material between consecutive slots", "pitch");
+  if (p.endOffset <= p.slotLength / 2)
+    issue(
+      "The first slot must leave material at the first cut end",
+      "endOffset"
+    );
+  if (p.endOffset + (p.slotCount - 1) * p.pitch + p.slotLength / 2 >= p.length)
+    issue("The last slot must leave material at the far cut end", "length");
+}
+var slottedChannelModelPropsSchema = external_exports.object(shape33).strict().superRefine(validate32);
+var slottedChannelModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("slottedchannel"), ...shape33 }).strict().superRefine(validate32);
+var aliases13 = {
+  w: "width",
+  h: "height",
+  t: "thickness",
+  innerr: "innerRadius",
+  l: "length",
+  slots: "slotCount",
+  slotw: "slotWidth",
+  slotl: "slotLength",
+  pitch: "pitch",
+  end: "endOffset",
+  width: "width",
+  height: "height",
+  thickness: "thickness",
+  innerradius: "innerRadius",
+  length: "length",
+  slotcount: "slotCount",
+  slotwidth: "slotWidth",
+  slotlength: "slotLength",
+  endoffset: "endOffset"
+};
+function parseSlottedChannelModelParams(raw) {
+  const [name, ...tokens] = splitModelStringTokens(raw.string);
+  if (raw.fn !== "slottedchannel" || name?.toLowerCase() !== "slottedchannel")
+    throw new Error("Expected slottedchannel without inline values");
+  const props = { fn: "slottedchannel" };
+  for (const token of tokens) {
+    const [key, value] = parseGearToken(token);
+    if (!Object.hasOwn(aliases13, key) || !value)
+      throw new Error(`Unknown or malformed slottedchannel token "${token}"`);
+    const property = aliases13[key];
+    if (Object.hasOwn(props, property))
+      throw new Error(`Repeated slottedchannel property "${property}"`);
+    props[property] = ["slotCount"].includes(property) ? parseGearInteger(value, property) : value;
+  }
+  return slottedChannelModelDefinitionSchema.parse(props);
+}
+var model39 = defineModel({
+  name: "slottedchannel",
+  schema: slottedChannelModelDefinitionSchema,
+  parse: parseSlottedChannelModelParams
+});
+function register39(registry2) {
+  registry2.register(model39);
+}
+var length23 = 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 positiveLength16 = length22.refine(
+var positiveLength17 = length23.refine(
   (value) => value > 0,
   "Length must be positive"
 );
-var shape32 = {
-  innerDiameter: positiveLength16,
-  outerDiameter: positiveLength16,
+var shape34 = {
+  innerDiameter: positiveLength17,
+  outerDiameter: positiveLength17,
   /** End-plane distance, including the rim chamfers. */
-  length: positiveLength16,
+  length: positiveLength17,
   round: external_exports.literal(true).default(true),
   /** Equal axial/radial setbacks at all four 45-degree rims. */
-  chamfer: length22.refine((value) => value >= 0, "Chamfer cannot be negative").default(0)
+  chamfer: length23.refine((value) => value >= 0, "Chamfer cannot be negative").default(0)
 };
-function validate31(props, context) {
+function validate33(props, context) {
   if (props.outerDiameter <= props.innerDiameter)
     context.addIssue({
       code: "custom",
@@ -10394,9 +10596,9 @@ function validate31(props, context) {
       message: "Chamfers must leave positive straight bore length"
     });
 }
-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 = {
+var spacerModelPropsSchema = external_exports.object(shape34).strict().superRefine(validate33);
+var spacerModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("spacer"), ...shape34 }).strict().superRefine(validate33);
+var aliases14 = {
   id: "innerDiameter",
   innerdiameter: "innerDiameter",
   od: "outerDiameter",
@@ -10420,8 +10622,8 @@ function parseSpacerModelParams(raw) {
     if (key === "round" && value === "") {
       property = "round";
       parsed = true;
-    } else if (key && Object.hasOwn(aliases13, key) && value) {
-      property = aliases13[key];
+    } else if (key && Object.hasOwn(aliases14, key) && value) {
+      property = aliases14[key];
       parsed = value;
     } else throw new Error(`Unknown or malformed spacer token "${token}"`);
     if (Object.hasOwn(props, property))
@@ -10430,34 +10632,169 @@ function parseSpacerModelParams(raw) {
   }
   return spacerModelDefinitionSchema.parse(props);
 }
-var model38 = defineModel({
+var model40 = defineModel({
   name: "spacer",
   schema: spacerModelDefinitionSchema,
   parse: parseSpacerModelParams
 });
-function register38(registry2) {
-  registry2.register(model38);
+function register40(registry2) {
+  registry2.register(model40);
 }
-var length23 = 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,
+    "Expected a complete numeric length with an optional unit"
+  ).transform((value) => value.toLowerCase())
+]).pipe(modelLengthSchema);
+var positiveLength18 = length24.refine(
+  (value) => value > 0,
+  "Length must be positive"
+);
+var nonnegativeLength8 = length24.refine(
+  (value) => value >= 0,
+  "Length cannot be negative"
+);
+var shape35 = {
+  panelHoleDiameter: positiveLength18,
+  innerDiameter: positiveLength18,
+  outerDiameter: positiveLength18,
+  height: positiveLength18,
+  grooveWidth: positiveLength18,
+  grooveDepth: positiveLength18,
+  splitWidth: positiveLength18
+};
+function validate34(p, context) {
+  const issue = (message, path) => context.addIssue({ code: "custom", message, path: [path] });
+  if (p.innerDiameter >= p.panelHoleDiameter || p.panelHoleDiameter >= p.outerDiameter)
+    issue(
+      "Diameters must satisfy bore < panel hole < outside diameter",
+      "panelHoleDiameter"
+    );
+  if (p.grooveWidth >= p.height)
+    issue("The groove must leave two positive-thickness flanges", "grooveWidth");
+  if (Math.abs(p.outerDiameter - 2 * p.grooveDepth - p.panelHoleDiameter) > 1e-9 * p.outerDiameter)
+    issue(
+      "Panel hole diameter must equal OD minus twice the radial groove depth",
+      "grooveDepth"
+    );
+  if (p.splitWidth >= p.innerDiameter)
+    issue(
+      "The slit must be narrower than the bore to retain the opposite wall",
+      "splitWidth"
+    );
+  if (!Number.isFinite(
+    8 * Math.max(
+      p.panelHoleDiameter,
+      p.innerDiameter,
+      p.outerDiameter,
+      p.height,
+      p.grooveWidth,
+      p.grooveDepth,
+      p.splitWidth
+    ) ** 3
+  ))
+    issue(
+      "Dimensions exceed finite derived geometry limits",
+      "panelHoleDiameter"
+    );
+}
+var splitGrommetModelPropsSchema = external_exports.object(shape35).strict().superRefine(validate34);
+var splitGrommetModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("splitgrommet"), ...shape35 }).strict().superRefine(validate34);
+function getSplitGrommetDimensions(input) {
+  const p = splitGrommetModelPropsSchema.parse(input);
+  return {
+    ...p,
+    size: [p.outerDiameter, p.outerDiameter, p.height],
+    bottomZ: -p.height / 2,
+    topZ: p.height / 2,
+    grooveRootDiameter: p.outerDiameter - 2 * p.grooveDepth,
+    flangeThickness: (p.height - p.grooveWidth) / 2,
+    grooveStartZ: -p.grooveWidth / 2,
+    grooveEndZ: p.grooveWidth / 2,
+    slitMinY: -p.splitWidth / 2,
+    slitMaxY: p.splitWidth / 2,
+    minimumWallThickness: (p.panelHoleDiameter - p.innerDiameter) / 2
+  };
+}
+var lengths17 = {
+  panelhole: "panelHoleDiameter",
+  id: "innerDiameter",
+  od: "outerDiameter",
+  h: "height",
+  groovew: "grooveWidth",
+  grooved: "grooveDepth",
+  split: "splitWidth",
+  panelholediameter: "panelHoleDiameter",
+  innerdiameter: "innerDiameter",
+  outerdiameter: "outerDiameter",
+  height: "height",
+  groovewidth: "grooveWidth",
+  groovedepth: "grooveDepth",
+  splitwidth: "splitWidth"
+};
+var flags7 = {};
+var selectors5 = {};
+var integers2 = {};
+var tuples2 = {};
+function parseSplitGrommetModelParams(raw) {
+  const [name, ...tokens] = splitModelStringTokens(raw.string);
+  if (raw.fn !== "splitgrommet" || name?.toLowerCase() !== "splitgrommet")
+    throw new Error("Expected splitgrommet without inline values");
+  const props = { fn: "splitgrommet" };
+  const assign = (property, value) => {
+    if (Object.hasOwn(props, property))
+      throw new Error(`Duplicate splitgrommet property "${property}"`);
+    props[property] = value;
+  };
+  for (const token of tokens) {
+    const match = token.match(/^([a-z]+)(.*)$/i);
+    if (!match) throw new Error(`Malformed splitgrommet token "${token}"`);
+    const key = match[1].toLowerCase(), value = match[2];
+    if (Object.hasOwn(lengths17, key) && value) assign(lengths17[key], value);
+    else if (Object.hasOwn(flags7, key) && !value) assign(flags7[key], true);
+    else if (Object.hasOwn(selectors5, key) && value.toLowerCase() === `(${selectors5[key].value})`)
+      assign(selectors5[key].property, true);
+    else if (Object.hasOwn(integers2, key) && /^\d+$/.test(value))
+      assign(integers2[key], Number(value));
+    else if (Object.hasOwn(tuples2, key)) {
+      const pair = value.match(/^\(([^(),]+),([^(),]+)\)$/);
+      if (!pair)
+        throw new Error(`Token "${key}" requires two parenthesized lengths`);
+      assign(tuples2[key][0], pair[1].trim());
+      assign(tuples2[key][1], pair[2].trim());
+    } else throw new Error(`Unknown or malformed splitgrommet token "${token}"`);
+  }
+  return splitGrommetModelDefinitionSchema.parse(props);
+}
+var model41 = defineModel({
+  name: "splitgrommet",
+  schema: splitGrommetModelDefinitionSchema,
+  parse: parseSplitGrommetModelParams
+});
+function register41(registry2) {
+  registry2.register(model41);
+}
+var length25 = 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 positiveLength17 = length23.refine(
+var positiveLength19 = length25.refine(
   (value) => value > 0,
   "Length must be positive"
 );
-var shape33 = {
-  innerDiameter: positiveLength17,
-  outerDiameter: positiveLength17,
+var shape36 = {
+  innerDiameter: positiveLength19,
+  outerDiameter: positiveLength19,
   /** Axial thickness of the rectangular radial/vertical section. */
-  thickness: positiveLength17,
+  thickness: positiveLength19,
   /** End-to-end axial displacement, independent of section thickness. */
-  rise: length23.refine((value) => value >= 0, "Rise cannot be negative"),
+  rise: length25.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 validate32(p, context) {
+function validate35(p, context) {
   if (p.innerDiameter >= p.outerDiameter)
     context.addIssue({
       code: "custom",
@@ -10470,9 +10807,9 @@ function validate32(p, context) {
       message: "The washer envelope and volume must remain finite"
     });
 }
-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 = {
+var splitWasherModelPropsSchema = external_exports.object(shape36).strict().superRefine(validate35);
+var splitWasherModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("splitwasher"), ...shape36 }).strict().superRefine(validate35);
+var lengths18 = {
   id: "innerDiameter",
   innerdiameter: "innerDiameter",
   od: "outerDiameter",
@@ -10500,8 +10837,8 @@ function parseSplitWasherModelParams(raw) {
       const name = match?.[1]?.toLowerCase(), suffix = match?.[2];
       if (!name || !suffix)
         throw new Error(`Invalid split washer token "${token}"`);
-      if (Object.hasOwn(lengths16, name)) {
-        property = lengths16[name];
+      if (Object.hasOwn(lengths18, name)) {
+        property = lengths18[name];
         value = suffix;
       } else if (name === "gapangle") {
         const angle = suffix.match(/^(\d+(?:\.\d*)?|\.\d+)(?:deg)?$/i);
@@ -10516,20 +10853,20 @@ function parseSplitWasherModelParams(raw) {
   }
   return splitWasherModelDefinitionSchema.parse(props);
 }
-var model39 = defineModel({
+var model42 = defineModel({
   name: "splitwasher",
   schema: splitWasherModelDefinitionSchema,
   parse: parseSplitWasherModelParams
 });
-function register39(registry2) {
-  registry2.register(model39);
+function register42(registry2) {
+  registry2.register(model42);
 }
-var length24 = external_exports.union([
+var length26 = 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 positiveLength18 = length24.refine((value) => value > 0);
-var nonnegativeLength7 = length24.refine((value) => value >= 0);
+var positiveLength20 = length26.refine((value) => value > 0);
+var nonnegativeLength9 = length26.refine((value) => value >= 0);
 var threadedRodCoarsePitches = {
   M2: 0.4,
   "M2.5": 0.45,
@@ -10556,13 +10893,13 @@ var threadedRodMetricSizeSchema = external_exports.enum([
   "M16",
   "M20"
 ]);
-var shape34 = {
+var shape37 = {
   metricSize: threadedRodMetricSizeSchema,
   /** Overall end-plane distance, including terminal chamfers. */
-  length: positiveLength18,
+  length: positiveLength20,
   /** Equal axial and radial setbacks of the two 45-degree outer chamfers. */
-  chamfer: nonnegativeLength7.default(0),
-  threadPitch: positiveLength18.optional(),
+  chamfer: nonnegativeLength9.default(0),
+  threadPitch: positiveLength20.optional(),
   leftHand: external_exports.boolean().default(false)
 };
 function resolve8(props) {
@@ -10571,7 +10908,7 @@ function resolve8(props) {
     threadPitch: props.threadPitch ?? threadedRodCoarsePitches[props.metricSize]
   };
 }
-function validate33(props, context) {
+function validate36(props, context) {
   const diameter = Number(props.metricSize.slice(1));
   const pitch = resolve8(props).threadPitch;
   if (diameter - 1.226869 * pitch <= 0)
@@ -10587,8 +10924,8 @@ function validate33(props, context) {
       message: "Chamfer must leave flat end faces and separate end chamfers"
     });
 }
-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) }));
+var threadedRodModelPropsSchema = external_exports.object(shape37).strict().superRefine(validate36).transform(resolve8);
+var threadedRodModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("threadedrod"), ...shape37 }).strict().superRefine(validate36).transform((model502) => ({ fn: model502.fn, ...resolve8(model502) }));
 function getThreadedRodDimensions(input) {
   const props = threadedRodModelPropsSchema.parse(input);
   const diameter = Number(props.metricSize.slice(1));
@@ -10601,7 +10938,7 @@ function getThreadedRodDimensions(input) {
     endDiameter: diameter - 2 * props.chamfer
   };
 }
-var lengths17 = {
+var lengths19 = {
   l: "length",
   length: "length",
   chamfer: "chamfer",
@@ -10633,8 +10970,8 @@ function parseThreadedRodModelParams(raw) {
       if (!/^\d+(?:\.\d+)?$/.test(value))
         throw new Error("Metric size must be a unitless diameter");
       parsed = `M${value}`;
-    } else if (Object.hasOwn(lengths17, name)) {
-      property = lengths17[name];
+    } else if (Object.hasOwn(lengths19, name)) {
+      property = lengths19[name];
       parsed = value;
     } else throw new Error(`Unknown threaded rod token "${token}"`);
     if (seen.has(property))
@@ -10656,21 +10993,21 @@ function normalizeThreadedRodModelString(value) {
     return [lower === "lefthanded" ? lower : token];
   }).join("_");
 }
-var model40 = defineModel({
+var model43 = defineModel({
   name: "threadedrod",
   schema: threadedRodModelDefinitionSchema,
   parse: parseThreadedRodModelParams,
   normalizeString: normalizeThreadedRodModelString
 });
-function register40(registry2) {
-  registry2.register(model40);
+function register43(registry2) {
+  registry2.register(model43);
 }
-var length25 = external_exports.union([
+var length27 = 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 = length25.refine((value) => value > 0, "Length must be positive");
-var shape35 = {
+var positive7 = length27.refine((value) => value > 0, "Length must be positive");
+var shape38 = {
   outerDiameter: positive7.default(8),
   wireDiameter: positive7.default(0.8),
   /** Fractional turns set the relative leg direction. */
@@ -10684,7 +11021,7 @@ var shape35 = {
 function normalize7(p) {
   return { ...p, pitch: p.pitch ?? p.wireDiameter * 1.25 };
 }
-function validate34(p, context) {
+function validate37(p, context) {
   if (p.outerDiameter < 3 * p.wireDiameter)
     context.addIssue({
       code: "custom",
@@ -10706,8 +11043,8 @@ function validate34(p, context) {
       message: "Spring dimensions must remain finite"
     });
 }
-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 }));
+var torsionSpringModelPropsSchema = external_exports.object(shape38).strict().superRefine(validate37).transform(normalize7);
+var torsionSpringModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("torsionspring"), ...shape38 }).strict().superRefine(validate37).transform((p) => ({ ...normalize7(p), fn: p.fn }));
 function getTorsionSpringDimensions(input) {
   const p = torsionSpringModelPropsSchema.parse(input);
   const meanRadius = (p.outerDiameter - p.wireDiameter) / 2;
@@ -10754,7 +11091,7 @@ function getTorsionSpringFrame(input, distance2) {
   ];
   return { position, tangent, normal, binormal };
 }
-var lengths18 = {
+var lengths20 = {
   od: "outerDiameter",
   wire: "wireDiameter",
   pitch: "pitch",
@@ -10779,7 +11116,7 @@ function parseTorsionSpringModelParams(raw) {
     if (!name || !value)
       throw new Error(`Invalid torsion spring token "${token}"`);
     let property, parsed = value;
-    if (name in lengths18) property = lengths18[name];
+    if (name in lengths20) property = lengths20[name];
     else if (name === "turns") {
       property = "turns";
       if (!/^[+]?(?:\d+(?:\.\d*)?|\.\d+)$/.test(value))
@@ -10792,32 +11129,145 @@ function parseTorsionSpringModelParams(raw) {
   }
   return torsionSpringModelDefinitionSchema.parse(props);
 }
-var model41 = defineModel({
+var model44 = defineModel({
   name: "torsionspring",
   schema: torsionSpringModelDefinitionSchema,
   parse: parseTorsionSpringModelParams
 });
-function register41(registry2) {
-  registry2.register(model41);
+function register44(registry2) {
+  registry2.register(model44);
 }
-var stringFlags13 = {
-  fourtsolid: "profile(fourtsolid)"
-};
-var omittedStringFlags13 = [];
-var shape36 = {
-  width: positiveGearLengthSchema.default(20),
-  height: positiveGearLengthSchema.default(20),
-  length: positiveGearLengthSchema.default(100),
-  profile: external_exports.literal("fourtsolid").default("fourtsolid"),
-  slotWidth: positiveGearLengthSchema.default(6),
-  pocketWidth: positiveGearLengthSchema.default(10),
-  pocketDepth: positiveGearLengthSchema.default(2),
-  /** Depth of the narrow slot opening before the wider pocket begins. */
-  lipThickness: positiveGearLengthSchema.default(2),
+var length28 = 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 positiveLength21 = length28.refine(
+  (value) => value > 0,
+  "Length must be positive"
+);
+var nonnegativeLength10 = length28.refine(
+  (value) => value >= 0,
+  "Length cannot be negative"
+);
+var shape39 = {
+  length: positiveLength21,
+  width: positiveLength21,
+  thickness: positiveLength21,
+  stemWidth: positiveLength21,
+  stemHeight: positiveLength21,
+  barbWidth: positiveLength21,
+  barbHeight: positiveLength21.default(0.5),
+  tee: external_exports.literal(true).default(true)
+};
+function validate38(p, context) {
+  const span = Math.max(p.width, p.length, p.thickness + p.stemHeight);
+  if (!Number.isFinite(span ** 3))
+    context.addIssue({
+      code: "custom",
+      message: "Dimensions must have a finite bounding volume"
+    });
+  if (p.stemWidth >= p.barbWidth)
+    context.addIssue({
+      code: "custom",
+      path: ["barbWidth"],
+      message: "Retention bead must be wider than the stem"
+    });
+  if (p.barbWidth >= p.width)
+    context.addIssue({
+      code: "custom",
+      path: ["width"],
+      message: "Cover plate must extend beyond the retention bead"
+    });
+  if (p.barbHeight >= p.stemHeight)
+    context.addIssue({
+      code: "custom",
+      path: ["barbHeight"],
+      message: "Retention bead height must leave a positive narrow stem section"
+    });
+}
+var tSlotCoverStripModelPropsSchema = external_exports.object(shape39).strict().superRefine(validate38);
+var tSlotCoverStripModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("tslotcoverstrip"), ...shape39 }).strict().superRefine(validate38);
+var aliases15 = {
+  l: "length",
+  length: "length",
+  w: "width",
+  width: "width",
+  t: "thickness",
+  thickness: "thickness",
+  stemw: "stemWidth",
+  stemwidth: "stemWidth",
+  stemh: "stemHeight",
+  stemheight: "stemHeight",
+  barbw: "barbWidth",
+  barbwidth: "barbWidth",
+  barbh: "barbHeight",
+  barbheight: "barbHeight"
+};
+var flags8 = {
+  tee: "tee"
+};
+var literals = {
+  profile: ["tee", "tee"]
+};
+function parseTSlotCoverStripModelParams(raw) {
+  const [name, ...tokens] = splitModelStringTokens(raw.string);
+  if (raw.fn !== "tslotcoverstrip" || name?.toLowerCase() !== "tslotcoverstrip")
+    throw new Error("Expected tslotcoverstrip without inline values");
+  const props = { fn: "tslotcoverstrip" };
+  const assign = (property, value) => {
+    if (Object.hasOwn(props, property))
+      throw new Error(`Duplicate tslotcoverstrip property "${property}"`);
+    props[property] = value;
+  };
+  for (const token of tokens) {
+    const match = token.match(/^([a-z]+)(.*)$/i);
+    const key = match?.[1]?.toLowerCase();
+    const value = match?.[2];
+    if (!key || value === void 0)
+      throw new Error(`Malformed tslotcoverstrip token "${token}"`);
+    if (Object.hasOwn(flags8, key)) {
+      if (value !== "")
+        throw new Error(`tslotcoverstrip flag "${key}" takes no value`);
+      assign(flags8[key], true);
+    } else if (Object.hasOwn(literals, key)) {
+      const [literal, property] = literals[key];
+      if (value.toLowerCase() !== `(${literal})`)
+        throw new Error(`Expected tslotcoverstrip ${key}(${literal})`);
+      assign(property, true);
+    } else if (Object.hasOwn(aliases15, key) && value) {
+      const property = aliases15[key];
+      assign(property, property === "pinCount" ? Number(value) : value);
+    } else
+      throw new Error(`Unknown or malformed tslotcoverstrip token "${token}"`);
+  }
+  return tSlotCoverStripModelDefinitionSchema.parse(props);
+}
+var model45 = defineModel({
+  name: "tslotcoverstrip",
+  schema: tSlotCoverStripModelDefinitionSchema,
+  parse: parseTSlotCoverStripModelParams
+});
+function register45(registry2) {
+  registry2.register(model45);
+}
+var stringFlags13 = {
+  fourtsolid: "profile(fourtsolid)"
+};
+var omittedStringFlags13 = [];
+var shape40 = {
+  width: positiveGearLengthSchema.default(20),
+  height: positiveGearLengthSchema.default(20),
+  length: positiveGearLengthSchema.default(100),
+  profile: external_exports.literal("fourtsolid").default("fourtsolid"),
+  slotWidth: positiveGearLengthSchema.default(6),
+  pocketWidth: positiveGearLengthSchema.default(10),
+  pocketDepth: positiveGearLengthSchema.default(2),
+  /** Depth of the narrow slot opening before the wider pocket begins. */
+  lipThickness: positiveGearLengthSchema.default(2),
   boreDiameter: nonnegativeGearLengthSchema.default(0),
   cornerRadius: nonnegativeGearLengthSchema.default(0)
 };
-function validate35(props, context) {
+function validate39(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;
@@ -10845,9 +11295,9 @@ function validate35(props, context) {
       "boreDiameter"
     );
 }
-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 = {
+var tSlotExtrusionModelPropsSchema = external_exports.object(shape40).strict().superRefine(validate39);
+var tSlotExtrusionModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("tslotextrusion"), ...shape40 }).strict().superRefine(validate39);
+var lengths21 = {
   w: "width",
   width: "width",
   h: "height",
@@ -10878,7 +11328,7 @@ function parseTSlotExtrusionModelParams(raw) {
     const [name, value] = parseGearToken(token);
     let property;
     let parsed = value;
-    if (name in lengths19) property = lengths19[name];
+    if (name in lengths21) property = lengths21[name];
     else if (name === "profile") {
       property = "profile";
       const match = value.match(/^\(([a-z]+)\)$/i);
@@ -10891,7 +11341,7 @@ function parseTSlotExtrusionModelParams(raw) {
   }
   return tSlotExtrusionModelDefinitionSchema.parse(props);
 }
-var model42 = defineModel({
+var model46 = defineModel({
   name: "tslotextrusion",
   schema: tSlotExtrusionModelDefinitionSchema,
   parse: parseTSlotExtrusionModelParams,
@@ -10902,14 +11352,14 @@ var model42 = defineModel({
     omittedStringFlags13
   )
 });
-function register42(registry2) {
-  registry2.register(model42);
+function register46(registry2) {
+  registry2.register(model46);
 }
 var stringFlags14 = {
   righttriangle: "shape(righttriangle)"
 };
 var omittedStringFlags14 = [];
-var shape37 = {
+var shape41 = {
   width: positiveGearLengthSchema.default(40),
   height: positiveGearLengthSchema.default(40),
   thickness: positiveGearLengthSchema.default(4),
@@ -10922,22 +11372,22 @@ var shape37 = {
   /** Ligament between each slot and its parallel outer plate edge. */
   edgeMargin: positiveGearLengthSchema.default(1)
 };
-function validate36(props, context) {
+function validate40(props, context) {
   const issue = (message, path) => context.addIssue({ code: "custom", message, path: [path] });
-  const [width10, length26] = props.slot;
-  if (length26 < width10) {
+  const [width10, length29] = props.slot;
+  if (length29 < width10) {
     issue("Slot length must be at least its width", "slot");
     return;
   }
   const radius = width10 / 2;
-  const halfStraight = (length26 - width10) / 2;
+  const halfStraight = (length29 - 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 <= length26 / 2 || y <= length26 / 2)
+  if (x <= length29 / 2 || y <= length29 / 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);
@@ -10953,18 +11403,18 @@ function validate36(props, context) {
   if (Math.hypot(dx, dy) <= width10)
     issue("The two slots must retain a positive separating ligament", "centers");
 }
-var tSlotGussetModelPropsSchema = external_exports.object(shape37).strict().superRefine(validate36);
-var tSlotGussetModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("tslotgusset"), ...shape37 }).strict().superRefine(validate36);
+var tSlotGussetModelPropsSchema = external_exports.object(shape41).strict().superRefine(validate40);
+var tSlotGussetModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("tslotgusset"), ...shape41 }).strict().superRefine(validate40);
 function getTSlotGussetMountingSlots(input = {}) {
   const props = tSlotGussetModelPropsSchema.parse(input);
-  const [width10, length26] = props.slot;
+  const [width10, length29] = props.slot;
   const inset = props.edgeMargin + width10 / 2;
   return [
     {
       center: { x: props.centers[0], y: inset, z: 0 },
       orientation: 0,
       width: width10,
-      length: length26,
+      length: length29,
       depth: props.thickness,
       direction: { x: 0, y: 0, z: 1 }
     },
@@ -10972,13 +11422,13 @@ function getTSlotGussetMountingSlots(input = {}) {
       center: { x: inset, y: props.centers[1], z: 0 },
       orientation: 90,
       width: width10,
-      length: length26,
+      length: length29,
       depth: props.thickness,
       direction: { x: 0, y: 0, z: 1 }
     }
   ];
 }
-var lengths20 = {
+var lengths22 = {
   w: "width",
   width: "width",
   h: "height",
@@ -10998,7 +11448,7 @@ function parseTSlotGussetModelParams(raw) {
     const [name, value] = parseGearToken(token);
     let property;
     let parsed = value;
-    if (name in lengths20) property = lengths20[name];
+    if (name in lengths22) property = lengths22[name];
     else if (name === "slots" || name === "slotcount") {
       property = "slotCount";
       parsed = parseGearInteger(value, "slotCount");
@@ -11019,7 +11469,7 @@ function parseTSlotGussetModelParams(raw) {
   }
   return tSlotGussetModelDefinitionSchema.parse(props);
 }
-var model43 = defineModel({
+var model47 = defineModel({
   name: "tslotgusset",
   schema: tSlotGussetModelDefinitionSchema,
   parse: parseTSlotGussetModelParams,
@@ -11030,10 +11480,10 @@ var model43 = defineModel({
     omittedStringFlags14
   )
 });
-function register43(registry2) {
-  registry2.register(model43);
+function register47(registry2) {
+  registry2.register(model47);
 }
-var shape38 = {
+var shape42 = {
   width: positiveGearLengthSchema.default(20),
   /** Equal leg extents from the virtual intersection of the inside flats. */
   legLength: positiveGearLengthSchema.default(40),
@@ -11045,7 +11495,7 @@ var shape38 = {
   holeOffset: positiveGearLengthSchema.default(20),
   bendRadius: nonnegativeGearLengthSchema.default(0)
 };
-function validate37(props, context) {
+function validate41(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");
@@ -11063,9 +11513,9 @@ function validate37(props, context) {
   if (props.holeOffset + radius >= props.legLength)
     issue("Holes must leave material at the free leg ends", "holeOffset");
 }
-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 = {
+var tSlotInsideCornerModelPropsSchema = external_exports.object(shape42).strict().superRefine(validate41);
+var tSlotInsideCornerModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("tslotinsidecorner"), ...shape42 }).strict().superRefine(validate41);
+var lengths23 = {
   w: "width",
   width: "width",
   leg: "legLength",
@@ -11088,7 +11538,7 @@ function parseTSlotInsideCornerModelParams(raw) {
     const [name, value] = parseGearToken(token);
     let property;
     let parsed = value;
-    if (name in lengths21) property = lengths21[name];
+    if (name in lengths23) property = lengths23[name];
     else if (name === "holes" || name === "holecount") {
       property = "holeCount";
       parsed = parseGearInteger(value, "holeCount");
@@ -11102,13 +11552,85 @@ function parseTSlotInsideCornerModelParams(raw) {
   }
   return tSlotInsideCornerModelDefinitionSchema.parse(props);
 }
-var model44 = defineModel({
+var model48 = defineModel({
   name: "tslotinsidecorner",
   schema: tSlotInsideCornerModelDefinitionSchema,
   parse: parseTSlotInsideCornerModelParams
 });
-function register44(registry2) {
-  registry2.register(model44);
+function register48(registry2) {
+  registry2.register(model48);
+}
+var shape43 = {
+  height: positiveGearLengthSchema,
+  upperWidth: positiveGearLengthSchema,
+  lowerWidth: positiveGearLengthSchema,
+  thickness: positiveGearLengthSchema,
+  bendRadius: nonnegativeGearLengthSchema,
+  length: positiveGearLengthSchema
+};
+function validate42(p, context) {
+  const issue = (message, path) => context.addIssue({ code: "custom", message, path: [path] });
+  const largestDimension = Math.max(
+    ...Object.values(p).filter(
+      (value) => typeof value === "number"
+    )
+  );
+  if (!Number.isFinite((4 * largestDimension) ** 3)) {
+    issue(
+      "Dimensions must permit finite derived coordinates and volume",
+      "height"
+    );
+    return;
+  }
+  if (p.bendRadius + p.thickness >= Math.min(p.upperWidth, p.lowerWidth))
+    issue(
+      "Both flanges must retain straight portions beyond their bends",
+      "bendRadius"
+    );
+  if (2 * (p.bendRadius + p.thickness) >= p.height)
+    issue("Height must leave a straight web between both bends", "height");
+  if (!Number.isFinite(p.upperWidth + p.lowerWidth - p.thickness))
+    issue("The combined section width must be finite", "upperWidth");
+}
+var zeeBarModelPropsSchema = external_exports.object(shape43).strict().superRefine(validate42);
+var zeeBarModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("zeebar"), ...shape43 }).strict().superRefine(validate42);
+var aliases16 = {
+  h: "height",
+  upperw: "upperWidth",
+  lowerw: "lowerWidth",
+  t: "thickness",
+  bendr: "bendRadius",
+  l: "length",
+  height: "height",
+  upperwidth: "upperWidth",
+  lowerwidth: "lowerWidth",
+  thickness: "thickness",
+  bendradius: "bendRadius",
+  length: "length"
+};
+function parseZeeBarModelParams(raw) {
+  const [name, ...tokens] = splitModelStringTokens(raw.string);
+  if (raw.fn !== "zeebar" || name?.toLowerCase() !== "zeebar")
+    throw new Error("Expected zeebar without inline values");
+  const props = { fn: "zeebar" };
+  for (const token of tokens) {
+    const [key, value] = parseGearToken(token);
+    if (!Object.hasOwn(aliases16, key) || !value)
+      throw new Error(`Unknown or malformed zeebar token "${token}"`);
+    const property = aliases16[key];
+    if (Object.hasOwn(props, property))
+      throw new Error(`Repeated zeebar property "${property}"`);
+    props[property] = value;
+  }
+  return zeeBarModelDefinitionSchema.parse(props);
+}
+var model49 = defineModel({
+  name: "zeebar",
+  schema: zeeBarModelDefinitionSchema,
+  parse: parseZeeBarModelParams
+});
+function register49(registry2) {
+  registry2.register(model49);
 }
 function getNemaMotorReferencePoints(input) {
   const p = nemaMotorModelPropsSchema.parse(input);
@@ -11198,7 +11720,12 @@ var modelDefinitionSchema = external_exports.union([
   model41.schema,
   model42.schema,
   model43.schema,
-  model44.schema
+  model44.schema,
+  model45.schema,
+  model46.schema,
+  model47.schema,
+  model48.schema,
+  model49.schema
 ]);
 function registerAllModels(registry2) {
   register(registry2);
@@ -11245,6 +11772,11 @@ function registerAllModels(registry2) {
   register42(registry2);
   register43(registry2);
   register44(registry2);
+  register45(registry2);
+  register46(registry2);
+  register47(registry2);
+  register48(registry2);
+  register49(registry2);
 }
 var registry = new ModelRegistry();
 registerAllModels(registry);
@@ -11427,24 +11959,24 @@ var FootprintPlatedHole = ({
 };
 
 // lib/model-registry.ts
-function defineModelRenderer(model88) {
-  return model88;
+function defineModelRenderer(model98) {
+  return model98;
 }
 var ModelRendererRegistry = class {
   models = /* @__PURE__ */ new Map();
-  register(model88) {
-    if (typeof model88.name !== "string" || !/^[a-z]+$/.test(model88.name)) {
+  register(model98) {
+    if (typeof model98.name !== "string" || !/^[a-z]+$/.test(model98.name)) {
       throw new Error(
         "Model renderer names must contain only lowercase letters"
       );
     }
-    if (this.models.has(model88.name)) {
-      throw new Error(`Model renderer "${model88.name}" is already registered`);
+    if (this.models.has(model98.name)) {
+      throw new Error(`Model renderer "${model98.name}" is already registered`);
     }
-    if (model88.pads !== "none" && model88.pads !== "footprinter") {
+    if (model98.pads !== "none" && model98.pads !== "footprinter") {
       throw new Error('Model renderer pads must be "none" or "footprinter"');
     }
-    const { name, schema, render: render2, pads } = model88;
+    const { name, schema, render: render2, pads } = model98;
     this.models.set(name, {
       name,
       schema,
@@ -11475,7 +12007,7 @@ 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);
+var profile = (shape44, height10) => extrusions.extrudeLinear({ height: height10 }, shape44);
 function filletProfile(points, radii, width10, height10) {
   const outline = [];
   for (let i = 0; i < points.length; i++) {
@@ -11570,14 +12102,14 @@ function AngleBar({ color = "#929da9", ...props }) {
 }
 
 // lib/models/anglebar/register.tsx
-var model45 = defineModelRenderer({
+var model50 = defineModelRenderer({
   name: "anglebar",
   schema: angleBarModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(AngleBar, { ...props }),
   pads: "none"
 });
-function register45(registry2) {
-  registry2.register(model45);
+function register50(registry2) {
+  registry2.register(model50);
 }
 
 // lib/mechanical/indexedMeshToGeom3.ts
@@ -11708,7 +12240,7 @@ function createBallBearingMesh(input = {}, options = {}) {
     if (face2 === "open") continue;
     const t = d.closureThickness;
     const ri = d.innerRaceOuterRadius, ro = d.outerRaceInnerRadius;
-    const shape39 = face2 === "shielded" ? [
+    const shape44 = face2 === "shielded" ? [
       [ro, 0],
       [ro, t * 0.45],
       [ri, t * 0.45],
@@ -11721,7 +12253,7 @@ function createBallBearingMesh(input = {}, options = {}) {
       [ri + 0.15 * (ro - ri), 0.5 * t],
       [ro - 0.15 * (ro - ri), 0.5 * t]
     ];
-    const profile6 = sign === -1 ? shape39 : shape39.map(([r, z]) => [r, d.width - z]).reverse();
+    const profile6 = sign === -1 ? shape44 : shape44.map(([r, z]) => [r, d.width - z]).reverse();
     parts.push({
       name: `${face2} ${sign < 0 ? "lower" : "upper"}`,
       color: face2 === "sealed" ? "#252a30" : "#b5bbc3",
@@ -11735,9 +12267,9 @@ function segmentsFor(value = 96) {
     throw new Error("Segments must be a multiple of 24 from 96 to 192");
   return value;
 }
-function checkPrecision(lengths22) {
-  const largest = Math.max(...lengths22);
-  if (!lengths22.every(Number.isFinite) || largest > 1e6 || Math.min(...lengths22) < Math.max(1e-5, largest * 1e-7))
+function checkPrecision(lengths24) {
+  const largest = Math.max(...lengths24);
+  if (!lengths24.every(Number.isFinite) || largest > 1e6 || Math.min(...lengths24) < Math.max(1e-5, largest * 1e-7))
     throw new Error(
       "Bearing dimensions exceed the renderer's numerical resolution"
     );
@@ -11845,14 +12377,14 @@ function BallBearing({ color, ...props }) {
 }
 
 // lib/models/ballbearing/register.tsx
-var model46 = defineModelRenderer({
+var model51 = defineModelRenderer({
   name: "ballbearing",
   schema: ballBearingModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(BallBearing, { ...props }),
   pads: "none"
 });
-function register46(registry2) {
-  registry2.register(model46);
+function register51(registry2) {
+  registry2.register(model51);
 }
 
 // lib/models/balltransferunit/mesh.ts
@@ -11944,7 +12476,7 @@ function circularProfile(x, y, radius, segments = 96) {
 // lib/models/balltransferunit/mesh.ts
 function createBallTransferUnitMesh(input = {}) {
   const d = getBallTransferUnitDimensions(input);
-  const lengths22 = [
+  const lengths24 = [
     d.height,
     d.flangeDiameter,
     d.flangeThickness,
@@ -11958,9 +12490,9 @@ function createBallTransferUnitMesh(input = {}) {
     (d.pitchCircleDiameter - d.holeDiameter - d.bodyDiameter) / 2,
     (d.flangeDiameter - d.pitchCircleDiameter - d.holeDiameter) / 2
   ];
-  const largest = Math.max(...lengths22);
+  const largest = Math.max(...lengths24);
   const resolution7 = Math.max(1e-5, largest * 1e-7);
-  if (!lengths22.every(Number.isFinite) || largest > 1e6 || Math.min(...lengths22) < resolution7)
+  if (!lengths24.every(Number.isFinite) || largest > 1e6 || Math.min(...lengths24) < resolution7)
     throw new Error(
       "Ball transfer unit exceeds the renderer's numerical resolution"
     );
@@ -12101,14 +12633,14 @@ function BallTransferUnit({ color, ...props }) {
 }
 
 // lib/models/balltransferunit/register.tsx
-var model47 = defineModelRenderer({
+var model52 = defineModelRenderer({
   name: "balltransferunit",
   schema: ballTransferUnitModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(BallTransferUnit, { ...props }),
   pads: "none"
 });
-function register47(registry2) {
-  registry2.register(model47);
+function register52(registry2) {
+  registry2.register(model52);
 }
 
 // lib/models/buttonscrew/mesh.ts
@@ -12228,14 +12760,14 @@ function ButtonScrew({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/buttonscrew/register.tsx
-var model48 = defineModelRenderer({
+var model53 = defineModelRenderer({
   name: "buttonscrew",
   schema: buttonScrewModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(ButtonScrew, { ...props }),
   pads: "none"
 });
-function register48(registry2) {
-  registry2.register(model48);
+function register53(registry2) {
+  registry2.register(model53);
 }
 
 // lib/models/cablegrommet/mesh.ts
@@ -12303,14 +12835,14 @@ function CableGrommet({
 }
 
 // lib/models/cablegrommet/register.tsx
-var model49 = defineModelRenderer({
+var model54 = defineModelRenderer({
   name: "cablegrommet",
   schema: cableGrommetModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(CableGrommet, { ...props }),
   pads: "none"
 });
-function register49(registry2) {
-  registry2.register(model49);
+function register54(registry2) {
+  registry2.register(model54);
 }
 
 // lib/models/channelbar/geometry.ts
@@ -12318,7 +12850,7 @@ 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);
+var profile2 = (shape44, height10) => extrusions2.extrudeLinear({ height: height10 }, shape44);
 function filletProfile2(points, radii, width10, height10) {
   const outline = [];
   for (let i = 0; i < points.length; i++) {
@@ -12424,14 +12956,14 @@ function ChannelBar({ color = "#929da9", ...props }) {
 }
 
 // lib/models/channelbar/register.tsx
-var model50 = defineModelRenderer({
+var model55 = defineModelRenderer({
   name: "channelbar",
   schema: channelBarModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(ChannelBar, { ...props }),
   pads: "none"
 });
-function register50(registry2) {
-  registry2.register(model50);
+function register55(registry2) {
+  registry2.register(model55);
 }
 
 // lib/models/clampingshaftcollar/mesh.ts
@@ -12459,9 +12991,9 @@ function createAnnularSleeve({
   outerRadius,
   boreARadius,
   boreBRadius = boreARadius,
-  length: length26,
+  length: length29,
   chamfer,
-  stepZ = length26 / 2
+  stepZ = length29 / 2
 }) {
   const halfAngle = Math.PI / bodySegments;
   const cosine = Math.cos(halfAngle);
@@ -12472,10 +13004,10 @@ function createAnnularSleeve({
   const raw = [
     [0, outerRadius - chamfer, false],
     [chamfer, outerRadius, false],
-    [length26 - chamfer, outerRadius, false],
-    [length26, outerRadius - chamfer, false],
-    [length26, boreBRadius + chamfer, true],
-    [length26 - chamfer, boreBRadius, true],
+    [length29 - chamfer, outerRadius, false],
+    [length29, outerRadius - chamfer, false],
+    [length29, boreBRadius + chamfer, true],
+    [length29 - chamfer, boreBRadius, true],
     [stepZ, boreBRadius, true],
     [stepZ, boreARadius, true],
     [chamfer, boreARadius, true],
@@ -12725,14 +13257,14 @@ function ClampingShaftCollar({
 }
 
 // lib/models/clampingshaftcollar/register.tsx
-var model51 = defineModelRenderer({
+var model56 = defineModelRenderer({
   name: "clampingshaftcollar",
   schema: clampingShaftCollarModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(ClampingShaftCollar, { ...props }),
   pads: "none"
 });
-function register51(registry2) {
-  registry2.register(model51);
+function register56(registry2) {
+  registry2.register(model56);
 }
 
 // lib/mechanical/clip-mesh-to-z-range.ts
@@ -12928,14 +13460,14 @@ function CompressionSpring({
 }
 
 // lib/models/compressionspring/register.tsx
-var model52 = defineModelRenderer({
+var model57 = defineModelRenderer({
   name: "compressionspring",
   schema: compressionSpringModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(CompressionSpring, { ...props }),
   pads: "none"
 });
-function register52(registry2) {
-  registry2.register(model52);
+function register57(registry2) {
+  registry2.register(model57);
 }
 
 // lib/models/dowelpin/mesh.ts
@@ -12986,14 +13518,14 @@ function DowelPin({ color = "#929da9", ...props }) {
 }
 
 // lib/models/dowelpin/register.tsx
-var model53 = defineModelRenderer({
+var model58 = defineModelRenderer({
   name: "dowelpin",
   schema: dowelPinModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(DowelPin, { ...props }),
   pads: "none"
 });
-function register53(registry2) {
-  registry2.register(model53);
+function register58(registry2) {
+  registry2.register(model58);
 }
 
 // lib/models/femalestandoff/mesh.ts
@@ -13095,14 +13627,14 @@ function FemaleStandoff({
 }
 
 // lib/models/femalestandoff/register.tsx
-var model54 = defineModelRenderer({
+var model59 = defineModelRenderer({
   name: "femalestandoff",
   schema: femaleStandoffModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FemaleStandoff, { ...props }),
   pads: "none"
 });
-function register54(registry2) {
-  registry2.register(model54);
+function register59(registry2) {
+  registry2.register(model59);
 }
 
 // lib/models/flangebolt/mesh.ts
@@ -13249,14 +13781,14 @@ function FlangeBolt({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/flangebolt/register.tsx
-var model55 = defineModelRenderer({
+var model60 = defineModelRenderer({
   name: "flangebolt",
   schema: flangeboltModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlangeBolt, { ...props }),
   pads: "none"
 });
-function register55(registry2) {
-  registry2.register(model55);
+function register60(registry2) {
+  registry2.register(model60);
 }
 
 // lib/models/flangedbushing/mesh.ts
@@ -13305,14 +13837,14 @@ function FlangedBushing({
 }
 
 // lib/models/flangedbushing/register.tsx
-var model56 = defineModelRenderer({
+var model61 = defineModelRenderer({
   name: "flangedbushing",
   schema: flangedBushingModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlangedBushing, { ...props }),
   pads: "none"
 });
-function register56(registry2) {
-  registry2.register(model56);
+function register61(registry2) {
+  registry2.register(model61);
 }
 
 // lib/models/flangenut/mesh.ts
@@ -13418,14 +13950,14 @@ function FlangeNut({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/flangenut/register.tsx
-var model57 = defineModelRenderer({
+var model62 = defineModelRenderer({
   name: "flangenut",
   schema: flangeNutModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlangeNut, { ...props }),
   pads: "none"
 });
-function register57(registry2) {
-  registry2.register(model57);
+function register62(registry2) {
+  registry2.register(model62);
 }
 
 // lib/models/flatheadscrew/mesh.ts
@@ -13552,14 +14084,14 @@ function FlatHeadScrew({
 }
 
 // lib/models/flatheadscrew/register.tsx
-var model58 = defineModelRenderer({
+var model63 = defineModelRenderer({
   name: "flatheadscrew",
   schema: flatHeadScrewModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlatHeadScrew, { ...props }),
   pads: "none"
 });
-function register58(registry2) {
-  registry2.register(model58);
+function register63(registry2) {
+  registry2.register(model63);
 }
 
 // lib/Screen.tsx
@@ -14234,14 +14766,14 @@ var FlexScreen = (props) => {
 };
 
 // lib/models/flexscreen/register.tsx
-var model59 = defineModelRenderer({
+var model64 = defineModelRenderer({
   name: "flexscreen",
   schema: flexScreenModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlexScreen, { ...props }),
   pads: "footprinter"
 });
-function register59(registry2) {
-  registry2.register(model59);
+function register64(registry2) {
+  registry2.register(model64);
 }
 
 // lib/models/heatsetinsert/mesh.ts
@@ -14326,14 +14858,14 @@ function HeatSetInsert({
 }
 
 // lib/models/heatsetinsert/register.tsx
-var model60 = defineModelRenderer({
+var model65 = defineModelRenderer({
   name: "heatsetinsert",
   schema: heatSetInsertModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HeatSetInsert, { ...props }),
   pads: "none"
 });
-function register60(registry2) {
-  registry2.register(model60);
+function register65(registry2) {
+  registry2.register(model65);
 }
 
 // lib/mechanical/spur-gear-mesh.ts
@@ -14526,14 +15058,14 @@ function HelicalGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/helicalgear/register.tsx
-var model61 = defineModelRenderer({
+var model66 = defineModelRenderer({
   name: "helicalgear",
   schema: helicalGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HelicalGear, { ...props }),
   pads: "none"
 });
-function register61(registry2) {
-  registry2.register(model61);
+function register66(registry2) {
+  registry2.register(model66);
 }
 
 // lib/models/hexbolt/mesh.ts
@@ -14668,14 +15200,14 @@ function HexBolt({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/hexbolt/register.tsx
-var model62 = defineModelRenderer({
+var model67 = defineModelRenderer({
   name: "hexbolt",
   schema: hexBoltModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexBolt, { ...props }),
   pads: "none"
 });
-function register62(registry2) {
-  registry2.register(model62);
+function register67(registry2) {
+  registry2.register(model67);
 }
 
 // lib/models/hexnut/mesh.ts
@@ -14794,14 +15326,14 @@ function HexNut({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/hexnut/register.tsx
-var model63 = defineModelRenderer({
+var model68 = defineModelRenderer({
   name: "hexnut",
   schema: hexNutModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexNut, { ...props }),
   pads: "none"
 });
-function register63(registry2) {
-  registry2.register(model63);
+function register68(registry2) {
+  registry2.register(model68);
 }
 
 // lib/mechanical/hex-socket-bolt-mesh.ts
@@ -14815,9 +15347,9 @@ var createHexSocketBoltMesh = (input) => {
     socketWidth,
     socketDepth
   } = hexSocketBoltDimensions[props.metricSize];
-  const { length: length26, showThreads } = props;
+  const { length: length29, showThreads } = props;
   const segments = 96;
-  const steps = showThreads ? Math.max(2, Math.ceil(length26 / pitch * 24)) : 2;
+  const steps = showThreads ? Math.max(2, Math.ceil(length29 / pitch * 24)) : 2;
   if (steps > 24e3)
     throw new Error(
       "Bolt length exceeds mesh resolution limit (1000 thread turns)"
@@ -14827,7 +15359,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, length26 / 3);
+  const tipBevel = Math.min(pitch * 0.6, length29 / 3);
   const ring = (z, radiusAt) => {
     const start = positions.length / 3;
     for (let i = 0; i < segments; i++) {
@@ -14855,8 +15387,8 @@ var createHexSocketBoltMesh = (input) => {
   let previous = -1;
   const shaftLevels = showThreads ? Array.from(
     { length: steps + 1 },
-    (_, step) => -length26 + length26 * step / steps
-  ) : [-length26, -length26 + tipBevel, 0];
+    (_, step) => -length29 + length29 * step / steps
+  ) : [-length29, -length29 + tipBevel, 0];
   for (const z of shaftLevels) {
     const current = ring(z, (angle) => {
       const phase = ((z / pitch - angle / (2 * Math.PI)) % 1 + 1) % 1;
@@ -14867,10 +15399,10 @@ var createHexSocketBoltMesh = (input) => {
       );
       const endRamp = Math.min(
         1,
-        (z + length26) / tipBevel,
-        -z / Math.min(pitch / 2, length26 / 3)
+        (z + length29) / tipBevel,
+        -z / Math.min(pitch / 2, length29 / 3)
       );
-      const tipCut = tipBevel * Math.max(0, 1 - (z + length26) / tipBevel);
+      const tipCut = tipBevel * Math.max(0, 1 - (z + length29) / tipBevel);
       return radius - (showThreads ? groove * endRamp : 0) - tipCut;
     });
     if (previous < 0) cap2(current, z, false);
@@ -14906,14 +15438,14 @@ function HexSocketBolt({
 }
 
 // lib/models/hexsocketbolt/register.tsx
-var model64 = defineModelRenderer({
+var model69 = defineModelRenderer({
   name: "hexsocketbolt",
   schema: hexSocketBoltModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexSocketBolt, { ...props }),
   pads: "none"
 });
-function register64(registry2) {
-  registry2.register(model64);
+function register69(registry2) {
+  registry2.register(model69);
 }
 
 // lib/models/hollowpositioningarmtube/mesh.ts
@@ -15026,14 +15558,14 @@ function HollowPositioningArmTube({
 }
 
 // lib/models/hollowpositioningarmtube/register.tsx
-var model65 = defineModelRenderer({
+var model70 = defineModelRenderer({
   name: "hollowpositioningarmtube",
   schema: hollowPositioningArmTubeModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HollowPositioningArmTube, { ...props }),
   pads: "none"
 });
-function register65(registry2) {
-  registry2.register(model65);
+function register70(registry2) {
+  registry2.register(model70);
 }
 
 // lib/models/malefemalestandoff/mesh.ts
@@ -15165,14 +15697,14 @@ function MaleFemaleStandoff({
 }
 
 // lib/models/malefemalestandoff/register.tsx
-var model66 = defineModelRenderer({
+var model71 = defineModelRenderer({
   name: "malefemalestandoff",
   schema: maleFemaleStandoffModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(MaleFemaleStandoff, { ...props }),
   pads: "none"
 });
-function register66(registry2) {
-  registry2.register(model66);
+function register71(registry2) {
+  registry2.register(model71);
 }
 
 // lib/NemaMotor.tsx
@@ -15431,14 +15963,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 model67 = defineModelRenderer({
+var model72 = defineModelRenderer({
   name: "nema",
   schema: nemaMotorModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(NemaMotor, { ...props }),
   pads: "none"
 });
-function register67(registry2) {
-  registry2.register(model67);
+function register72(registry2) {
+  registry2.register(model72);
 }
 
 // lib/models/nylonlocknut/mesh.ts
@@ -15574,14 +16106,14 @@ function NylonLockNut({
 }
 
 // lib/models/nylonlocknut/register.tsx
-var model68 = defineModelRenderer({
+var model73 = defineModelRenderer({
   name: "nylonlocknut",
   schema: nylonLockNutModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(NylonLockNut, { ...props }),
   pads: "none"
 });
-function register68(registry2) {
-  registry2.register(model68);
+function register73(registry2) {
+  registry2.register(model73);
 }
 
 // lib/models/panscrew/mesh.ts
@@ -15787,15 +16319,15 @@ function PanScrew({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/panscrew/register.tsx
-var model69 = defineModelRenderer({
+var model74 = defineModelRenderer({
   name: "panscrew",
   schema: panScrewModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(PanScrew, { ...props }),
   pads: "none"
 });
-function register69(registry2) {
-  registry2.register(model69);
-}
+function register74(registry2) {
+  registry2.register(model74);
+}
 
 // lib/models/perforatedsheet/geometry.ts
 import jscad8 from "@jscad/modeling";
@@ -15810,7 +16342,7 @@ var {
 var generalize4 = modifiers3.generalize;
 var { subtract } = booleans;
 var { rectangle: rectangle3, roundedRectangle: roundedRectangle3, circle: circle2 } = primitives3;
-var profile3 = (shape39, height10) => extrusions3.extrudeLinear({ height: height10 }, shape39);
+var profile3 = (shape44, height10) => extrusions3.extrudeLinear({ height: height10 }, shape44);
 function perforated(p) {
   const holes = [];
   const rows = Math.floor((p.width - 2 * p.edgeY) / p.pitchY + 1 + 1e-10);
@@ -15880,14 +16412,14 @@ function PerforatedSheet({
 }
 
 // lib/models/perforatedsheet/register.tsx
-var model70 = defineModelRenderer({
+var model75 = defineModelRenderer({
   name: "perforatedsheet",
   schema: perforatedSheetModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(PerforatedSheet, { ...props }),
   pads: "none"
 });
-function register70(registry2) {
-  registry2.register(model70);
+function register75(registry2) {
+  registry2.register(model75);
 }
 
 // lib/models/plainbushing/mesh.ts
@@ -15943,14 +16475,14 @@ function PlainBushing({
 }
 
 // lib/models/plainbushing/register.tsx
-var model71 = defineModelRenderer({
+var model76 = defineModelRenderer({
   name: "plainbushing",
   schema: plainBushingModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(PlainBushing, { ...props }),
   pads: "none"
 });
-function register71(registry2) {
-  registry2.register(model71);
+function register76(registry2) {
+  registry2.register(model76);
 }
 
 // lib/models/pushfitplug/geometry.ts
@@ -16015,14 +16547,14 @@ function PushFitPlug({ color = "#929da9", ...props }) {
 }
 
 // lib/models/pushfitplug/register.tsx
-var model72 = defineModelRenderer({
+var model77 = defineModelRenderer({
   name: "pushfitplug",
   schema: pushFitPlugModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(PushFitPlug, { ...props }),
   pads: "none"
 });
-function register72(registry2) {
-  registry2.register(model72);
+function register77(registry2) {
+  registry2.register(model77);
 }
 
 // lib/models/rectangularbar/geometry.ts
@@ -16030,7 +16562,7 @@ 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 profile4 = (shape44, height10) => extrusions5.extrudeLinear({ height: height10 }, shape44);
 var roundedRect = (width10, height10, radius) => radius ? roundedRectangle5({
   size: [width10, height10],
   roundRadius: radius,
@@ -16084,14 +16616,123 @@ function RectangularBar({
 }
 
 // lib/models/rectangularbar/register.tsx
-var model73 = defineModelRenderer({
+var model78 = defineModelRenderer({
   name: "rectangularbar",
   schema: rectangularBarModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(RectangularBar, { ...props }),
   pads: "none"
 });
-function register73(registry2) {
-  registry2.register(model73);
+function register78(registry2) {
+  registry2.register(model78);
+}
+
+// lib/models/rectangulargasket/geometry.ts
+function retainCapSeams(mesh, tolerance) {
+  const positions = [...mesh.positions], indices = [];
+  const count = mesh.positions.length / 3;
+  for (let i = 0; i < mesh.indices.length; i += 3) {
+    const ids = mesh.indices.slice(i, i + 3), boundary = [];
+    for (let side = 0; side < 3; side++) {
+      const a = ids[side], b = ids[(side + 1) % 3];
+      const origin = positions.slice(a * 3, a * 3 + 3);
+      const delta = positions.slice(b * 3, b * 3 + 3).map((x, axis) => x - origin[axis]);
+      const lengthSquared = delta.reduce((sum, x) => sum + x * x, 0);
+      const length29 = Math.sqrt(lengthSquared);
+      const intermediate = [];
+      for (let id = 0; id < count; id++) {
+        if (id === a || id === b) continue;
+        const point = positions.slice(id * 3, id * 3 + 3);
+        const t = point.reduce(
+          (sum, x, axis) => sum + (x - origin[axis]) * delta[axis],
+          0
+        ) / lengthSquared;
+        if (t * length29 <= tolerance || (1 - t) * length29 <= tolerance) continue;
+        if (Math.hypot(
+          ...point.map((x, axis) => x - origin[axis] - t * delta[axis])
+        ) <= tolerance)
+          intermediate.push({ id, t });
+      }
+      boundary.push(
+        a,
+        ...intermediate.sort((a2, b2) => a2.t - b2.t).map((point) => point.id)
+      );
+    }
+    if (boundary.length === 3) indices.push(...boundary);
+    else {
+      const center = positions.length / 3;
+      for (let axis = 0; axis < 3; axis++)
+        positions.push(
+          ids.reduce((sum, id) => sum + mesh.positions[id * 3 + axis], 0) / 3
+        );
+      for (let side = 0; side < boundary.length; side++)
+        indices.push(
+          center,
+          boundary[side],
+          boundary[(side + 1) % boundary.length]
+        );
+    }
+  }
+  return { positions, indices };
+}
+function createRectangularGasketMesh(input) {
+  const p = rectangularGasketModelPropsSchema.parse(input), d = getRectangularGasketDimensions(p);
+  if (Math.min(p.thickness, p.border, d.innerWidth, d.innerHeight) <= Math.max(...d.size) * 1e-10)
+    throw new Error(
+      "rectangulargasket dimensions exceed mesh resolution limits"
+    );
+  const rounded = (width10, height10, radius) => {
+    if (radius === 0)
+      return [
+        [-width10 / 2, -height10 / 2],
+        [width10 / 2, -height10 / 2],
+        [width10 / 2, height10 / 2],
+        [-width10 / 2, height10 / 2]
+      ];
+    const points = [];
+    for (let corner = 0; corner < 4; corner++) {
+      const x = (corner === 0 || corner === 3 ? 1 : -1) * (width10 / 2 - radius);
+      const y = (corner < 2 ? 1 : -1) * (height10 / 2 - radius);
+      for (let step = 0; step <= 32; step++) {
+        const angle = corner * Math.PI / 2 + step * Math.PI / 64;
+        points.push([
+          x + radius * Math.cos(angle),
+          y + radius * Math.sin(angle)
+        ]);
+      }
+    }
+    return points;
+  };
+  return retainCapSeams(
+    extrudePlanarProfile({
+      outer: rounded(p.width, p.height, p.cornerRadius),
+      holes: [rounded(d.innerWidth, d.innerHeight, d.innerCornerRadius)],
+      start: d.bottomZ,
+      end: d.topZ
+    }),
+    Math.max(...d.size) * 1e-10
+  );
+}
+function createRectangularGasketGeom(input) {
+  return indexedMeshToGeom3(createRectangularGasketMesh(input));
+}
+
+// lib/models/rectangulargasket/RectangularGasket.tsx
+function RectangularGasket({
+  color = "#394553",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createRectangularGasketGeom(props) }) });
+}
+
+// lib/models/rectangulargasket/register.tsx
+var model79 = defineModelRenderer({
+  name: "rectangulargasket",
+  schema: rectangularGasketModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(RectangularGasket, { ...props }),
+  pads: "none"
+});
+function register79(registry2) {
+  registry2.register(model79);
 }
 
 // lib/models/rectangulartube/geometry.ts
@@ -16107,7 +16748,7 @@ var {
 var generalize7 = modifiers6.generalize;
 var { subtract: subtract2 } = booleans2;
 var { rectangle: rectangle6, roundedRectangle: roundedRectangle6 } = primitives6;
-var profile5 = (shape39, height10) => extrusions6.extrudeLinear({ height: height10 }, shape39);
+var profile5 = (shape44, height10) => extrusions6.extrudeLinear({ height: height10 }, shape44);
 var roundedRect2 = (width10, height10, radius) => radius ? roundedRectangle6({
   size: [width10, height10],
   roundRadius: radius,
@@ -16171,14 +16812,14 @@ function RectangularTube({
 }
 
 // lib/models/rectangulartube/register.tsx
-var model74 = defineModelRenderer({
+var model80 = defineModelRenderer({
   name: "rectangulartube",
   schema: rectangularTubeModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(RectangularTube, { ...props }),
   pads: "none"
 });
-function register74(registry2) {
-  registry2.register(model74);
+function register80(registry2) {
+  registry2.register(model80);
 }
 
 // lib/models/rigidcoupler/mesh.ts
@@ -16215,14 +16856,14 @@ function RigidCoupler({
 }
 
 // lib/models/rigidcoupler/register.tsx
-var model75 = defineModelRenderer({
+var model81 = defineModelRenderer({
   name: "rigidcoupler",
   schema: rigidCouplerModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(RigidCoupler, { ...props }),
   pads: "none"
 });
-function register75(registry2) {
-  registry2.register(model75);
+function register81(registry2) {
+  registry2.register(model81);
 }
 
 // lib/models/setscrew/mesh.ts
@@ -16337,14 +16978,14 @@ function SetScrew({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/setscrew/register.tsx
-var model76 = defineModelRenderer({
+var model82 = defineModelRenderer({
   name: "setscrew",
   schema: setscrewModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SetScrew, { ...props }),
   pads: "none"
 });
-function register76(registry2) {
-  registry2.register(model76);
+function register82(registry2) {
+  registry2.register(model82);
 }
 
 // lib/models/shaftcollar/mesh.ts
@@ -16376,14 +17017,14 @@ function ShaftCollar({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/shaftcollar/register.tsx
-var model77 = defineModelRenderer({
+var model83 = defineModelRenderer({
   name: "shaftcollar",
   schema: shaftCollarModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(ShaftCollar, { ...props }),
   pads: "none"
 });
-function register77(registry2) {
-  registry2.register(model77);
+function register83(registry2) {
+  registry2.register(model83);
 }
 
 // lib/mechanical/sheet-metal-mesh.ts
@@ -16428,7 +17069,7 @@ function createSheetMetalMesh(input) {
       throw new Error(`No ${hole.panel} panel on ${profile6}`);
   }
   for (const panel of panels) {
-    const length26 = panel === "base" ? baseLength : flangeHeight;
+    const length29 = 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)),
@@ -16437,17 +17078,17 @@ function createSheetMetalMesh(input) {
       maxV: Math.max(...outline2.map((p) => p.v))
     }));
     for (const [i, box] of bounds.entries()) {
-      if (box.minU <= -length26 / 2 || box.maxU >= length26 / 2 || box.minV <= -width10 / 2 || box.maxV >= width10 / 2)
+      if (box.minU <= -length29 / 2 || box.maxU >= length29 / 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: -length26 / 2, v: -width10 / 2 },
-      { u: length26 / 2, v: -width10 / 2 },
-      { u: length26 / 2, v: width10 / 2 },
-      { u: -length26 / 2, v: width10 / 2 }
+      { u: -length29 / 2, v: -width10 / 2 },
+      { u: length29 / 2, v: -width10 / 2 },
+      { u: length29 / 2, v: width10 / 2 },
+      { u: -length29 / 2, v: width10 / 2 }
     ];
     const loops = [outline, ...holes.map((hole) => [...hole].reverse())];
     const points = loops.flat();
@@ -16537,14 +17178,153 @@ function SheetMetal({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/sheetmetal/register.tsx
-var model78 = defineModelRenderer({
+var model84 = defineModelRenderer({
   name: "sheetmetal",
   schema: sheetMetalModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SheetMetal, { ...props }),
   pads: "none"
 });
-function register78(registry2) {
-  registry2.register(model78);
+function register84(registry2) {
+  registry2.register(model84);
+}
+
+// lib/models/slottedchannel/mesh.ts
+function quarterBend(radius, thickness) {
+  const outer = radius + thickness;
+  const center = outer;
+  const points = [];
+  for (let step = 0; step <= 48; step++) {
+    const angle = Math.PI + step * Math.PI / 96;
+    points.push(
+      step === 0 ? [0, center] : step === 48 ? [center, 0] : [
+        center + outer * Math.cos(angle),
+        center + outer * Math.sin(angle)
+      ]
+    );
+  }
+  if (radius === 0) points.push([center, center]);
+  else
+    for (let step = 0; step <= 48; step++) {
+      const angle = 3 * Math.PI / 2 - step * Math.PI / 96;
+      points.push(
+        step === 0 ? [center, thickness] : step === 48 ? [thickness, center] : [
+          center + radius * Math.cos(angle),
+          center + radius * Math.sin(angle)
+        ]
+      );
+    }
+  return points;
+}
+function obround(center, width10, length29) {
+  if (length29 === width10) return circularProfile(0, center, width10 / 2);
+  const r = width10 / 2, straight = (length29 - width10) / 2;
+  const points = [];
+  for (let step = 0; step <= 48; step++) {
+    const angle = step * Math.PI / 48;
+    points.push([r * Math.cos(angle), center + straight + r * Math.sin(angle)]);
+  }
+  for (let step = 0; step <= 48; step++) {
+    const angle = Math.PI + step * Math.PI / 48;
+    points.push([r * Math.cos(angle), center - straight + r * Math.sin(angle)]);
+  }
+  return points;
+}
+function createSlottedChannelMesh(input) {
+  const p = slottedChannelModelPropsSchema.parse(input);
+  const {
+    width: w,
+    height: h2,
+    thickness: t,
+    length: l,
+    innerRadius: r,
+    slotCount,
+    slotWidth,
+    slotLength,
+    pitch,
+    endOffset
+  } = p;
+  const tangent = r + t;
+  const holes = Array.from(
+    { length: slotCount },
+    (_, i) => obround(endOffset + i * pitch, slotWidth, slotLength)
+  );
+  const leg = [
+    [tangent, 0],
+    [h2, 0],
+    [h2, l],
+    [tangent, l]
+  ];
+  const bend = quarterBend(r, t);
+  const mesh = joinProfileMeshes([
+    extrudePlanarProfile({
+      outer: [
+        [tangent, 0],
+        [w - tangent, 0],
+        [w - tangent, l],
+        [tangent, l]
+      ],
+      holes: holes.map(
+        (loop) => loop.map(([u, v]) => [u + w / 2, v])
+      ),
+      start: 0,
+      end: t,
+      project: (u, v, d) => [u, d, v],
+      reverse: true,
+      skipWall: (a, b) => a[0] === tangent && b[0] === tangent || a[0] === w - tangent && b[0] === w - tangent
+    }),
+    extrudePlanarProfile({
+      outer: leg,
+      start: 0,
+      end: t,
+      project: (u, v, d) => [d, u, v],
+      skipWall: (a, b) => a[0] === tangent && b[0] === tangent
+    }),
+    extrudePlanarProfile({
+      outer: leg,
+      start: w - t,
+      end: w,
+      project: (u, v, d) => [d, u, v],
+      skipWall: (a, b) => a[0] === tangent && b[0] === tangent
+    }),
+    extrudePlanarProfile({
+      outer: bend,
+      start: 0,
+      end: l,
+      skipWall: (a, b) => a[0] === tangent && b[0] === tangent || a[1] === tangent && b[1] === tangent
+    }),
+    extrudePlanarProfile({
+      outer: bend.map(([u, v]) => [w - u, v]),
+      start: 0,
+      end: l,
+      skipWall: (a, b) => a[0] === w - tangent && b[0] === w - tangent || a[1] === tangent && b[1] === tangent
+    })
+  ]);
+  mesh.positions = mesh.positions.map(
+    (value, index) => value - (index % 3 === 0 ? w / 2 : index % 3 === 1 ? h2 / 2 : 0)
+  );
+  return mesh;
+}
+
+// lib/models/slottedchannel/SlottedChannel.tsx
+function createSlottedChannelGeom(input) {
+  return indexedMeshToGeom3(createSlottedChannelMesh(input));
+}
+function SlottedChannel({
+  color = "#8995a3",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createSlottedChannelGeom(props) }) });
+}
+
+// lib/models/slottedchannel/register.tsx
+var model85 = defineModelRenderer({
+  name: "slottedchannel",
+  schema: slottedChannelModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SlottedChannel, { ...props }),
+  pads: "none"
+});
+function register85(registry2) {
+  registry2.register(model85);
 }
 
 // lib/models/spacer/mesh.ts
@@ -16567,14 +17347,103 @@ function Spacer({ color = "#a18450", ...props }) {
 }
 
 // lib/models/spacer/register.tsx
-var model79 = defineModelRenderer({
+var model86 = defineModelRenderer({
   name: "spacer",
   schema: spacerModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(Spacer, { ...props }),
   pads: "none"
 });
-function register79(registry2) {
-  registry2.register(model79);
+function register86(registry2) {
+  registry2.register(model86);
+}
+
+// lib/models/splitgrommet/geometry.ts
+import earcut6 from "earcut";
+function createSplitGrommetMesh(input) {
+  const p = splitGrommetModelPropsSchema.parse(input), d = getSplitGrommetDimensions(p);
+  if (Math.min(
+    d.flangeThickness,
+    d.minimumWallThickness,
+    p.grooveDepth,
+    p.grooveWidth,
+    p.splitWidth
+  ) <= Math.max(...d.size) * 1e-10)
+    throw new Error("splitgrommet dimensions exceed mesh resolution limits");
+  const section = [
+    [p.innerDiameter / 2, d.bottomZ],
+    [p.outerDiameter / 2, d.bottomZ],
+    [p.outerDiameter / 2, d.grooveStartZ],
+    [d.grooveRootDiameter / 2, d.grooveStartZ],
+    [d.grooveRootDiameter / 2, d.grooveEndZ],
+    [p.outerDiameter / 2, d.grooveEndZ],
+    [p.outerDiameter / 2, d.topZ],
+    [p.innerDiameter / 2, d.topZ]
+  ];
+  const segments = 128, count = section.length;
+  const positions = [], indices = [];
+  for (let i = 0; i <= segments; i++)
+    for (const [radius, z] of section) {
+      const alpha = Math.asin(p.splitWidth / (2 * radius));
+      const stops = [
+        alpha,
+        Math.PI / 2,
+        Math.PI,
+        3 * Math.PI / 2,
+        2 * Math.PI - alpha
+      ];
+      const arc = Math.min(3, Math.floor(i / 32)), fraction = (i - arc * 32) / 32;
+      const angle = stops[arc] + (stops[arc + 1] - stops[arc]) * fraction;
+      positions.push(
+        i === 0 || i === segments ? Math.sqrt(radius ** 2 - (p.splitWidth / 2) ** 2) : radius * Math.cos(angle),
+        i === 0 ? d.slitMaxY : i === segments ? d.slitMinY : radius * Math.sin(angle),
+        z
+      );
+    }
+  for (let i = 0; i < segments; i++)
+    for (let j = 0; j < count; j++) {
+      const next = (j + 1) % count;
+      const a = i * count + j, b = (i + 1) * count + j, c = (i + 1) * count + next, e = i * count + next;
+      indices.push(a, b, c, a, c, e);
+    }
+  const slitSection = section.flatMap(([radius, z]) => [
+    Math.sqrt(radius ** 2 - (p.splitWidth / 2) ** 2),
+    z
+  ]);
+  const caps = earcut6(slitSection);
+  for (let i = 0; i < caps.length; i += 3) {
+    const a = caps[i], b = caps[i + 1], c = caps[i + 2];
+    indices.push(
+      a,
+      b,
+      c,
+      segments * count + a,
+      segments * count + c,
+      segments * count + b
+    );
+  }
+  return { positions, indices };
+}
+function createSplitGrommetGeom(input) {
+  return indexedMeshToGeom3(createSplitGrommetMesh(input));
+}
+
+// lib/models/splitgrommet/SplitGrommet.tsx
+function SplitGrommet({
+  color = "#394553",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createSplitGrommetGeom(props) }) });
+}
+
+// lib/models/splitgrommet/register.tsx
+var model87 = defineModelRenderer({
+  name: "splitgrommet",
+  schema: splitGrommetModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SplitGrommet, { ...props }),
+  pads: "none"
+});
+function register87(registry2) {
+  registry2.register(model87);
 }
 
 // lib/models/splitwasher/mesh.ts
@@ -16637,14 +17506,14 @@ function SplitWasher({ color = "#929ba6", ...props }) {
 }
 
 // lib/models/splitwasher/register.tsx
-var model80 = defineModelRenderer({
+var model88 = defineModelRenderer({
   name: "splitwasher",
   schema: splitWasherModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SplitWasher, { ...props }),
   pads: "none"
 });
-function register80(registry2) {
-  registry2.register(model80);
+function register88(registry2) {
+  registry2.register(model88);
 }
 
 // lib/SpurGear.tsx
@@ -16656,14 +17525,14 @@ function SpurGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/spurgear/register.tsx
-var model81 = defineModelRenderer({
+var model89 = defineModelRenderer({
   name: "spurgear",
   schema: spurGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SpurGear, { ...props }),
   pads: "none"
 });
-function register81(registry2) {
-  registry2.register(model81);
+function register89(registry2) {
+  registry2.register(model89);
 }
 
 // lib/models/threadedrod/mesh.ts
@@ -16753,14 +17622,14 @@ function ThreadedRod({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/threadedrod/register.tsx
-var model82 = defineModelRenderer({
+var model90 = defineModelRenderer({
   name: "threadedrod",
   schema: threadedRodModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(ThreadedRod, { ...props }),
   pads: "none"
 });
-function register82(registry2) {
-  registry2.register(model82);
+function register90(registry2) {
+  registry2.register(model90);
 }
 
 // lib/models/torsionspring/mesh.ts
@@ -16849,20 +17718,110 @@ function TorsionSpring({
 }
 
 // lib/models/torsionspring/register.tsx
-var model83 = defineModelRenderer({
+var model91 = defineModelRenderer({
   name: "torsionspring",
   schema: torsionSpringModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(TorsionSpring, { ...props }),
   pads: "none"
 });
-function register83(registry2) {
-  registry2.register(model83);
+function register91(registry2) {
+  registry2.register(model91);
+}
+
+// lib/models/tslotcoverstrip/geometry.ts
+import jscad14 from "@jscad/modeling";
+var {
+  primitives: primitives7,
+  extrusions: extrusions7,
+  booleans: booleans3,
+  geometries: geometries7,
+  modifiers: modifiers7,
+  measurements: measurements7
+} = jscad14;
+var generalize8 = modifiers7.generalize;
+function createTSlotCoverStripGeom(input) {
+  const p = tSlotCoverStripModelPropsSchema.parse(input);
+  const w = p.width / 2;
+  const s = p.stemWidth / 2;
+  const b = p.barbWidth / 2;
+  const tip = -p.stemHeight;
+  const beadTop = tip + p.barbHeight;
+  const outline = primitives7.polygon({
+    points: [
+      [-w, 0],
+      [-s, 0],
+      [-s, beadTop],
+      [-b, beadTop],
+      [-b, tip],
+      [b, tip],
+      [b, beadTop],
+      [s, beadTop],
+      [s, 0],
+      [w, 0],
+      [w, p.thickness],
+      [-w, p.thickness]
+    ]
+  });
+  return extrusions7.extrudeLinear({ height: p.length }, outline);
+}
+function createTSlotCoverStripMesh(input) {
+  const geom = generalize8(
+    { snap: false, triangulate: true },
+    createTSlotCoverStripGeom(input)
+  );
+  const epsilon = Math.max(...measurements7.measureDimensions(geom)) * 1e-10;
+  const positions = [];
+  const indices = [];
+  const lookup = /* @__PURE__ */ new Map();
+  const vertex = (v) => {
+    const key = v.map((x) => Math.round(x / epsilon)).join(",");
+    let index = lookup.get(key);
+    if (index === void 0) {
+      index = positions.length / 3;
+      positions.push(...v);
+      lookup.set(key, index);
+    }
+    return index;
+  };
+  for (const poly of geometries7.geom3.toPolygons(geom)) {
+    for (let i = 1; i < poly.vertices.length - 1; i++) {
+      const a = poly.vertices[0], b = poly.vertices[i], c = poly.vertices[i + 1];
+      const u = b.map((x, j) => x - a[j]), v = c.map((x, j) => x - a[j]);
+      const area = Math.hypot(
+        u[1] * v[2] - u[2] * v[1],
+        u[2] * v[0] - u[0] * v[2],
+        u[0] * v[1] - u[1] * v[0]
+      );
+      if (area > epsilon * epsilon)
+        indices.push(vertex(a), vertex(b), vertex(c));
+    }
+  }
+  return { positions, indices };
+}
+
+// lib/models/tslotcoverstrip/TSlotCoverStrip.tsx
+function TSlotCoverStrip({
+  color = "#465564",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createTSlotCoverStripGeom(props) }) });
+}
+
+// lib/models/tslotcoverstrip/register.tsx
+var model92 = defineModelRenderer({
+  name: "tslotcoverstrip",
+  schema: tSlotCoverStripModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(TSlotCoverStrip, { ...props }),
+  pads: "none"
+});
+function register92(registry2) {
+  registry2.register(model92);
 }
 
 // lib/models/tslotextrusion/mesh.ts
 function createTSlotExtrusionMesh(input = {}) {
   const props = tSlotExtrusionModelPropsSchema.parse(input);
-  const { width: width10, height: height10, length: length26, cornerRadius, lipThickness, pocketDepth } = props;
+  const { width: width10, height: height10, length: length29, cornerRadius, lipThickness, pocketDepth } = props;
   const slot = props.slotWidth / 2;
   const pocket = props.pocketWidth / 2;
   const depth = lipThickness + pocketDepth;
@@ -16899,7 +17858,7 @@ function createTSlotExtrusionMesh(input = {}) {
     outer,
     holes: props.boreDiameter > 0 ? [circularProfile(0, 0, props.boreDiameter / 2)] : [],
     start: 0,
-    end: length26
+    end: length29
   });
 }
 
@@ -16915,14 +17874,14 @@ function TSlotExtrusion({
 }
 
 // lib/models/tslotextrusion/register.tsx
-var model84 = defineModelRenderer({
+var model93 = defineModelRenderer({
   name: "tslotextrusion",
   schema: tSlotExtrusionModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(TSlotExtrusion, { ...props }),
   pads: "none"
 });
-function register84(registry2) {
-  registry2.register(model84);
+function register93(registry2) {
+  registry2.register(model93);
 }
 
 // lib/models/tslotgusset/mesh.ts
@@ -16968,14 +17927,14 @@ function TSlotGusset({ color = "#8995a3", ...props }) {
 }
 
 // lib/models/tslotgusset/register.tsx
-var model85 = defineModelRenderer({
+var model94 = defineModelRenderer({
   name: "tslotgusset",
   schema: tSlotGussetModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(TSlotGusset, { ...props }),
   pads: "none"
 });
-function register85(registry2) {
-  registry2.register(model85);
+function register94(registry2) {
+  registry2.register(model94);
 }
 
 // lib/models/tslotinsidecorner/mesh.ts
@@ -17049,18 +18008,18 @@ function TSlotInsideCorner({
 }
 
 // lib/models/tslotinsidecorner/register.tsx
-var model86 = defineModelRenderer({
+var model95 = defineModelRenderer({
   name: "tslotinsidecorner",
   schema: tSlotInsideCornerModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(TSlotInsideCorner, { ...props }),
   pads: "none"
 });
-function register86(registry2) {
-  registry2.register(model86);
+function register95(registry2) {
+  registry2.register(model95);
 }
 
 // lib/mechanical/worm-gear-mesh.ts
-import earcut6 from "earcut";
+import earcut7 from "earcut";
 var createWormGearMesh = (input) => {
   const props = wormGearModelPropsSchema.parse(input);
   const { outsideDiameter, rootDiameter, axialPitch, lead, toothThickness } = getWormGearDimensions(props);
@@ -17213,7 +18172,7 @@ var createWormGearMesh = (input) => {
         positions[vertex * 3],
         positions[vertex * 3 + 1]
       ]);
-      const triangles = earcut6(flat, [count], 2);
+      const triangles = earcut7(flat, [count], 2);
       for (let index = 0; index < triangles.length; index += 3) {
         const a = vertices[triangles[index]];
         const b = vertices[triangles[index + 1]];
@@ -17241,23 +18200,96 @@ function WormGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/wormgear/register.tsx
-var model87 = defineModelRenderer({
+var model96 = defineModelRenderer({
   name: "wormgear",
   schema: wormGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(WormGear, { ...props }),
   pads: "none"
 });
-function register87(registry2) {
-  registry2.register(model87);
+function register96(registry2) {
+  registry2.register(model96);
+}
+
+// lib/models/zeebar/mesh.ts
+function filletedOutline(points, radii) {
+  const outline = [];
+  for (let i = 0; i < points.length; i++) {
+    const a = points[(i + points.length - 1) % points.length], b = points[i], c = points[(i + 1) % points.length], r = radii[i];
+    if (r === 0) {
+      outline.push(b);
+      continue;
+    }
+    const al = Math.hypot(a[0] - b[0], a[1] - b[1]), cl = Math.hypot(c[0] - b[0], c[1] - b[1]);
+    const u = [(a[0] - b[0]) / al, (a[1] - b[1]) / al], v = [(c[0] - b[0]) / cl, (c[1] - b[1]) / cl];
+    const center = [
+      b[0] + r * (u[0] + v[0]),
+      b[1] + r * (u[1] + v[1])
+    ];
+    const start = Math.atan2(
+      b[1] + r * u[1] - center[1],
+      b[0] + r * u[0] - center[0]
+    );
+    const turn = u[1] * v[0] - u[0] * v[1] > 0 ? 1 : -1;
+    for (let step = 0; step <= 48; step++) {
+      const angle = start + turn * step * Math.PI / 96;
+      outline.push(
+        step === 0 ? [b[0] + r * u[0], b[1] + r * u[1]] : step === 48 ? [b[0] + r * v[0], b[1] + r * v[1]] : [
+          center[0] + r * Math.cos(angle),
+          center[1] + r * Math.sin(angle)
+        ]
+      );
+    }
+  }
+  return outline;
+}
+function createZeeBarMesh(input) {
+  const p = zeeBarModelPropsSchema.parse(input);
+  const {
+    height: h2,
+    upperWidth: upper,
+    lowerWidth: lower,
+    thickness: t,
+    bendRadius: r,
+    length: l
+  } = p;
+  const w = upper + lower - t, outer = r + t;
+  const outline = filletedOutline(
+    [
+      [0, 0],
+      [lower, 0],
+      [lower, h2 - t],
+      [w, h2 - t],
+      [w, h2],
+      [lower - t, h2],
+      [lower - t, t],
+      [0, t]
+    ],
+    [0, outer, r, 0, 0, outer, r, 0]
+  ).map(([x, y]) => [x - w / 2, y - h2 / 2]);
+  return extrudePlanarProfile({ outer: outline, start: 0, end: l });
+}
+
+// lib/models/zeebar/ZeeBar.tsx
+function createZeeBarGeom(input) {
+  return indexedMeshToGeom3(createZeeBarMesh(input));
+}
+function ZeeBar({ color = "#8995a3", ...props }) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createZeeBarGeom(props) }) });
+}
+
+// lib/models/zeebar/register.tsx
+var model97 = defineModelRenderer({
+  name: "zeebar",
+  schema: zeeBarModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(ZeeBar, { ...props }),
+  pads: "none"
+});
+function register97(registry2) {
+  registry2.register(model97);
 }
 
 // lib/generated/model-renderers.ts
 function registerAllModelRenderers(registry2) {
-  register45(registry2);
-  register46(registry2);
-  register47(registry2);
-  register48(registry2);
-  register49(registry2);
   register50(registry2);
   register51(registry2);
   register52(registry2);
@@ -17296,6 +18328,16 @@ function registerAllModelRenderers(registry2) {
   register85(registry2);
   register86(registry2);
   register87(registry2);
+  register88(registry2);
+  register89(registry2);
+  register90(registry2);
+  register91(registry2);
+  register92(registry2);
+  register93(registry2);
+  register94(registry2);
+  register95(registry2);
+  register96(registry2);
+  register97(registry2);
 }
 
 // lib/default-model-registry.ts
@@ -17637,7 +18679,7 @@ import { fp as fp10 } from "@tscircuit/footprinter";
 var ChipBody = ({
   center,
   width: width10,
-  length: length26,
+  length: length29,
   height: height10,
   heightAboveSurface: heightAboveSurface2 = 0.15,
   color = "#555",
@@ -17654,24 +18696,24 @@ var ChipBody = ({
 }) => {
   const straightHeight = height10 * straightHeightRatio;
   const taperHeight = height10 - straightHeight;
-  const taperInset = Math.min(width10, length26) * taperRatio;
+  const taperInset = Math.min(width10, length29) * taperRatio;
   const faceWidth = Math.max(width10 - taperInset, width10 * faceRatio);
-  const faceLength = Math.max(length26 - taperInset, length26 * faceRatio);
-  const defaultNotchRadius = Math.min(width10, length26) * 0.12;
+  const faceLength = Math.max(length29 - taperInset, length29 * faceRatio);
+  const defaultNotchRadius = Math.min(width10, length29) * 0.12;
   const actualNotchRadius = notchRadius ?? defaultNotchRadius;
   const defaultNotchPosition = {
     x: 0,
-    y: length26 / 2 - actualNotchRadius * 0.25,
+    y: length29 / 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, length26, 0.01] }) })
+      /* @__PURE__ */ jsx(Translate, { z: straightHeight, children: /* @__PURE__ */ jsx(Cuboid, { size: [width10, length29, 0.01] }) })
     ] }),
     /* @__PURE__ */ jsxs(Hull, { children: [
-      /* @__PURE__ */ jsx(Translate, { z: straightHeight, children: /* @__PURE__ */ jsx(Cuboid, { size: [width10, length26, 0.01] }) }),
+      /* @__PURE__ */ jsx(Translate, { z: straightHeight, children: /* @__PURE__ */ jsx(Cuboid, { size: [width10, length29, 0.01] }) }),
       /* @__PURE__ */ jsx(Translate, { z: straightHeight + taperHeight, children: /* @__PURE__ */ jsx(Cuboid, { size: [faceWidth, faceLength, 0.01] }) })
     ] })
   ] });
@@ -17688,7 +18730,7 @@ var ChipBody = ({
   let finalBody = body;
   if (chamferSize > 0) {
     const xOffset = width10 / 2;
-    const yOffset = length26 / 2;
+    const yOffset = length29 / 2;
     finalBody = /* @__PURE__ */ jsxs(Subtract, { children: [
       body,
       chamferCutout(xOffset, yOffset),
@@ -17718,8 +18760,8 @@ function getExpandedStroke(strokeInput, width10) {
   function getNormal(p1, p2) {
     const dx = p2.x - p1.x;
     const dy = p2.y - p1.y;
-    const length26 = Math.sqrt(dx * dx + dy * dy);
-    return { x: -dy / length26, y: dx / length26 };
+    const length29 = Math.sqrt(dx * dx + dy * dy);
+    return { x: -dy / length29, y: dx / length29 };
   }
   function addPoint(point, normal, factor) {
     const newPoint = {
@@ -19387,11 +20429,11 @@ var FemaleHeaderRow = ({
 // lib/PushButton.tsx
 var PushButton = ({
   width: width10,
-  length: length26,
+  length: length29,
   innerDiameter = 1
 }) => {
   const bodyWidth = width10;
-  const bodyLength10 = length26;
+  const bodyLength10 = length29;
   const bodyHeight = width10 * 0.7;
   const legWidth = innerDiameter / 2.5;
   return /* @__PURE__ */ jsxs(Fragment2, { children: [
@@ -23325,12 +24367,12 @@ var JstSh = ({ footprint = "jst6_sh" }) => {
 };
 
 // lib/Crystal.tsx
-var getTerminalPoints = ([centerX, centerY], width10, length26, chamfer, isPinOne) => {
+var getTerminalPoints = ([centerX, centerY], width10, length29, chamfer, isPinOne) => {
   const xDirection = Math.sign(centerX);
   const yDirection = Math.sign(centerY);
   const halfWidth = width10 / 2;
-  const halfLength = length26 / 2;
-  const innerChamfer = isPinOne ? Math.min(0.32, length26 * 0.36) : 0;
+  const halfLength = length29 / 2;
+  const innerChamfer = isPinOne ? Math.min(0.32, length29 * 0.36) : 0;
   const outerChamfer = Math.min(chamfer, halfWidth, halfLength);
   const points = [
     [-halfWidth, -halfLength],
@@ -23350,13 +24392,13 @@ var getTerminalPoints = ([centerX, centerY], width10, length26, chamfer, isPinOn
 };
 var getRoundedRectProfile = ({
   width: width10,
-  length: length26,
+  length: length29,
   radius,
   height: height10,
   z
 }) => {
   const x = width10 / 2 - radius;
-  const y = length26 / 2 - radius;
+  const y = length29 / 2 - radius;
   return [
     [-x, -y],
     [x, -y],
@@ -23500,12 +24542,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 length26 = isUpperRow ? topPadLength : bottomPadLength;
+    const length29 = isUpperRow ? topPadLength : bottomPadLength;
     return {
       index,
       x: contactStartX + index * pitch,
       y,
-      length: length26
+      length: length29
     };
   });
   const contactMaxY = Math.max(
@@ -24057,7 +25099,7 @@ var Led2835 = ({
 };
 
 // lib/RJ45.tsx
-var range2 = (length26) => Array.from({ length: length26 }, (_, index) => index);
+var range2 = (length29) => Array.from({ length: length29 }, (_, index) => index);
 var RJ45 = ({
   bodyWidth = 16.26,
   bodyDepth = 15.88,
@@ -24877,10 +25919,10 @@ var SOT143 = ({ footprint = "sot143" }) => {
 var Footprinter3d = ({ footprint }) => {
   const modelFn = mp.string(footprint.split("_", 1)[0]).params().fn;
   if (mp.getModelNames().includes(modelFn)) {
-    const model88 = mp.string(footprint).json();
-    const renderer = modelRendererRegistry.get(model88.fn);
+    const model98 = mp.string(footprint).json();
+    const renderer = modelRendererRegistry.get(model98.fn);
     if (renderer) {
-      return renderer.render(model88);
+      return renderer.render(model98);
     }
   }
   let normalizedFootprint = footprint;
@@ -25564,7 +26606,7 @@ var toVec3 = (v) => {
 };
 function renderNode(node, colorCtx, renderCtx) {
   const {
-    jscad: { primitives: primitives7, booleans: booleans3, hulls, geometries: geometries7, extrusions: extrusions7, transforms }
+    jscad: { primitives: primitives8, booleans: booleans4, hulls, geometries: geometries8, extrusions: extrusions8, transforms }
   } = renderCtx;
   if (node == null || node === false) return [];
   if (Array.isArray(node))
@@ -25629,9 +26671,9 @@ function renderNode(node, colorCtx, renderCtx) {
     const geoms = entries.map((g) => g.geom);
     if (geoms.length === 0) return [];
     let geom;
-    if (type === Union) geom = booleans3.union(geoms);
+    if (type === Union) geom = booleans4.union(geoms);
     else if (type === Subtract)
-      geom = booleans3.subtract(geoms[0], geoms.slice(1));
+      geom = booleans4.subtract(geoms[0], geoms.slice(1));
     else geom = hulls.hull(geoms);
     return [
       {
@@ -25646,7 +26688,7 @@ function renderNode(node, colorCtx, renderCtx) {
   }
   if (type === Polygon) {
     const points = props?.points ?? [];
-    const g2 = geometries7.geom2.fromPoints(points);
+    const g2 = geometries8.geom2.fromPoints(points);
     return [{ geom: g2, color: colorCtx ?? props?.color }];
   }
   if (type === ExtrudeLinear) {
@@ -25655,9 +26697,9 @@ function renderNode(node, colorCtx, renderCtx) {
     );
     const geoms2 = entries.map((g) => g.geom);
     if (geoms2.length === 0) return [];
-    const base2 = geoms2.length > 1 ? booleans3.union(geoms2) : geoms2[0];
+    const base2 = geoms2.length > 1 ? booleans4.union(geoms2) : geoms2[0];
     const height10 = props?.height ?? props?.h ?? 1;
-    let g3 = extrusions7.extrudeLinear({ height: height10 }, base2);
+    let g3 = extrusions8.extrudeLinear({ height: height10 }, base2);
     if (g3.polygons) {
       for (const poly of g3.polygons) {
         if (!poly.plane || !poly.vertices || poly.vertices.length < 3) continue;
@@ -25678,32 +26720,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 = primitives7.cuboid({ size, center });
+      g = primitives8.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 = primitives7.cube({ size, center });
+      g = primitives8.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 = primitives7.cylinder({ height: height10, radius, center });
+      g = primitives8.cylinder({ height: height10, radius, center });
     } else if (type === Sphere) {
       const radius = props?.radius ?? 1;
       const center = props?.center ?? [0, 0, 0];
-      g = primitives7.sphere({ radius, center });
+      g = primitives8.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 = primitives7.roundedCylinder({ height: height10, radius, roundRadius, center });
+      g = primitives8.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 = primitives7.roundedCuboid({ size, roundRadius, center });
+      g = primitives8.roundedCuboid({ size, roundRadius, center });
     }
     return [{ geom: g, color: colorCtx ?? props?.color }];
   }
@@ -25713,10 +26755,10 @@ function renderNode(node, colorCtx, renderCtx) {
   }
   return (children ?? []).flatMap((c) => renderNode(c, colorCtx, renderCtx));
 }
-function render(root, jscad14) {
-  const geometries7 = renderNode(root, void 0, { jscad: jscad14 });
+function render(root, jscad15) {
+  const geometries8 = renderNode(root, void 0, { jscad: jscad15 });
   return {
-    geometries: geometries7.map(
+    geometries: geometries8.map(
       (entry) => entry.material ? { ...entry, geom: { ...entry.geom, material: entry.material } } : entry
     )
   };
@@ -25806,25 +26848,25 @@ function convertCSGToThreeGeom(csg) {
 }
 
 // lib/vanilla/index.ts
-function getJscadModelForFootprint(footprint, jscad14) {
+function getJscadModelForFootprint(footprint, jscad15) {
   const vnode = h(Footprinter3d, { footprint });
-  return render(vnode, jscad14);
+  return render(vnode, jscad15);
 }
-function getJscadModelForFootprintWithPads(footprint, jscad14) {
+function getJscadModelForFootprintWithPads(footprint, jscad15) {
   const vnode = h(
     Fragment,
     {},
     h(Footprinter3d, { footprint }),
     h(ExtrudedPads, { footprint })
   );
-  return render(vnode, jscad14);
+  return render(vnode, jscad15);
 }
-function createJSCADRenderer(jscad14) {
+function createJSCADRenderer(jscad15) {
   function createJSCADRoot(container) {
     return {
       render(element) {
-        const { geometries: geometries7 } = render(element, jscad14);
-        container.splice(0, container.length, ...geometries7);
+        const { geometries: geometries8 } = render(element, jscad15);
+        container.splice(0, container.length, ...geometries8);
       }
     };
   }
@@ -25863,20 +26905,25 @@ export {
   PlainBushing,
   PushFitPlug,
   RectangularBar,
+  RectangularGasket,
   RectangularTube,
   RigidCoupler,
   SetScrew,
   ShaftCollar,
   SheetMetal,
+  SlottedChannel,
   Spacer,
+  SplitGrommet,
   SplitWasher,
   SpurGear,
+  TSlotCoverStrip,
   TSlotExtrusion,
   TSlotGusset,
   TSlotInsideCorner,
   ThreadedRod,
   TorsionSpring,
   WormGear,
+  ZeeBar,
   convertCSGToThreeGeom,
   createAngleBarGeom,
   createAngleBarMesh,
@@ -25935,6 +26982,8 @@ export {
   createPushFitPlugMesh,
   createRectangularBarGeom,
   createRectangularBarMesh,
+  createRectangularGasketGeom,
+  createRectangularGasketMesh,
   createRectangularTubeGeom,
   createRectangularTubeMesh,
   createRigidCouplerGeom,
@@ -25945,12 +26994,18 @@ export {
   createShaftCollarMesh,
   createSheetMetalGeom,
   createSheetMetalMesh,
+  createSlottedChannelGeom,
+  createSlottedChannelMesh,
   createSpacerGeom,
   createSpacerMesh,
+  createSplitGrommetGeom,
+  createSplitGrommetMesh,
   createSplitWasherGeom,
   createSplitWasherMesh,
   createSpurGearGeom,
   createSpurGearMesh,
+  createTSlotCoverStripGeom,
+  createTSlotCoverStripMesh,
   createTSlotExtrusionGeom,
   createTSlotExtrusionMesh,
   createTSlotGussetGeom,
@@ -25963,6 +27018,8 @@ export {
   createTorsionSpringMesh,
   createWormGearGeom,
   createWormGearMesh,
+  createZeeBarGeom,
+  createZeeBarMesh,
   getJscadModelForFootprint,
   getJscadModelForFootprintWithPads,
   h