jscad-electronics 0.0.236 → 0.0.238

package/dist/vanilla.js

@@ -24,7 +24,7 @@ function h(type, props, ...restChildren) {
   };
 }
 
-// .model-contracts/generations/fa75ee0265d6d666dfb181dbec270fd94d15a3b5-v2/node_modules/zod/v3/external.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/node_modules/zod/v3/external.js
 var external_exports = {};
 __export(external_exports, {
   BRAND: () => BRAND,
@@ -136,7 +136,7 @@ __export(external_exports, {
   void: () => voidType
 });
 
-// .model-contracts/generations/fa75ee0265d6d666dfb181dbec270fd94d15a3b5-v2/node_modules/zod/v3/helpers/util.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/node_modules/zod/v3/helpers/util.js
 var util;
 (function(util2) {
   util2.assertEqual = (_) => {
@@ -270,7 +270,7 @@ var getParsedType = (data) => {
   }
 };
 
-// .model-contracts/generations/fa75ee0265d6d666dfb181dbec270fd94d15a3b5-v2/node_modules/zod/v3/ZodError.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/node_modules/zod/v3/ZodError.js
 var ZodIssueCode = util.arrayToEnum([
   "invalid_type",
   "invalid_literal",
@@ -388,7 +388,7 @@ ZodError.create = (issues) => {
   return error;
 };
 
-// .model-contracts/generations/fa75ee0265d6d666dfb181dbec270fd94d15a3b5-v2/node_modules/zod/v3/locales/en.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/node_modules/zod/v3/locales/en.js
 var errorMap = (issue, _ctx) => {
   let message;
   switch (issue.code) {
@@ -491,7 +491,7 @@ var errorMap = (issue, _ctx) => {
 };
 var en_default = errorMap;
 
-// .model-contracts/generations/fa75ee0265d6d666dfb181dbec270fd94d15a3b5-v2/node_modules/zod/v3/errors.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/node_modules/zod/v3/errors.js
 var overrideErrorMap = en_default;
 function setErrorMap(map) {
   overrideErrorMap = map;
@@ -500,7 +500,7 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 
-// .model-contracts/generations/fa75ee0265d6d666dfb181dbec270fd94d15a3b5-v2/node_modules/zod/v3/helpers/parseUtil.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
   const { data, path, errorMaps, issueData } = params;
   const fullPath = [...path, ...issueData.path || []];
@@ -610,14 +610,14 @@ var isDirty = (x) => x.status === "dirty";
 var isValid = (x) => x.status === "valid";
 var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
 
-// .model-contracts/generations/fa75ee0265d6d666dfb181dbec270fd94d15a3b5-v2/node_modules/zod/v3/helpers/errorUtil.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/node_modules/zod/v3/helpers/errorUtil.js
 var errorUtil;
 (function(errorUtil2) {
   errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
   errorUtil2.toString = (message) => typeof message === "string" ? message : message?.message;
 })(errorUtil || (errorUtil = {}));
 
-// .model-contracts/generations/fa75ee0265d6d666dfb181dbec270fd94d15a3b5-v2/node_modules/zod/v3/types.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
   constructor(parent, value, path, key) {
     this._cachedPath = [];
@@ -4065,7 +4065,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// .model-contracts/generations/fa75ee0265d6d666dfb181dbec270fd94d15a3b5-v2/node_modules/@tscircuit/mm/dist/index.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/node_modules/@tscircuit/mm/dist/index.js
 var unitToMm = {
   in: 25.4,
   inch: 25.4,
@@ -4092,7 +4092,7 @@ var mm = (n) => {
   throw new Error(`Unsupported unit: ${unit}`);
 };
 
-// .model-contracts/generations/fa75ee0265d6d666dfb181dbec270fd94d15a3b5-v2/index.js
+// .model-contracts/generations/ad649bc7a403a3e6e9b12ce32ac0b3d0fa61c6bf-v2/index.js
 function normalizeNemaMotorModelString(value) {
   if (!/^nema(?:8|17|23|34)(?:_|$)/i.test(value)) return value;
   return value.replace(/(^|_)jst([0-9]+)_(ph|sh)(?=_|$)/gi, "$1jst$3$2").replace(/(^|_)jst[_-](ph|sh)[_-]([0-9]+)(?=_|$)/gi, "$1jst$2$3").replace(/(^|_)none(?=_|$)/gi, "$1nowires").replace(/(^|_)stubs(?=_|$)/gi, "$1wirestubs");
@@ -4148,36 +4148,6 @@ var parseModelStringParams = (definition) => {
   params.string = normalizedDefinition;
   return params;
 };
-function expandModelStringFlags(value, flags10) {
-  return splitModelStringTokens(value).map(
-    (token, index) => index > 0 && Object.hasOwn(flags10, token.toLowerCase()) ? flags10[token.toLowerCase()] : token
-  ).join("_");
-}
-function normalizeModelStringFlags(value, flags10, parse, omittedFlags) {
-  const tokens = splitModelStringTokens(value);
-  if (!tokens.slice(1).some((token) => Object.hasOwn(flags10, token.toLowerCase())))
-    return value;
-  const expanded = expandModelStringFlags(value, flags10);
-  parse(parseModelStringParams(expanded));
-  const preferred = new Map(
-    Object.entries(flags10).map(([flag, selector]) => [selector, flag])
-  );
-  const omitted = new Set(omittedFlags.map((flag) => flags10[flag]));
-  return splitModelStringTokens(expanded).flatMap((token, index) => {
-    if (index === 0) return [token.toLowerCase()];
-    const lower = token.toLowerCase();
-    if (omitted.has(lower)) return [];
-    return [preferred.get(lower) ?? token];
-  }).join("_");
-}
-var stringFlags = {
-  hex: "drive(hex)",
-  fullthread: "thread(full)",
-  lefthanded: "threadhand(left)",
-  righthanded: "threadhand(right)",
-  male: "threadgender(male)"
-};
-var omittedStringFlags = ["righthanded", "male"];
 function defineModel(model552) {
   return model552;
 }
@@ -4324,11 +4294,11 @@ var hexBoltModelPropsShape = {
   iso4017: external_exports.literal(true).default(true),
   metricSize: hexBoltMetricSizeSchema,
   length: positiveModelLengthSchema2,
-  thread: external_exports.literal("full").default("full"),
-  drive: external_exports.literal("hex").default("hex"),
-  threadHand: external_exports.enum(["right", "left"]).default("right"),
+  fullThread: external_exports.literal(true).default(true),
+  hex: external_exports.literal(true).default(true),
+  leftHanded: external_exports.boolean().default(false),
   threadClass: external_exports.literal("6g").default("6g"),
-  threadGender: external_exports.literal("male").default("male"),
+  male: external_exports.literal(true).default(true),
   showThreads: external_exports.boolean().default(true),
   diameter: positiveModelLengthSchema2.optional(),
   threadPitch: positiveModelLengthSchema2.optional(),
@@ -4373,11 +4343,7 @@ var aliases = {
   metricsize: "metricSize",
   l: "length",
   length: "length",
-  thread: "thread",
-  drive: "drive",
-  threadhand: "threadHand",
   threadclass: "threadClass",
-  threadgender: "threadGender",
   diameter: "diameter",
   threadpitch: "threadPitch",
   headacrossflats: "headAcrossFlats",
@@ -4395,19 +4361,18 @@ var aliases = {
   headh: "headHeight",
   af: "headAcrossFlats"
 };
-var selectors = /* @__PURE__ */ new Set([
-  "thread",
-  "drive",
-  "threadHand",
-  "threadClass",
-  "threadGender"
-]);
+var selectors = /* @__PURE__ */ new Set(["threadClass"]);
+var booleanFlags = {
+  hex: { property: "hex", value: true },
+  fullthread: { property: "fullThread", value: true },
+  male: { property: "male", value: true },
+  lefthanded: { property: "leftHanded", value: true },
+  righthanded: { property: "leftHanded", value: false }
+};
 var parseHexBoltModelParams = (raw) => {
   if (raw.fn !== "hexbolt")
     throw new Error(`Expected hexbolt params, got "${raw.fn}"`);
-  const [root, ...tokens] = splitModelStringTokens(
-    expandModelStringFlags(raw.string, stringFlags)
-  );
+  const [root, ...tokens] = splitModelStringTokens(raw.string);
   if (root?.toLowerCase() !== "hexbolt")
     throw new Error("The hexbolt function does not accept an inline value");
   const props = {};
@@ -4423,13 +4388,17 @@ var parseHexBoltModelParams = (raw) => {
     const value = match?.[2];
     let property;
     let parsed;
-    if (key === "threads" || key === "nothreads") {
+    if (key && Object.hasOwn(booleanFlags, key)) {
+      if (value !== "") throw new Error(`Flag "${key}" does not accept a value`);
+      property = booleanFlags[key].property;
+      parsed = booleanFlags[key].value;
+    } else if (key === "threads" || key === "nothreads") {
       if (value !== "")
         throw new Error(`Token "${key}" does not accept a value`);
       property = "showThreads";
       parsed = key === "threads";
     } else {
-      property = key ? aliases[key] ?? "" : "";
+      property = key && Object.hasOwn(aliases, key) ? aliases[key] : "";
       if (!property || !value)
         throw new Error(`Unknown or missing hexbolt token "${token}"`);
       if (selectors.has(property)) {
@@ -4461,13 +4430,7 @@ var parseHexBoltModelParams = (raw) => {
 var model = defineModel({
   name: "hexbolt",
   schema: hexBoltModelDefinitionSchema,
-  parse: parseHexBoltModelParams,
-  normalizeString: (value) => normalizeModelStringFlags(
-    value,
-    stringFlags,
-    parseHexBoltModelParams,
-    omittedStringFlags
-  )
+  parse: parseHexBoltModelParams
 });
 function register(registry2) {
   registry2.register(model);
@@ -4574,11 +4537,11 @@ var shape2 = {
   /** Unsigned pitch-cylinder helix angle to +Z, in degrees. */
   helixAngle: external_exports.number().finite().min(0).lt(90).default(20),
   /** Right-hand teeth advance counterclockwise as Z increases. */
-  handedness: external_exports.enum(["right", "left"]).default("right"),
+  leftHanded: external_exports.boolean().default(false),
   segmentsPerTurn: external_exports.number().int().min(12).max(128).default(32)
 };
 function dimensions2(props) {
-  const { helixAngle, handedness, segmentsPerTurn, ...spur } = props;
+  const { helixAngle, leftHanded, segmentsPerTurn, ...spur } = props;
   const d = getSpurGearDimensions(spur);
   const beta = helixAngle * Math.PI / 180;
   return {
@@ -4589,18 +4552,18 @@ function dimensions2(props) {
     ) * 180 / Math.PI,
     normalPitch: d.circularPitch * Math.cos(beta),
     /** Signed angular advance between the lower and upper faces, in degrees. */
-    twistAngle: helixAngle === 0 ? 0 : (handedness === "right" ? 1 : -1) * (2 * props.faceWidth / d.pitchDiameter * Math.tan(beta) * 180) / Math.PI
+    twistAngle: helixAngle === 0 ? 0 : (leftHanded ? -1 : 1) * (2 * props.faceWidth / d.pitchDiameter * Math.tan(beta) * 180) / Math.PI
   };
 }
 function validate2(props, context) {
-  const { fn, helixAngle, handedness, segmentsPerTurn, ...spur } = props;
+  const { fn, helixAngle, leftHanded, segmentsPerTurn, ...spur } = props;
   const result = spurGearModelPropsSchema.safeParse(spur);
   if (!result.success) {
     for (const issue of result.error.issues) context.addIssue(issue);
     return;
   }
   if (Object.values(
-    dimensions2({ ...result.data, helixAngle, handedness, segmentsPerTurn })
+    dimensions2({ ...result.data, helixAngle, leftHanded, segmentsPerTurn })
   ).some((value) => !Number.isFinite(value)))
     context.addIssue({
       code: "custom",
@@ -4634,7 +4597,7 @@ function parseHelicalGearModelParams(raw) {
     const [name, value] = parseGearToken(token);
     let property;
     let parsed;
-    if (name in lengths) {
+    if (Object.hasOwn(lengths, name)) {
       property = lengths[name];
       parsed = value;
     } else if (name === "teeth" || name === "segments" || name === "turnsegments") {
@@ -4646,8 +4609,8 @@ function parseHelicalGearModelParams(raw) {
     } else if (name === "right" || name === "left") {
       if (value)
         throw new Error(`Helical flag "${name}" does not accept a value`);
-      property = "handedness";
-      parsed = name;
+      property = "leftHanded";
+      parsed = name === "left";
     } else throw new Error(`Unknown helical gear token "${token}"`);
     if (property in props)
       throw new Error(
@@ -4684,6 +4647,76 @@ var jstMotorWireConnectionSchema = external_exports.string().refine((value) => {
   const connector = getJstMotorConnector(value);
   return connector !== void 0 && connector.pinCount >= 2 && connector.pinCount <= connector.maxPinCount;
 }, "Expected jst-ph-N (2\u201316 pins) or jst-sh-N (2\u201315 pins)");
+function isInsideNemaFace(x, y, p) {
+  const h2 = p.width / 2;
+  x = Math.abs(x);
+  y = Math.abs(y);
+  if (x > h2 || y > h2) return false;
+  const chamfer = p.chamfer;
+  if (!p.stepped) return x + y <= 2 * h2 - chamfer;
+  const c = chamfer / Math.SQRT2;
+  if (c === 0) return true;
+  const recess = p.recessRadius;
+  const fillet = p.filletRadius;
+  const k = h2 - c + recess;
+  if (x > h2 - c && y > h2 - c)
+    return x <= k && y <= k && Math.hypot(x - k, y - k) >= recess;
+  if (y > h2 - fillet && x > h2 - c - fillet)
+    return Math.hypot(x - (h2 - c - fillet), y - (h2 - fillet)) <= fillet;
+  if (x > h2 - fillet && y > h2 - c - fillet)
+    return Math.hypot(x - (h2 - fillet), y - (h2 - c - fillet)) <= fillet;
+  return true;
+}
+var segmentDistance = (x, y, ax, ay, bx, by) => {
+  const dx = bx - ax;
+  const dy = by - ay;
+  const t = Math.max(
+    0,
+    Math.min(1, ((x - ax) * dx + (y - ay) * dy) / (dx * dx + dy * dy || 1))
+  );
+  return Math.hypot(x - ax - t * dx, y - ay - t * dy);
+};
+var arcDistance = (x, y, cx, cy, r, start, end) => {
+  const angle = (Math.atan2(y - cy, x - cx) + 2 * Math.PI) % (2 * Math.PI);
+  if (angle >= start && angle <= end)
+    return Math.abs(Math.hypot(x - cx, y - cy) - r);
+  return Math.min(
+    Math.hypot(x - cx - r * Math.cos(start), y - cy - r * Math.sin(start)),
+    Math.hypot(x - cx - r * Math.cos(end), y - cy - r * Math.sin(end))
+  );
+};
+var boundaryDistance = (x, y, p) => {
+  const h2 = p.width / 2;
+  x = Math.abs(x);
+  y = Math.abs(y);
+  const chamfer = p.chamfer;
+  if (!p.stepped || chamfer === 0)
+    return Math.min(
+      Math.abs(h2 - x),
+      Math.abs(h2 - y),
+      Math.abs(2 * h2 - chamfer - x - y) / Math.SQRT2
+    );
+  const c = chamfer / Math.SQRT2;
+  const recess = p.recessRadius;
+  const fillet = p.filletRadius;
+  const a = h2 - c - fillet;
+  const k = h2 - c + recess;
+  return Math.min(
+    segmentDistance(x, y, -a, h2, a, h2),
+    segmentDistance(x, y, h2, -a, h2, a),
+    segmentDistance(x, y, h2 - c, h2 - fillet, h2 - c, k),
+    segmentDistance(x, y, k, h2 - c, h2 - fillet, h2 - c),
+    arcDistance(x, y, a, h2 - fillet, fillet, 0, Math.PI / 2),
+    arcDistance(x, y, k, k, recess, Math.PI, 3 * Math.PI / 2),
+    arcDistance(x, y, h2 - fillet, a, fillet, 0, Math.PI / 2)
+  );
+};
+function fitsNemaCircle(x, y, radius, p) {
+  return isInsideNemaFace(x, y, p) && boundaryDistance(x, y, p) > radius;
+}
+function clearsNemaCircle(x, y, radius, p) {
+  return !isInsideNemaFace(x, y, p) && boundaryDistance(x, y, p) > radius;
+}
 var hexSocketBoltDimensions = {
   M2: {
     diameter: 2,
@@ -4800,7 +4833,8 @@ var nemaMotorDimensions = {
     pilotLength: 1.5,
     shaftDiameter: 4,
     shaftLength: 15,
-    shaftShape: "round",
+    roundShaft: true,
+    dShaft: false,
     shaftFlatDepth: 0.5,
     shaftFlatLength: 10,
     shaftFlatAngle: 0,
@@ -4822,7 +4856,8 @@ var nemaMotorDimensions = {
     pilotLength: 2,
     shaftDiameter: 5,
     shaftLength: 24,
-    shaftShape: "d",
+    roundShaft: false,
+    dShaft: true,
     shaftFlatDepth: 0.5,
     shaftFlatLength: 15,
     shaftFlatAngle: 0,
@@ -4832,7 +4867,15 @@ var nemaMotorDimensions = {
     bodyCornerChamfer: 6
   },
   23: {
-    backFaceScrewSize: "M4",
+    // Representative side-tab rear pattern from STEPPERONLINE's ST-M10 adapter.
+    // The adapter's R5/R2.5 profile is a visual reference, not a frame guarantee:
+    // https://www.omc-stepperonline.com/image/catalog/dimensions/ST-M10_Dimension.svg
+    backFaceHoleSpacing: 50,
+    backFaceHoleSpacingY: 32,
+    rearCornerChamfer: 9 * Math.SQRT2,
+    rearCornerRecessRadius: 5,
+    rearCornerFilletRadius: 2.5,
+    backFaceScrewSize: "M3",
     backFaceHoleDepth: 4.5,
     bodyWidth: 56.4,
     bodyLength: 51,
@@ -4844,14 +4887,18 @@ var nemaMotorDimensions = {
     pilotLength: 1.6,
     shaftDiameter: 6.35,
     shaftLength: 20.6,
-    shaftShape: "d",
+    roundShaft: false,
+    dShaft: true,
     shaftFlatDepth: 0.5,
     shaftFlatLength: 15,
     shaftFlatAngle: 0,
     frontCapLength: 5,
     rearCapLength: 5,
     faceCornerChamfer: 2,
-    bodyCornerChamfer: 15
+    bodyCornerChamfer: 9 * Math.SQRT2,
+    bodyCornerRecessRadius: 5,
+    bodyCornerFilletRadius: 2.5,
+    chamferedBodyCornerChamfer: 15
   },
   34: {
     // Illustrative rear details; independent of the mounting flange.
@@ -4869,7 +4916,8 @@ var nemaMotorDimensions = {
     pilotLength: 1.6,
     shaftDiameter: 14,
     shaftLength: 32,
-    shaftShape: "round",
+    roundShaft: true,
+    dShaft: false,
     shaftFlatDepth: 0.5,
     shaftFlatLength: 15,
     shaftFlatAngle: 0,
@@ -4882,13 +4930,21 @@ var nemaMotorDimensions = {
 var shape3 = {
   nemaSize: nemaSizeSchema,
   /** Rear cap at Z=-bodyLength: bare, open bores or installed cap screws. */
-  backFace: external_exports.enum(["plain", "holes", "screws"]).optional(),
+  backFacePlain: external_exports.boolean().optional(),
+  backFaceHoles: external_exports.boolean().optional(),
+  backFaceScrews: external_exports.boolean().optional(),
   backFaceHoleSpacing: positiveModelLengthSchema.optional(),
+  /** Axis overrides; the legacy scalar still sets a square pattern when supplied. */
+  backFaceHoleSpacingX: positiveModelLengthSchema.optional(),
+  backFaceHoleSpacingY: positiveModelLengthSchema.optional(),
   backFaceHoleDiameter: positiveModelLengthSchema.optional(),
   backFaceHoleDepth: positiveModelLengthSchema.optional(),
   backFaceScrewSize: metricBoltSizeSchema.optional(),
   /** Visual termination; the wireside reference exists even when hidden. */
-  wireConnection: external_exports.union([external_exports.enum(["none", "stubs"]), jstMotorWireConnectionSchema]).optional(),
+  noWires: external_exports.boolean().optional(),
+  wireStubs: external_exports.boolean().optional(),
+  /** JST catalog designation, mutually exclusive with the visible-wire flags. */
+  wireConnection: jstMotorWireConnectionSchema.optional(),
   /** Counterclockwise angle about local +Z; 0 is the +X side. */
   wireSideAngle: external_exports.number().finite().optional(),
   wireLength: positiveModelLengthSchema.optional(),
@@ -4905,7 +4961,8 @@ var shape3 = {
   /** Distance from mounting face Z=0 to shaft tip, including pilot height. */
   shaftLength: positiveModelLengthSchema.optional(),
   shaftDiameter: positiveModelLengthSchema.optional(),
-  shaftShape: external_exports.enum(["round", "d"]).optional(),
+  roundShaft: external_exports.boolean().optional(),
+  dShaft: external_exports.boolean().optional(),
   /** Radial material removed from the +X side before rotation. */
   shaftFlatDepth: nonnegativeModelLengthSchema.optional(),
   /** Flat extends back from the tip; leaves a round shoulder above the pilot. */
@@ -4916,23 +4973,74 @@ var shape3 = {
   rearCapLength: positiveModelLengthSchema.optional(),
   faceCornerChamfer: nonnegativeModelLengthSchema.optional(),
   bodyCornerChamfer: nonnegativeModelLengthSchema.optional(),
+  bodyCornerRecessRadius: nonnegativeModelLengthSchema.optional(),
+  bodyCornerFilletRadius: nonnegativeModelLengthSchema.optional(),
   /** Rear outline is independent of the front mounting flange. */
   rearCornerChamfer: nonnegativeModelLengthSchema.optional(),
-  cornerProfile: external_exports.enum(["chamfered", "stepped"]).optional()
-};
-var resolve = (p) => {
+  rearCornerRecessRadius: nonnegativeModelLengthSchema.optional(),
+  rearCornerFilletRadius: nonnegativeModelLengthSchema.optional(),
+  rearChamfered: external_exports.boolean().optional(),
+  rearStepped: external_exports.boolean().optional(),
+  chamfered: external_exports.boolean().optional(),
+  stepped: external_exports.boolean().optional()
+};
+var resolve = (p, ctx) => {
+  const select = (flags11, fallback) => {
+    const selected = flags11.filter((flag) => p[flag] === true);
+    const specified = flags11.some((flag) => p[flag] !== void 0);
+    if (selected.length > 1 || specified && selected.length === 0)
+      ctx.addIssue({
+        code: "custom",
+        message: `Select exactly one of ${flags11.join(", ")}`
+      });
+    return selected[0] ?? fallback;
+  };
+  const back = select(
+    ["backFacePlain", "backFaceHoles", "backFaceScrews"],
+    p.nemaSize === 34 ? "backFacePlain" : "backFaceScrews"
+  );
+  const shaft = select(
+    ["roundShaft", "dShaft"],
+    nemaMotorDimensions[p.nemaSize].roundShaft ? "roundShaft" : "dShaft"
+  );
+  const corner = select(
+    ["chamfered", "stepped"],
+    p.nemaSize === 23 || p.nemaSize === 34 ? "stepped" : "chamfered"
+  );
+  const rearCorner = select(
+    ["rearChamfered", "rearStepped"],
+    p.chamfered === true ? "rearChamfered" : p.nemaSize === 23 || corner === "stepped" ? "rearStepped" : "rearChamfered"
+  );
+  const wireSpecified = p.noWires !== void 0 || p.wireStubs !== void 0 || p.wireConnection !== void 0;
+  const wireSelections = Number(p.noWires === true) + Number(p.wireStubs === true) + Number(p.wireConnection !== void 0);
+  if (wireSelections > 1 || wireSpecified && wireSelections === 0)
+    ctx.addIssue({
+      code: "custom",
+      message: "Select exactly one of noWires, wireStubs or a JST wireConnection"
+    });
   const d = nemaMotorDimensions[p.nemaSize];
+  const bodyCornerChamfer = p.bodyCornerChamfer ?? (corner === "chamfered" && "chamferedBodyCornerChamfer" in d ? d.chamferedBodyCornerChamfer : d.bodyCornerChamfer);
+  const defaultBodyRadius = Math.min(4, bodyCornerChamfer / Math.SQRT2 / 4);
   const backFaceScrewSize = p.backFaceScrewSize ?? d.backFaceScrewSize;
   const screw = hexSocketBoltDimensions[backFaceScrewSize];
+  const backFaceHoleSpacing = p.backFaceHoleSpacing ?? ("backFaceHoleSpacing" in d ? d.backFaceHoleSpacing : p.mountingHoleSpacing ?? d.mountingHoleSpacing);
+  const rearCornerChamfer = p.rearCornerChamfer ?? (p.nemaSize === 23 && rearCorner === "rearChamfered" ? p.faceCornerChamfer ?? d.faceCornerChamfer : "rearCornerChamfer" in d ? d.rearCornerChamfer : back === "backFacePlain" && (p.mountingHoleThrough ?? d.mountingHoleThrough) ? p.bodyCornerChamfer ?? d.bodyCornerChamfer : p.faceCornerChamfer ?? d.faceCornerChamfer);
+  const defaultRearRadius = Math.min(4, rearCornerChamfer / Math.SQRT2 / 4);
   return {
     nemaSize: p.nemaSize,
-    wireConnection: p.wireConnection ?? "stubs",
+    noWires: p.noWires === true,
+    wireStubs: p.wireStubs === true || !wireSpecified,
+    ...p.wireConnection !== void 0 ? { wireConnection: p.wireConnection } : {},
     wireSideAngle: ((p.wireSideAngle ?? (p.nemaSize === 34 ? 90 : 0)) % 360 + 360) % 360,
     wireLength: p.wireLength ?? (p.nemaSize === 34 ? 25 : 6),
     wireDiameter: p.wireDiameter ?? (p.nemaSize === 34 ? 2 : 1.2),
     wireCount: p.wireCount ?? 4,
-    backFace: p.backFace ?? (p.nemaSize === 34 ? "plain" : "screws"),
-    backFaceHoleSpacing: p.backFaceHoleSpacing ?? ("backFaceHoleSpacing" in d ? d.backFaceHoleSpacing : p.mountingHoleSpacing ?? d.mountingHoleSpacing),
+    backFacePlain: back === "backFacePlain",
+    backFaceHoles: back === "backFaceHoles",
+    backFaceScrews: back === "backFaceScrews",
+    backFaceHoleSpacing,
+    backFaceHoleSpacingX: p.backFaceHoleSpacingX ?? backFaceHoleSpacing,
+    backFaceHoleSpacingY: p.backFaceHoleSpacingY ?? p.backFaceHoleSpacing ?? ("backFaceHoleSpacingY" in d ? d.backFaceHoleSpacingY : backFaceHoleSpacing),
     backFaceHoleDiameter: p.backFaceHoleDiameter ?? screw.diameter,
     backFaceHoleDepth: p.backFaceHoleDepth ?? d.backFaceHoleDepth,
     backFaceScrewSize,
@@ -4946,43 +5054,64 @@ var resolve = (p) => {
     pilotLength: p.pilotLength ?? d.pilotLength,
     shaftDiameter: p.shaftDiameter ?? d.shaftDiameter,
     shaftLength: p.shaftLength ?? d.shaftLength,
-    shaftShape: p.shaftShape ?? d.shaftShape,
+    roundShaft: shaft === "roundShaft",
+    dShaft: shaft === "dShaft",
     shaftFlatDepth: p.shaftFlatDepth ?? d.shaftFlatDepth,
     shaftFlatLength: p.shaftFlatLength ?? d.shaftFlatLength,
     shaftFlatAngle: p.shaftFlatAngle ?? d.shaftFlatAngle,
     frontCapLength: p.frontCapLength ?? d.frontCapLength,
     rearCapLength: p.rearCapLength ?? d.rearCapLength,
     faceCornerChamfer: p.faceCornerChamfer ?? d.faceCornerChamfer,
-    bodyCornerChamfer: p.bodyCornerChamfer ?? d.bodyCornerChamfer,
-    ...p.nemaSize === 34 || p.cornerProfile !== void 0 ? { cornerProfile: p.cornerProfile ?? "stepped" } : {},
-    ..."rearCornerChamfer" in d || p.rearCornerChamfer !== void 0 ? {
-      rearCornerChamfer: p.rearCornerChamfer ?? ("rearCornerChamfer" in d ? d.rearCornerChamfer : p.faceCornerChamfer ?? d.faceCornerChamfer)
-    } : {}
+    bodyCornerChamfer,
+    bodyCornerRecessRadius: p.bodyCornerRecessRadius ?? ("bodyCornerRecessRadius" in d ? d.bodyCornerRecessRadius : defaultBodyRadius),
+    bodyCornerFilletRadius: p.bodyCornerFilletRadius ?? ("bodyCornerFilletRadius" in d ? d.bodyCornerFilletRadius : defaultBodyRadius),
+    chamfered: corner === "chamfered",
+    stepped: corner === "stepped",
+    rearCornerChamfer,
+    rearStepped: rearCorner === "rearStepped",
+    rearChamfered: rearCorner === "rearChamfered",
+    rearCornerRecessRadius: p.rearCornerRecessRadius ?? ("rearCornerRecessRadius" in d ? d.rearCornerRecessRadius : defaultRearRadius),
+    rearCornerFilletRadius: p.rearCornerFilletRadius ?? ("rearCornerFilletRadius" in d ? d.rearCornerFilletRadius : defaultRearRadius)
   };
 };
 var validate3 = (p, ctx) => {
   const issue = (message) => ctx.addIssue({ code: "custom", message });
-  const rearChamfer = p.rearCornerChamfer ?? (p.backFace === "plain" && p.mountingHoleThrough ? p.bodyCornerChamfer : p.faceCornerChamfer);
-  const rearEdge = p.cornerProfile === "stepped" ? rearChamfer / Math.SQRT2 : rearChamfer;
-  if (p.backFace !== "plain") {
+  if (p.stepped && p.bodyCornerRecessRadius + p.bodyCornerFilletRadius > p.bodyCornerChamfer / Math.SQRT2)
+    issue("Body recess and fillet radii must fit within the corner shoulder");
+  const rearChamfer = p.rearCornerChamfer ?? (p.backFacePlain && p.mountingHoleThrough ? p.bodyCornerChamfer : p.faceCornerChamfer);
+  const rearEdge = p.rearStepped ? rearChamfer / Math.SQRT2 : rearChamfer;
+  if (p.rearStepped && p.rearCornerRecessRadius + p.rearCornerFilletRadius > rearEdge)
+    issue("Rear recess and fillet radii must fit within the corner shoulder");
+  if (!p.backFacePlain) {
     const screw = hexSocketBoltDimensions[p.backFaceScrewSize];
-    const radius = (p.backFace === "screws" ? Math.max(p.backFaceHoleDiameter, screw.headDiameter) : p.backFaceHoleDiameter) / 2;
-    if (p.backFaceHoleSpacing <= 2 * radius)
+    const radius = (p.backFaceScrews ? Math.max(p.backFaceHoleDiameter, screw.headDiameter) : p.backFaceHoleDiameter) / 2;
+    if (p.backFaceHoleSpacingX <= 2 * radius || p.backFaceHoleSpacingY <= 2 * radius)
       issue("Rear holes and screw heads must not overlap each other");
-    if (p.backFaceHoleSpacing + 2 * radius >= p.bodyWidth || (p.cornerProfile === "stepped" ? p.backFaceHoleSpacing + 2 * radius >= p.bodyWidth - 2 * rearEdge : p.bodyWidth - rearChamfer - p.backFaceHoleSpacing <= radius * Math.SQRT2))
+    if (!fitsNemaCircle(
+      p.backFaceHoleSpacingX / 2,
+      p.backFaceHoleSpacingY / 2,
+      radius,
+      {
+        width: p.bodyWidth,
+        chamfer: p.rearCornerChamfer,
+        stepped: p.rearStepped,
+        recessRadius: p.rearCornerRecessRadius,
+        filletRadius: p.rearCornerFilletRadius
+      }
+    ))
       issue("Rear holes and screw heads must fit entirely inside the rear face");
     if (p.backFaceHoleDepth >= p.rearCapLength)
       issue("Rear hole depth must be less than the rear cap length");
-    if (p.backFace === "screws" && p.backFaceHoleDiameter < screw.diameter)
+    if (p.backFaceScrews && p.backFaceHoleDiameter < screw.diameter)
       issue("Rear holes must accommodate the screw diameter");
   }
-  if (p.wireConnection === "stubs") {
+  if (p.wireStubs) {
     if (p.wireDiameter * p.wireCount * 1.5 > p.bodyWidth - 2 * rearEdge)
       issue("Wire bundle must fit on the cap side");
     if (p.wireDiameter >= p.rearCapLength)
       issue("Wire diameter must fit within the rear cap");
   }
-  const connector = getJstMotorConnector(p.wireConnection);
+  const connector = p.wireConnection === void 0 ? void 0 : getJstMotorConnector(p.wireConnection);
   if (connector && p.bodyWidth - 2 * rearEdge < connector.bodyWidth)
     issue("JST header must fit on the motor side");
   const r = p.mountingHoleDiameter / 2;
@@ -5000,17 +5129,23 @@ var validate3 = (p, ctx) => {
     issue("Mounting holes must clear the pilot");
   if (!p.mountingHoleThrough && p.mountingHoleDepth >= p.frontCapLength)
     issue("Blind mounting hole depth must be less than the front cap length");
-  if (p.mountingHoleThrough && (p.cornerProfile === "stepped" ? p.bodyWidth / 2 - p.bodyCornerChamfer / Math.SQRT2 + Math.min(4, p.bodyCornerChamfer / Math.SQRT2 / 4) >= p.mountingHoleSpacing / 2 - r : p.bodyWidth - p.bodyCornerChamfer - p.mountingHoleSpacing >= -r * Math.SQRT2))
+  if (p.mountingHoleThrough && !clearsNemaCircle(p.mountingHoleSpacing / 2, p.mountingHoleSpacing / 2, r, {
+    width: p.bodyWidth,
+    chamfer: p.bodyCornerChamfer,
+    stepped: p.stepped,
+    recessRadius: p.bodyCornerRecessRadius,
+    filletRadius: p.bodyCornerFilletRadius
+  }))
     issue("Body must clear through front mounting holes");
   if (p.shaftLength <= p.pilotLength)
     issue("Shaft tip must extend beyond the pilot");
-  if (p.shaftShape === "d" && (p.shaftFlatDepth <= 0 || p.shaftFlatDepth >= p.shaftDiameter / 2 || p.shaftFlatLength <= 0 || p.shaftFlatLength > p.shaftLength - p.pilotLength))
+  if (p.dShaft && (p.shaftFlatDepth <= 0 || p.shaftFlatDepth >= p.shaftDiameter / 2 || p.shaftFlatLength <= 0 || p.shaftFlatLength > p.shaftLength - p.pilotLength))
     issue(
       "D flat must have positive depth less than the shaft radius and fit above the pilot"
     );
 };
 var nemaMotorModelPropsSchema = external_exports.object(shape3).strict().transform(resolve).superRefine(validate3);
-var nemaMotorModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("nema"), ...shape3 }).strict().transform(({ fn, ...props }) => ({ fn, ...resolve(props) })).superRefine(validate3);
+var nemaMotorModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("nema"), ...shape3 }).strict().transform(({ fn, ...props }, ctx) => ({ fn, ...resolve(props, ctx) })).superRefine(validate3);
 var lengths2 = {
   wirelength: "wireLength",
   wirediameter: "wireDiameter",
@@ -5019,6 +5154,8 @@ var lengths2 = {
   bodylength: "bodyLength",
   bodywidth: "bodyWidth",
   backholespacing: "backFaceHoleSpacing",
+  backholespacingx: "backFaceHoleSpacingX",
+  backholespacingy: "backFaceHoleSpacingY",
   backholediameter: "backFaceHoleDiameter",
   backholedepth: "backFaceHoleDepth",
   shaftlength: "shaftLength",
@@ -5034,7 +5171,26 @@ var lengths2 = {
   rearcap: "rearCapLength",
   facechamfer: "faceCornerChamfer",
   bodychamfer: "bodyCornerChamfer",
-  rearchamfer: "rearCornerChamfer"
+  bodyrecess: "bodyCornerRecessRadius",
+  bodyfillet: "bodyCornerFilletRadius",
+  rearchamfer: "rearCornerChamfer",
+  rearrecess: "rearCornerRecessRadius",
+  rearfillet: "rearCornerFilletRadius"
+};
+var flags = {
+  backfaceplain: "backFacePlain",
+  plainbackface: "backFacePlain",
+  backfaceholes: "backFaceHoles",
+  backfacescrews: "backFaceScrews",
+  round: "roundShaft",
+  roundshaft: "roundShaft",
+  dshaft: "dShaft",
+  chamfered: "chamfered",
+  stepped: "stepped",
+  rearstepped: "rearStepped",
+  rearchamfered: "rearChamfered",
+  nowires: "noWires",
+  wirestubs: "wireStubs"
 };
 function parseNemaMotorModelParams(raw) {
   const tokens = normalizeNemaMotorModelString(raw.string).split("_");
@@ -5052,20 +5208,15 @@ function parseNemaMotorModelParams(raw) {
     if (name in lengths2) {
       property = lengths2[name];
       parsed = value;
-    } else if (["backfaceholes", "backfacescrews", "plainbackface"].includes(name)) {
+    } else if (name in flags) {
       if (value) throw new Error(`NEMA flag "${name}" does not accept a value`);
-      property = "backFace";
-      parsed = name === "backfaceholes" ? "holes" : name === "backfacescrews" ? "screws" : "plain";
-    } else if (["wirestubs", "nowires", "jstph", "jstsh"].includes(name)) {
-      const isJst = name === "jstph" || name === "jstsh";
-      if (isJst && !/^[1-9][0-9]*$/.test(value) || !isJst && value)
+      property = flags[name];
+      parsed = true;
+    } else if (name === "jstph" || name === "jstsh") {
+      if (!/^[1-9][0-9]*$/.test(value))
         throw new Error(`Invalid wire connection token "${token}"`);
       property = "wireConnection";
-      parsed = isJst ? `jst-${name.slice(3)}-${value}` : name === "nowires" ? "none" : "stubs";
-    } else if (name === "stepped" || name === "chamfered") {
-      if (value) throw new Error(`NEMA flag "${name}" does not accept a value`);
-      property = "cornerProfile";
-      parsed = name;
+      parsed = `jst-${name.slice(3)}-${value}`;
     } else if (name === "wirecount") {
       property = "wireCount";
       if (!/^\d+$/.test(value)) throw new Error("wirecount requires an integer");
@@ -5078,10 +5229,10 @@ function parseNemaMotorModelParams(raw) {
       if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:deg)?$/i.test(value))
         throw new Error(`${name} requires a numeric angle in degrees`);
       parsed = Number(value.replace(/deg$/i, ""));
-    } else if (["round", "dshaft", "throughholes", "blindholes"].includes(name)) {
+    } else if (name === "throughholes" || name === "blindholes") {
       if (value) throw new Error(`NEMA flag "${name}" does not accept a value`);
-      property = name === "round" || name === "dshaft" ? "shaftShape" : "mountingHoleThrough";
-      parsed = name === "round" ? "round" : name === "dshaft" ? "d" : name === "throughholes";
+      property = "mountingHoleThrough";
+      parsed = name === "throughholes";
     } else throw new Error(`Unknown NEMA motor token "${token}"`);
     if (property in props)
       throw new Error(`NEMA property "${property}" is set more than once`);
@@ -5104,22 +5255,26 @@ var holePosition = {
   u: modelLengthSchema,
   v: modelLengthSchema
 };
-var sheetMetalHoleSchema = external_exports.discriminatedUnion("shape", [
+var sheetMetalHoleSchema = external_exports.union([
   external_exports.object({
     ...holePosition,
-    shape: external_exports.literal("round"),
+    round: external_exports.literal(true),
+    slot: external_exports.literal(false).default(false),
     diameter: positiveModelLengthSchema
   }).strict(),
   external_exports.object({
     ...holePosition,
-    shape: external_exports.literal("slot"),
+    round: external_exports.literal(false).default(false),
+    slot: external_exports.literal(true),
     length: positiveModelLengthSchema,
     width: positiveModelLengthSchema,
     axis: external_exports.enum(["u", "v"]).default("v")
   }).strict()
 ]);
 var sheetMetalShape = {
-  profile: external_exports.enum(["plate", "angle", "channel"]).default("plate"),
+  plate: external_exports.boolean().default(false),
+  angle: external_exports.boolean().default(false),
+  channel: external_exports.boolean().default(false),
   width: positiveModelLengthSchema,
   /** Straight base length between bend tangencies, not overall width. */
   baseLength: positiveModelLengthSchema,
@@ -5129,9 +5284,19 @@ var sheetMetalShape = {
   insideBendRadius: positiveModelLengthSchema.default(1),
   holes: external_exports.array(sheetMetalHoleSchema).max(100).default([])
 };
-var sheetMetalModelPropsSchema = external_exports.object(sheetMetalShape).strict();
-var sheetMetalModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("sheetmetal"), ...sheetMetalShape }).strict();
-function parseSheetMetalFeature(feature, profile6) {
+function validateFlags(props, context) {
+  if ([props.plate, props.angle, props.channel].filter(Boolean).length > 1)
+    context.addIssue({
+      code: "custom",
+      message: "Specify at most one of plate, angle, or channel"
+    });
+}
+function resolveFlags(props) {
+  return { ...props, plate: props.plate || !(props.angle || props.channel) };
+}
+var sheetMetalModelPropsSchema = external_exports.object(sheetMetalShape).strict().superRefine(validateFlags).transform(resolveFlags);
+var sheetMetalModelDefinitionSchema = external_exports.object({ fn: external_exports.literal("sheetmetal"), ...sheetMetalShape }).strict().superRefine(validateFlags).transform((props) => ({ fn: props.fn, ...resolveFlags(props) }));
+function parseSheetMetalFeature(feature, flags11) {
   const match = feature.match(/^(hole|slot)[1-9]\d*\(([^()]+)\)$/);
   if (!match) throw new Error(`Invalid sheet metal feature "${feature}"`);
   const kind = match[1];
@@ -5164,8 +5329,8 @@ function parseSheetMetalFeature(feature, profile6) {
   if (faces.length !== 1)
     throw new Error(`Specify exactly one face in ${feature}`);
   const face2 = faces[0];
-  if (face2 === "angledface" && profile6 !== "angle" || ["leftface", "rightface"].includes(face2) && profile6 !== "channel")
-    throw new Error(`No ${face2} on ${profile6}`);
+  if (face2 === "angledface" && !flags11.angle || ["leftface", "rightface"].includes(face2) && !flags11.channel)
+    throw new Error(`No ${face2} on the selected sheet metal form`);
   for (const [a, b] of [
     ["leftofcenter", "rightofcenter"],
     ["abovecenter", "belowcenter"],
@@ -5189,7 +5354,7 @@ function parseSheetMetalFeature(feature, profile6) {
       throw new Error(`Hole requires r or d in ${feature}`);
     return sheetMetalHoleSchema.parse({
       ...position,
-      shape: "round",
+      round: true,
       diameter: "r" in values ? 2 * distance2("r") : distance2("d")
     });
   }
@@ -5199,7 +5364,7 @@ function parseSheetMetalFeature(feature, profile6) {
   if (length32 < width10) throw new Error("Slot length must be at least its width");
   return sheetMetalHoleSchema.parse({
     ...position,
-    shape: "slot",
+    slot: true,
     length: length32,
     width: width10,
     axis: panel === "base" === !("vertical" in values) ? "u" : "v"
@@ -5227,8 +5392,9 @@ function parseSheetMetalModelParams(raw) {
       continue;
     }
     if (["plate", "angle", "channel"].includes(token)) {
-      if (props.profile) throw new Error("Duplicate sheet metal profile");
-      props.profile = token;
+      if (["plate", "angle", "channel"].some((flag) => flag in props))
+        throw new Error("Duplicate sheet metal form flag");
+      props[token] = true;
       continue;
     }
     const key = lengths3[token[0]];
@@ -5242,7 +5408,7 @@ function parseSheetMetalModelParams(raw) {
     ...props
   });
   definition.holes = features.map(
-    (feature) => parseSheetMetalFeature(feature, definition.profile)
+    (feature) => parseSheetMetalFeature(feature, definition)
   );
   return definition;
 }
@@ -5254,14 +5420,6 @@ var model4 = defineModel({
 function register4(registry2) {
   registry2.register(model4);
 }
-var flexScreenOrientationSchema = external_exports.enum([
-  "sitsFlat",
-  "sitsFlatBelowBoard",
-  "foldedToFaceAboveBoard",
-  "foldedToFaceBelowBoard",
-  "foldedToRightAngleAboveBoard",
-  "foldedToRightAngleBelowBoard"
-]);
 var positiveFiniteNumberSchema = external_exports.number().finite().positive();
 var aspectRatioStringSchema = external_exports.string().refine((value) => {
   const parts = value.split(":");
@@ -5303,7 +5461,6 @@ var flexScreenModelPropsShape = {
   aspectRatio: flexScreenAspectRatioSchema.optional(),
   ratio: flexScreenAspectRatioSchema.optional(),
   defaultDiagonal: positiveModelLengthSchema.optional(),
-  orientation: flexScreenOrientationSchema.optional(),
   sitsFlat: external_exports.boolean().optional(),
   sitsFlatBelowBoard: external_exports.boolean().optional(),
   foldedToFaceAboveBoard: external_exports.boolean().optional(),
@@ -5371,7 +5528,42 @@ var addOrientationShortcutIssue = (props, addIssue) => {
   const selectedShortcuts = orientationShortcutKeys.filter(
     (key) => props[key] === true
   );
-  if (selectedShortcuts.length > 1) addIssue(selectedShortcuts[1]);
+  if (selectedShortcuts.length > 1) {
+    addIssue(
+      selectedShortcuts[1],
+      "Only one FlexScreen orientation shortcut can be true"
+    );
+  } else if (selectedShortcuts.length === 0 && orientationShortcutKeys.some((key) => props[key] !== void 0)) {
+    addIssue(
+      "sitsFlat",
+      "A FlexScreen orientation flag must be true when placement flags are supplied"
+    );
+  }
+};
+var normalizeOrientationFlags = (props) => {
+  const {
+    sitsFlat,
+    sitsFlatBelowBoard,
+    foldedToFaceAboveBoard,
+    foldedToFaceBelowBoard,
+    foldedToRightAngleAboveBoard,
+    foldedToRightAngleBelowBoard,
+    foldsAboveBoard,
+    foldsBelowBoard,
+    ...rest
+  } = props;
+  const above = foldedToFaceAboveBoard === true || foldsAboveBoard === true;
+  const below = foldedToFaceBelowBoard === true || foldsBelowBoard === true;
+  const selected = sitsFlatBelowBoard === true || above || below || foldedToRightAngleAboveBoard === true || foldedToRightAngleBelowBoard === true;
+  return {
+    ...rest,
+    sitsFlat: sitsFlat === true || !selected,
+    sitsFlatBelowBoard: sitsFlatBelowBoard === true,
+    foldedToFaceAboveBoard: above,
+    foldedToFaceBelowBoard: below,
+    foldedToRightAngleAboveBoard: foldedToRightAngleAboveBoard === true,
+    foldedToRightAngleBelowBoard: foldedToRightAngleBelowBoard === true
+  };
 };
 var validateTailLengths = (props, context) => {
   if (props.flexCableLength === void 0) return;
@@ -5392,27 +5584,27 @@ var validateTailLengths = (props, context) => {
 };
 var flexScreenModelPropsSchema = external_exports.object(flexScreenModelPropsShape).strict().superRefine((props, context) => {
   validateTailLengths(props, context);
-  addOrientationShortcutIssue(props, (path) => {
+  addOrientationShortcutIssue(props, (path, message) => {
     context.addIssue({
       code: "custom",
-      message: "Only one FlexScreen orientation shortcut can be true",
+      message,
       path: [path]
     });
   });
-});
+}).transform(normalizeOrientationFlags);
 var flexScreenModelDefinitionSchema = external_exports.object({
   fn: external_exports.literal("flexscreen"),
   ...flexScreenModelPropsShape
 }).strict().superRefine((model552, context) => {
   validateTailLengths(model552, context);
-  addOrientationShortcutIssue(model552, (path) => {
+  addOrientationShortcutIssue(model552, (path, message) => {
     context.addIssue({
       code: "custom",
-      message: "Only one FlexScreen orientation shortcut can be true",
+      message,
       path: [path]
     });
   });
-});
+}).transform(normalizeOrientationFlags);
 var orientationTokens = {
   sitsflat: "sitsFlat",
   sitsflatbelow: "sitsFlatBelowBoard",
@@ -5538,6 +5730,23 @@ var parseFlexScreenModelParams = (rawParams) => {
   }
   const props = {};
   let orientation;
+  for (const part of splitModelStringTokens(rawParams.string).slice(1)) {
+    const match = part.match(/^([a-zA-Z]+)(.*)$/);
+    if (!match) continue;
+    const token = match[1].toLowerCase();
+    const selected = orientationTokens[token];
+    if (!selected) continue;
+    if (match[2] !== "") {
+      throw new Error(`FlexScreen token "${token}" does not accept a value`);
+    }
+    if (orientation !== void 0) {
+      throw new Error(
+        orientation === selected ? `Duplicate FlexScreen orientation flag "${token}"` : "A FlexScreen model string can only set one orientation"
+      );
+    }
+    orientation = selected;
+    props[selected] = true;
+  }
   let relativeDistance;
   for (const [token, value] of Object.entries(rawParams)) {
     if (token === "fn" || token === "string" || token === "flexscreen") {
@@ -5546,13 +5755,6 @@ var parseFlexScreenModelParams = (rawParams) => {
     const tokenOrientation = orientationTokens[token];
     if (tokenOrientation) {
       assertBareToken(value, token);
-      if (orientation && orientation !== tokenOrientation) {
-        throw new Error(
-          "A FlexScreen model string can only set one orientation"
-        );
-      }
-      orientation = tokenOrientation;
-      props.orientation = tokenOrientation;
       continue;
     }
     if (token in booleanTokens) {
@@ -5728,7 +5930,7 @@ var shape4 = {
   /** Additional radial dedendum beyond one module, in millimeters. */
   clearance: nonnegativeGearLengthSchema.default(0.25),
   boreDiameter: nonnegativeGearLengthSchema.default(0),
-  handedness: external_exports.enum(["right", "left"]).default("right"),
+  leftHanded: external_exports.boolean().default(false),
   /** Counterclockwise degrees about +Z, beginning at the Z=0 end. */
   phase: external_exports.number().finite().default(0),
   radialSegments: external_exports.number().int().min(24).max(256).refine(
@@ -5798,7 +6000,7 @@ function parseWormGearModelParams(raw) {
     const [name, value] = parseGearToken(token);
     let property;
     let parsed;
-    if (name in lengths5) {
+    if (Object.hasOwn(lengths5, name)) {
       property = lengths5[name];
       parsed = value;
     } else if (["starts", "segments", "turnsegments"].includes(name)) {
@@ -5809,8 +6011,8 @@ function parseWormGearModelParams(raw) {
       parsed = parseGearAngle(value, property);
     } else if (name === "right" || name === "left") {
       if (value) throw new Error(`Worm flag "${name}" does not accept a value`);
-      property = "handedness";
-      parsed = name;
+      property = "leftHanded";
+      parsed = name === "left";
     } else throw new Error(`Unknown worm gear token "${token}"`);
     if (property in props)
       throw new Error(`Worm gear property "${property}" is set more than once`);
@@ -6129,7 +6331,7 @@ var lengths7 = {
   w: "width",
   width: "width"
 };
-var flags = {
+var flags2 = {
   open: "bothSidesOpen",
   bothsidesopen: "bothSidesOpen",
   shielded: "bothSidesShielded",
@@ -6163,8 +6365,8 @@ function parseBallBearingModelParams(raw) {
   const scopes = /* @__PURE__ */ new Set();
   for (const token of tokens.slice(1)) {
     const lower = token.toLowerCase();
-    if (Object.hasOwn(flags, lower)) {
-      const property2 = flags[lower];
+    if (Object.hasOwn(flags2, lower)) {
+      const property2 = flags2[lower];
       const scope = property2.startsWith("both") ? "both" : property2.startsWith("top") ? "top" : "bottom";
       if (scopes.has(scope))
         throw new Error(
@@ -6358,7 +6560,7 @@ function parseBallTransferUnitModelParams(raw) {
     const lower = token.toLowerCase();
     let property;
     let value;
-    if (lower === "face3hole" || lower === "mount(face3hole)") {
+    if (lower === "face3hole") {
       property = "faceThreeHole";
       value = true;
     } else {
@@ -6384,12 +6586,6 @@ var model12 = defineModel({
 function register12(registry2) {
   registry2.register(model12);
 }
-var stringFlags2 = {
-  hexsocket: "drive(hexsocket)",
-  fullthread: "thread(full)",
-  righthanded: "threadhand(right)"
-};
-var omittedStringFlags2 = ["righthanded"];
 var buttonScrewDimensions = {
   M3: {
     diameter: 3,
@@ -6450,10 +6646,10 @@ var shape9 = {
   metricSize: buttonScrewMetricSizeSchema,
   /** Under-head length; this family supports short fully threaded screws only. */
   length: length4,
-  drive: external_exports.literal("hexsocket").default("hexsocket"),
-  thread: external_exports.literal("full").default("full"),
+  hexSocket: external_exports.literal(true).default(true),
+  fullThread: external_exports.literal(true).default(true),
   threadPitch: length4.optional(),
-  threadHand: external_exports.literal("right").default("right"),
+  leftHanded: external_exports.literal(false).default(false),
   threadClass: external_exports.literal("6g").default("6g"),
   showThreads: external_exports.boolean().default(true)
 };
@@ -6509,9 +6705,7 @@ function getButtonScrewDimensions(input) {
   };
 }
 function parseButtonScrewModelParams(raw) {
-  const tokens = splitModelStringTokens(
-    expandModelStringFlags(raw.string, stringFlags2)
-  );
+  const tokens = splitModelStringTokens(raw.string);
   if (raw.fn !== "buttonscrew" || tokens[0]?.toLowerCase() !== "buttonscrew")
     throw new Error("Expected buttonscrew without an inline argument");
   const props = { fn: "buttonscrew" };
@@ -6520,12 +6714,15 @@ function parseButtonScrewModelParams(raw) {
     length: "length",
     threadpitch: "threadPitch"
   };
-  const selectors7 = {
-    drive: "drive",
-    thread: "thread",
-    threadhand: "threadHand",
+  const selectors5 = {
     threadclass: "threadClass"
   };
+  const booleanFlags4 = {
+    hexsocket: { property: "hexSocket", value: true },
+    fullthread: { property: "fullThread", value: true },
+    righthanded: { property: "leftHanded", value: false },
+    lefthanded: { property: "leftHanded", value: true }
+  };
   for (const token of tokens.slice(1)) {
     if (token.toLowerCase() === "iso7380-1") {
       if ("iso73801" in props)
@@ -6539,12 +6736,17 @@ function parseButtonScrewModelParams(raw) {
     const value = match[2];
     let property;
     let parsed = value;
-    if (name === "m") {
+    if (Object.hasOwn(booleanFlags4, name)) {
+      if (value) throw new Error(`Flag "${name}" does not accept a value`);
+      property = booleanFlags4[name].property;
+      parsed = booleanFlags4[name].value;
+    } else if (name === "m") {
       property = "metricSize";
       parsed = `M${value}`;
-    } else if (name in lengths25) property = lengths25[name];
-    else if (name in selectors7) {
-      property = selectors7[name];
+    } else if (Object.hasOwn(lengths25, name))
+      property = lengths25[name];
+    else if (Object.hasOwn(selectors5, name)) {
+      property = selectors5[name];
       if (!/^\([^()]+\)$/.test(value))
         throw new Error(`Expected a parenthesized ${name}`);
       parsed = value.slice(1, -1).toLowerCase();
@@ -6562,21 +6764,11 @@ function parseButtonScrewModelParams(raw) {
 var model13 = defineModel({
   name: "buttonscrew",
   schema: buttonScrewModelDefinitionSchema,
-  parse: parseButtonScrewModelParams,
-  normalizeString: (value) => normalizeModelStringFlags(
-    value,
-    stringFlags2,
-    parseButtonScrewModelParams,
-    omittedStringFlags2
-  )
+  parse: parseButtonScrewModelParams
 });
 function register13(registry2) {
   registry2.register(model13);
 }
-var stringFlags3 = {
-  symmetricring: "shape(symmetricring)"
-};
-var omittedStringFlags3 = [];
 var length5 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(
@@ -6592,7 +6784,7 @@ var shape10 = {
   grooveWidth: length5,
   /** Radial recess from the flange outside diameter. */
   grooveDepth: length5,
-  shape: external_exports.literal("symmetricring").default("symmetricring")
+  symmetricRing: external_exports.literal(true).default(true)
 };
 function validate9(props, context) {
   if (props.innerDiameter >= props.panelHoleDiameter || props.panelHoleDiameter >= props.outerDiameter)
@@ -6649,9 +6841,7 @@ var lengths9 = {
   groovedepth: "grooveDepth"
 };
 function parseCableGrommetModelParams(raw) {
-  const tokens = splitModelStringTokens(
-    expandModelStringFlags(raw.string, stringFlags3)
-  );
+  const tokens = splitModelStringTokens(raw.string);
   if (raw.fn !== "cablegrommet" || !/^cablegrommet$/i.test(tokens[0]))
     throw new Error("Expected cablegrommet without an inline value");
   const props = { fn: "cablegrommet" };
@@ -6659,15 +6849,14 @@ function parseCableGrommetModelParams(raw) {
     const match = token.match(/^([a-z]+)(.*)$/i);
     const name = match?.[1]?.toLowerCase();
     const value = match?.[2];
-    if (!name || !value) throw new Error(`Invalid grommet token "${token}"`);
+    if (!name) throw new Error(`Invalid grommet token "${token}"`);
     let property;
     let parsed = value;
     if (name in lengths9) property = lengths9[name];
-    else if (name === "shape") {
-      property = "shape";
-      const selector = value.match(/^\(([a-z]+)\)$/i);
-      if (!selector) throw new Error("Grommet shape requires parentheses");
-      parsed = selector[1].toLowerCase();
+    else if (name === "symmetricring") {
+      property = "symmetricRing";
+      if (value !== "") throw new Error("symmetricring is a value-free flag");
+      parsed = true;
     } else throw new Error(`Unknown grommet token "${token}"`);
     if (property in props)
       throw new Error(`Grommet property "${property}" is set more than once`);
@@ -6678,13 +6867,7 @@ function parseCableGrommetModelParams(raw) {
 var model14 = defineModel({
   name: "cablegrommet",
   schema: cableGrommetModelDefinitionSchema,
-  parse: parseCableGrommetModelParams,
-  normalizeString: (value) => normalizeModelStringFlags(
-    value,
-    stringFlags3,
-    parseCableGrommetModelParams,
-    omittedStringFlags3
-  )
+  parse: parseCableGrommetModelParams
 });
 function register14(registry2) {
   registry2.register(model14);
@@ -6781,12 +6964,6 @@ var model15 = defineModel({
 function register15(registry2) {
   registry2.register(model15);
 }
-var stringFlags4 = {
-  singleclamp: "mount(singleclamp)",
-  lefthanded: "threadhand(left)",
-  righthanded: "threadhand(right)"
-};
-var omittedStringFlags4 = ["righthanded"];
 var length7 = external_exports.union([
   external_exports.number().finite(),
   external_exports.string().regex(
@@ -6807,10 +6984,10 @@ var shape12 = {
   splitWidth: positive3,
   clampX: positive3.optional(),
   clearanceHoleDiameter: positive3.optional(),
-  mount: external_exports.literal("singleclamp").default("singleclamp"),
+  singleClamp: external_exports.literal(true).default(true),
   metricSize: metricBoltSizeSchema,
   threadPitch: positive3.optional(),
-  threadHand: external_exports.enum(["right", "left"]).default("right"),
+  leftHanded: external_exports.boolean().default(false),
   threadClass: external_exports.literal("6H").default("6H"),
   chamfer: nonnegative2.default(0)
 };
@@ -6886,7 +7063,7 @@ function getClampingShaftCollarDimensions(input) {
       diameter: threadDiameter,
       depth: threadedExtent - p.splitWidth / 2,
       threadPitch: p.threadPitch,
-      threadHand: p.threadHand,
+      leftHanded: p.leftHanded,
       threadGender: "female",
       threadClass: p.threadClass
     }
@@ -6895,10 +7072,8 @@ function getClampingShaftCollarDimensions(input) {
 var tokenProperties = {
   bore: "boreDiameter",
   od: "outerDiameter",
-  mount: "mount",
   m: "metricSize",
   threadpitch: "threadPitch",
-  threadhand: "threadHand",
   threadclass: "threadClass",
   chamfer: "chamfer",
   w: "width",
@@ -6909,27 +7084,35 @@ var tokenProperties = {
   clearance: "clearanceHoleDiameter"
 };
 function parseClampingShaftCollarModelParams(raw) {
-  const tokens = splitModelStringTokens(
-    expandModelStringFlags(raw.string, stringFlags4)
-  );
+  const tokens = splitModelStringTokens(raw.string);
   if (raw.fn !== "clampingshaftcollar" || tokens[0]?.toLowerCase() !== "clampingshaftcollar")
     throw new Error("Expected an unadorned clampingshaftcollar function");
   const props = {};
   for (const token of tokens.slice(1)) {
     const match = token.match(/^([a-z]+)(.*)$/i);
     const name = match?.[1]?.toLowerCase() ?? "";
+    const value = match?.[2] ?? "";
+    if (["singleclamp", "lefthanded", "righthanded"].includes(name)) {
+      if (value) throw new Error(`Flag "${name}" does not take a value`);
+      const property2 = name === "singleclamp" ? "singleClamp" : "leftHanded";
+      if (property2 in props)
+        throw new Error(
+          `Duplicate or conflicting clampingshaftcollar flag "${property2}"`
+        );
+      props[property2] = name !== "righthanded";
+      continue;
+    }
     const property = tokenProperties[name];
     if (!property)
       throw new Error(`Unknown clampingshaftcollar token "${token}"`);
     if (property in props)
       throw new Error(`Duplicate clampingshaftcollar property "${property}"`);
-    const value = match[2];
     if (!value) throw new Error(`Token "${name}" requires a value`);
-    if (["mount", "threadHand", "threadClass"].includes(property)) {
+    if (property === "threadClass") {
       const argument = value.match(/^\(([^()]+)\)$/);
       if (!argument)
         throw new Error(`Token "${name}" requires one parenthesized argument`);
-      props[property] = property === "threadClass" ? argument[1].toUpperCase() : argument[1].toLowerCase();
+      props[property] = argument[1].toUpperCase();
     } else if (property === "metricSize") {
       if (!/^\d+(?:\.\d+)?$/.test(value))
         throw new Error("m requires a unitless metric designation");
@@ -6946,41 +7129,27 @@ function parseClampingShaftCollarModelParams(raw) {
 var model16 = defineModel({
   name: "clampingshaftcollar",
   schema: clampingShaftCollarModelDefinitionSchema,
-  parse: parseClampingShaftCollarModelParams,
-  normalizeString: (value) => normalizeModelStringFlags(
-    value,
-    stringFlags4,
-    parseClampingShaftCollarModelParams,
-    omittedStringFlags4
-  )
+  parse: parseClampingShaftCollarModelParams
 });
 function register16(registry2) {
   registry2.register(model16);
 }
-var stringFlags5 = {
-  closedground: "ends(closedground)",
-  lefthanded: "hand(left)",
-  righthanded: "hand(right)",
-  custom: "spec(custom)",
-  free: "state(free)"
-};
-var omittedStringFlags5 = ["righthanded", "custom", "free"];
 var length8 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
 ]).pipe(modelLengthSchema).refine((value) => value > 0, "Length must be positive");
 var turnCount = external_exports.number().int().min(1).max(Number.MAX_SAFE_INTEGER);
 var shape13 = {
-  spec: external_exports.literal("custom").default("custom"),
+  custom: external_exports.literal(true).default(true),
   outerDiameter: length8,
   wireDiameter: length8,
   freeLength: length8,
   totalTurns: turnCount.min(3),
   /** Closed-ground ends have exactly one inactive turn at each end. */
   activeTurns: turnCount.optional(),
-  ends: external_exports.literal("closedground").default("closedground"),
-  hand: external_exports.enum(["right", "left"]).default("right"),
-  state: external_exports.literal("free").default("free")
+  closedGround: external_exports.literal(true).default(true),
+  leftHanded: external_exports.boolean().default(false),
+  free: external_exports.literal(true).default(true)
 };
 function validate12(props, context) {
   if (props.outerDiameter <= 2 * props.wireDiameter)
@@ -7033,14 +7202,12 @@ function getCompressionSpringCenterlinePoint(input, turn) {
     throw new Error("Turn coordinate must be finite and within [0,totalTurns]");
   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 phase = (props.leftHanded ? -1 : 1) * 2 * Math.PI * (turn % 1);
   const z59 = 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: z59 };
 }
 function parseCompressionSpringModelParams(raw) {
-  const tokens = splitModelStringTokens(
-    expandModelStringFlags(raw.string, stringFlags5)
-  );
+  const tokens = splitModelStringTokens(raw.string);
   if (raw.fn !== "compressionspring" || tokens[0]?.toLowerCase() !== "compressionspring")
     throw new Error("Expected compressionspring without an inline argument");
   const props = { fn: "compressionspring" };
@@ -7051,11 +7218,12 @@ function parseCompressionSpringModelParams(raw) {
     length: "freeLength",
     freelength: "freeLength"
   };
-  const selectors7 = {
-    spec: "spec",
-    ends: "ends",
-    hand: "hand",
-    state: "state"
+  const flags11 = {
+    custom: "custom",
+    closedground: "closedGround",
+    free: "free",
+    lefthanded: "leftHanded",
+    righthanded: "leftHanded"
   };
   for (const token of tokens.slice(1)) {
     const match = token.match(/^([a-z]+)(.*)$/i);
@@ -7070,11 +7238,10 @@ function parseCompressionSpringModelParams(raw) {
       if (!/^\d+$/.test(value))
         throw new Error(`${name} requires a unitless integer`);
       parsed = Number(value);
-    } else if (name in selectors7) {
-      property = selectors7[name];
-      if (!/^\([^()]+\)$/.test(value))
-        throw new Error(`Expected a parenthesized ${name}`);
-      parsed = value.slice(1, -1).toLowerCase();
+    } else if (Object.hasOwn(flags11, name)) {
+      if (value) throw new Error(`Flag "${name}" does not take a value`);
+      property = flags11[name];
+      parsed = name !== "righthanded";
     } else throw new Error(`Unknown compression spring token "${token}"`);
     if (property in props)
       throw new Error(`Duplicate compression spring property "${property}"`);
@@ -7085,13 +7252,7 @@ function parseCompressionSpringModelParams(raw) {
 var model17 = defineModel({
   name: "compressionspring",
   schema: compressionSpringModelDefinitionSchema,
-  parse: parseCompressionSpringModelParams,
-  normalizeString: (value) => normalizeModelStringFlags(
-    value,
-    stringFlags5,
-    parseCompressionSpringModelParams,
-    omittedStringFlags5
-  )
+  parse: parseCompressionSpringModelParams
 });
 function register17(registry2) {
   registry2.register(model17);
@@ -7544,7 +7705,7 @@ var aliases4 = {
   threadrootdiameter: "threadRootDiameter",
   threadpitchdiameter: "threadPitchDiameter"
 };
-var flags2 = {
+var flags3 = {
   fullthread: "fullThread",
   plainface: "plainFace",
   lefthanded: "leftHand",
@@ -7570,9 +7731,9 @@ function parseFlangeBoltModelParams(raw) {
     const value = match?.[2] ?? "";
     let property;
     let parsed;
-    if (flags2[key]) {
+    if (flags3[key]) {
       if (value) throw new Error(`Flag ${key} does not accept a value`);
-      property = flags2[key];
+      property = flags3[key];
       parsed = !["righthanded", "nothreads"].includes(key);
     } else {
       if (key === "standard" || key === "headstandard")
@@ -7610,10 +7771,6 @@ var model20 = defineModel({
 function register20(registry2) {
   registry2.register(model20);
 }
-var stringFlags6 = {
-  plainclosed: "style(plainclosed)"
-};
-var omittedStringFlags6 = ["plainclosed"];
 var positiveLength6 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
@@ -7625,7 +7782,7 @@ var shape17 = {
   /** Overall end-plane distance including the integral flange. */
   length: positiveLength6,
   flangeThickness: positiveLength6,
-  style: external_exports.literal("plainclosed").default("plainclosed")
+  plainClosed: external_exports.literal(true).default(true)
 };
 function validate16(props, context) {
   if (props.outerDiameter <= props.innerDiameter)
@@ -7675,9 +7832,7 @@ var lengths12 = {
   flangethickness: "flangeThickness"
 };
 function parseFlangedBushingModelParams(raw) {
-  const tokens = splitModelStringTokens(
-    expandModelStringFlags(raw.string, stringFlags6)
-  );
+  const tokens = splitModelStringTokens(raw.string);
   if (raw.fn !== "flangedbushing" || tokens[0]?.toLowerCase() !== "flangedbushing")
     throw new Error("Expected flangedbushing without an inline value");
   const props = { fn: "flangedbushing" };
@@ -7691,11 +7846,10 @@ function parseFlangedBushingModelParams(raw) {
     if (Object.hasOwn(lengths12, name)) {
       property = lengths12[name];
       parsed = value;
-    } else if (name === "style") {
-      property = "style";
-      const style = value.match(/^\(([a-z]+)\)$/i);
-      if (!style) throw new Error("Style requires a parenthesized value");
-      parsed = style[1].toLowerCase();
+    } else if (name === "plainclosed") {
+      property = "plainClosed";
+      if (value !== "") throw new Error("plainclosed is a value-free flag");
+      parsed = true;
     } else throw new Error(`Unknown flanged bushing token "${token}"`);
     if (Object.hasOwn(props, property))
       throw new Error(
@@ -7708,13 +7862,7 @@ function parseFlangedBushingModelParams(raw) {
 var model21 = defineModel({
   name: "flangedbushing",
   schema: flangedBushingModelDefinitionSchema,
-  parse: parseFlangedBushingModelParams,
-  normalizeString: (value) => normalizeModelStringFlags(
-    value,
-    stringFlags6,
-    parseFlangedBushingModelParams,
-    omittedStringFlags6
-  )
+  parse: parseFlangedBushingModelParams
 });
 function register21(registry2) {
   registry2.register(model21);
@@ -8072,10 +8220,7 @@ var lengths13 = {
   outerdiameter: "outerDiameter",
   thickness: "thickness"
 };
-var flags3 = { flatannulus: "flatAnnulus" };
-var selectors2 = {
-  profile: { value: "flatannulus", property: "flatAnnulus" }
-};
+var flags4 = { flatannulus: "flatAnnulus" };
 var integers = {};
 var tuples = {};
 function parseFlatGasketModelParams(raw) {
@@ -8093,9 +8238,7 @@ function parseFlatGasketModelParams(raw) {
     if (!match) throw new Error(`Malformed flatgasket token "${token}"`);
     const key = match[1].toLowerCase(), value = match[2];
     if (Object.hasOwn(lengths13, key) && value) assign(lengths13[key], value);
-    else if (Object.hasOwn(flags3, key) && !value) assign(flags3[key], true);
-    else if (Object.hasOwn(selectors2, key) && value.toLowerCase() === `(${selectors2[key].value})`)
-      assign(selectors2[key].property, true);
+    else if (Object.hasOwn(flags4, key) && !value) assign(flags4[key], true);
     else if (Object.hasOwn(integers, key) && /^\d+$/.test(value))
       assign(integers[key], Number(value));
     else if (Object.hasOwn(tuples, key)) {
@@ -8116,14 +8259,6 @@ var model24 = defineModel({
 function register24(registry2) {
   registry2.register(model24);
 }
-var stringFlags7 = {
-  hexsocket: "drive(hexsocket)",
-  fullthread: "thread(full)",
-  lefthanded: "threadhand(left)",
-  righthanded: "threadhand(right)",
-  male: "threadgender(male)"
-};
-var omittedStringFlags7 = ["righthanded", "male"];
 var positiveModelLengthSchema3 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^(?:\d+(?:\.\d+)?|\.\d+)(?:mm|cm|m|in|inch)?$/i).transform((value) => value.toLowerCase())
@@ -8199,11 +8334,11 @@ var flatHeadScrewModelPropsShape = {
   iso10642: external_exports.literal(true).default(true),
   metricSize: flatHeadScrewMetricSizeSchema,
   length: positiveModelLengthSchema3,
-  thread: external_exports.literal("full").default("full"),
-  drive: external_exports.literal("hexsocket").default("hexsocket"),
-  threadHand: external_exports.enum(["right", "left"]).default("right"),
+  fullThread: external_exports.literal(true).default(true),
+  hexSocket: external_exports.literal(true).default(true),
+  leftHanded: external_exports.boolean().default(false),
   threadClass: external_exports.literal("6g").default("6g"),
-  threadGender: external_exports.literal("male").default("male"),
+  male: external_exports.literal(true).default(true),
   showThreads: external_exports.boolean().default(true),
   diameter: positiveModelLengthSchema3.optional(),
   threadPitch: positiveModelLengthSchema3.optional(),
@@ -8269,11 +8404,7 @@ var aliases5 = {
   metricsize: "metricSize",
   l: "length",
   length: "length",
-  thread: "thread",
-  drive: "drive",
-  threadhand: "threadHand",
   threadclass: "threadClass",
-  threadgender: "threadGender",
   diameter: "diameter",
   threadpitch: "threadPitch",
   headdiameter: "headDiameter",
@@ -8294,19 +8425,18 @@ var aliases5 = {
   socketaf: "socketAcrossFlats",
   socketh: "socketDepth"
 };
-var selectors3 = /* @__PURE__ */ new Set([
-  "thread",
-  "drive",
-  "threadHand",
-  "threadClass",
-  "threadGender"
-]);
+var selectors2 = /* @__PURE__ */ new Set(["threadClass"]);
+var booleanFlags2 = {
+  hexsocket: { property: "hexSocket", value: true },
+  fullthread: { property: "fullThread", value: true },
+  male: { property: "male", value: true },
+  lefthanded: { property: "leftHanded", value: true },
+  righthanded: { property: "leftHanded", value: false }
+};
 var parseFlatHeadScrewModelParams = (raw) => {
   if (raw.fn !== "flatheadscrew")
     throw new Error(`Expected flatheadscrew params, got "${raw.fn}"`);
-  const [root, ...tokens] = splitModelStringTokens(
-    expandModelStringFlags(raw.string, stringFlags7)
-  );
+  const [root, ...tokens] = splitModelStringTokens(raw.string);
   if (root?.toLowerCase() !== "flatheadscrew")
     throw new Error(
       "The flatheadscrew function does not accept an inline value"
@@ -8324,16 +8454,20 @@ var parseFlatHeadScrewModelParams = (raw) => {
     const value = match?.[2];
     let property;
     let parsed;
-    if (key === "threads" || key === "nothreads") {
+    if (key && Object.hasOwn(booleanFlags2, key)) {
+      if (value !== "") throw new Error(`Flag "${key}" does not accept a value`);
+      property = booleanFlags2[key].property;
+      parsed = booleanFlags2[key].value;
+    } else if (key === "threads" || key === "nothreads") {
       if (value !== "")
         throw new Error(`Token "${key}" does not accept a value`);
       property = "showThreads";
       parsed = key === "threads";
     } else {
-      property = key ? aliases5[key] ?? "" : "";
+      property = key && Object.hasOwn(aliases5, key) ? aliases5[key] : "";
       if (!property || !value)
         throw new Error(`Unknown or missing flatheadscrew token "${token}"`);
-      if (selectors3.has(property)) {
+      if (selectors2.has(property)) {
         const selector = value.match(/^\(([^()]+)\)$/)?.[1];
         if (!selector)
           throw new Error(`Token "${key}" requires a parenthesized selector`);
@@ -8363,13 +8497,7 @@ var parseFlatHeadScrewModelParams = (raw) => {
 var model25 = defineModel({
   name: "flatheadscrew",
   schema: flatHeadScrewModelDefinitionSchema,
-  parse: parseFlatHeadScrewModelParams,
-  normalizeString: (value) => normalizeModelStringFlags(
-    value,
-    stringFlags7,
-    parseFlatHeadScrewModelParams,
-    omittedStringFlags7
-  )
+  parse: parseFlatHeadScrewModelParams
 });
 function register25(registry2) {
   registry2.register(model25);
@@ -8530,7 +8658,7 @@ var aliases7 = {
   threadpitchdiameter: "threadPitchDiameter",
   rootouterdiameter: "rootOuterDiameter"
 };
-var flags4 = {
+var flags5 = {
   diamondknurl: "diamondKnurl",
   lefthanded: "leftHand",
   righthanded: "leftHand",
@@ -8547,9 +8675,9 @@ function parseHeatSetInsertModelParams(raw) {
   for (const token of tokens) {
     const match = token.match(/^([a-z]+)(.*)$/i), key = match?.[1]?.toLowerCase() ?? "", value = match?.[2] ?? "";
     let property, parsed;
-    if (flags4[key]) {
+    if (flags5[key]) {
       if (value) throw new Error("Flags do not accept values");
-      property = flags4[key];
+      property = flags5[key];
       parsed = !["righthanded", "nothreads"].includes(key);
     } else {
       property = aliases7[key] ?? "";
@@ -8586,10 +8714,6 @@ var model27 = defineModel({
 function register27(registry2) {
   registry2.register(model27);
 }
-var stringFlags8 = {
-  righthanded: "threadhand(right)"
-};
-var omittedStringFlags8 = ["righthanded"];
 var hexNutDimensions = {
   M5: {
     diameter: 5,
@@ -8830,7 +8954,7 @@ var shape23 = {
   metricSize: hexNutMetricSizeSchema.optional(),
   imperialSize: hexNutImperialSizeSchema.optional(),
   threadPitch: length13.optional(),
-  threadHand: external_exports.literal("right").default("right"),
+  rightHanded: external_exports.literal(true).default(true),
   threadClass: external_exports.enum(["6H", "2B"]).optional(),
   showThreads: external_exports.boolean().default(true)
 };
@@ -8856,11 +8980,11 @@ function validate22(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 flags10 = ["iso4032", "din934", "asmeb1822"];
+  const flags11 = ["iso4032", "din934", "asmeb1822"];
   const family = selectedFamily(props);
-  if (flags10.filter((flag) => props[flag] === true).length > 1)
+  if (flags11.filter((flag) => props[flag] === true).length > 1)
     issue("iso4032", "Select only one ISO, DIN or ASME family");
-  for (const flag of flags10)
+  for (const flag of flags11)
     if (family[flag] && props[flag] === false)
       issue(
         flag,
@@ -8908,14 +9032,11 @@ function getHexNutDimensions(input) {
   };
 }
 function parseHexNutModelParams(raw) {
-  const tokens = splitModelStringTokens(
-    expandModelStringFlags(raw.string, stringFlags8)
-  );
+  const tokens = splitModelStringTokens(raw.string);
   if (raw.fn !== "hexnut" || tokens[0]?.toLowerCase() !== "hexnut")
     throw new Error("Expected hexnut without an inline argument");
   const props = { fn: "hexnut" };
-  const selectors7 = {
-    threadhand: "threadHand",
+  const selectors5 = {
     threadclass: "threadClass"
   };
   let explicitFamily = false;
@@ -8952,9 +9073,13 @@ function parseHexNutModelParams(raw) {
           throw new Error("Duplicate hex nut property threadPitch");
         props.threadPitch = 25.4 / Number(parts[1]);
       }
+    } else if (name === "righthanded") {
+      if (value) throw new Error("Handedness flags cannot have a value");
+      property = "rightHanded";
+      parsed = true;
     } else if (name === "threadpitch") property = "threadPitch";
-    else if (name in selectors7) {
-      property = selectors7[name];
+    else if (name in selectors5) {
+      property = selectors5[name];
       if (!/^\([^()]+\)$/.test(value))
         throw new Error(`Expected a parenthesized ${name}`);
       parsed = value.slice(1, -1).toLowerCase();
@@ -8973,13 +9098,7 @@ function parseHexNutModelParams(raw) {
 var model28 = defineModel({
   name: "hexnut",
   schema: hexNutModelDefinitionSchema,
-  parse: parseHexNutModelParams,
-  normalizeString: (value) => normalizeModelStringFlags(
-    value,
-    stringFlags8,
-    parseHexNutModelParams,
-    omittedStringFlags8
-  )
+  parse: parseHexNutModelParams
 });
 function register28(registry2) {
   registry2.register(model28);
@@ -9241,7 +9360,7 @@ var lengths15 = {
   studchamfer: "studChamfer",
   mouthchamfer: "mouthChamfer"
 };
-var flags5 = {
+var flags6 = {
   hex: ["hex", true],
   lefthanded: ["leftHand", true],
   righthanded: ["leftHand", false],
@@ -9257,8 +9376,8 @@ function parseMaleFemaleStandoffModelParams(raw) {
     const lower = token.toLowerCase();
     let property;
     let value;
-    if (Object.hasOwn(flags5, lower)) {
-      const entry = flags5[lower];
+    if (Object.hasOwn(flags6, lower)) {
+      const entry = flags6[lower];
       property = entry[0];
       value = entry[1];
     } else {
@@ -9443,14 +9562,6 @@ var model31 = defineModel({
 function register31(registry2) {
   registry2.register(model31);
 }
-var stringFlags9 = {
-  phillips: "drive(phillips)",
-  fullthread: "thread(full)",
-  lefthanded: "threadhand(left)",
-  righthanded: "threadhand(right)",
-  male: "threadgender(male)"
-};
-var omittedStringFlags9 = ["righthanded", "male"];
 var positiveModelLengthSchema4 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^(?:\d+(?:\.\d+)?|\.\d+)(?:mm|cm|m|in|inch)?$/i).transform((value) => value.toLowerCase())
@@ -9574,11 +9685,11 @@ var panScrewModelPropsShape = {
   iso7045: external_exports.literal(true).default(true),
   metricSize: panScrewMetricSizeSchema,
   length: positiveModelLengthSchema4,
-  thread: external_exports.literal("full").default("full"),
-  drive: external_exports.literal("phillips").default("phillips"),
-  threadHand: external_exports.enum(["right", "left"]).default("right"),
+  fullThread: external_exports.literal(true).default(true),
+  phillips: external_exports.literal(true).default(true),
+  leftHanded: external_exports.boolean().default(false),
   threadClass: external_exports.literal("6g").default("6g"),
-  threadGender: external_exports.literal("male").default("male"),
+  male: external_exports.literal(true).default(true),
   showThreads: external_exports.boolean().default(true),
   iso4757: external_exports.literal(true).default(true),
   recessType: external_exports.literal("H").default("H"),
@@ -9645,11 +9756,7 @@ var aliases8 = {
   metricsize: "metricSize",
   l: "length",
   length: "length",
-  thread: "thread",
-  drive: "drive",
-  threadhand: "threadHand",
   threadclass: "threadClass",
-  threadgender: "threadGender",
   diameter: "diameter",
   threadpitch: "threadPitch",
   headdiameter: "headDiameter",
@@ -9680,19 +9787,18 @@ var aliases8 = {
   headh: "headHeight",
   headd: "headDiameter"
 };
-var selectors4 = /* @__PURE__ */ new Set([
-  "thread",
-  "drive",
-  "threadHand",
-  "threadClass",
-  "threadGender"
-]);
+var selectors3 = /* @__PURE__ */ new Set(["threadClass"]);
+var booleanFlags3 = {
+  phillips: { property: "phillips", value: true },
+  fullthread: { property: "fullThread", value: true },
+  male: { property: "male", value: true },
+  lefthanded: { property: "leftHanded", value: true },
+  righthanded: { property: "leftHanded", value: false }
+};
 var parsePanScrewModelParams = (raw) => {
   if (raw.fn !== "panscrew")
     throw new Error(`Expected panscrew params, got "${raw.fn}"`);
-  const [root, ...tokens] = splitModelStringTokens(
-    expandModelStringFlags(raw.string, stringFlags9)
-  );
+  const [root, ...tokens] = splitModelStringTokens(raw.string);
   if (root?.toLowerCase() !== "panscrew")
     throw new Error("The panscrew function does not accept an inline value");
   const props = {};
@@ -9709,16 +9815,20 @@ var parsePanScrewModelParams = (raw) => {
     const value = match?.[2];
     let property;
     let parsed;
-    if (key === "threads" || key === "nothreads") {
+    if (key && Object.hasOwn(booleanFlags3, key)) {
+      if (value !== "") throw new Error(`Flag "${key}" does not accept a value`);
+      property = booleanFlags3[key].property;
+      parsed = booleanFlags3[key].value;
+    } else if (key === "threads" || key === "nothreads") {
       if (value !== "")
         throw new Error(`Token "${key}" does not accept a value`);
       property = "showThreads";
       parsed = key === "threads";
     } else {
-      property = key ? aliases8[key] ?? "" : "";
+      property = key && Object.hasOwn(aliases8, key) ? aliases8[key] : "";
       if (!property || !value)
         throw new Error(`Unknown or missing panscrew token "${token}"`);
-      if (selectors4.has(property)) {
+      if (selectors3.has(property)) {
         const selector = value.match(/^\(([^()]+)\)$/)?.[1];
         if (!selector)
           throw new Error(`Token "${key}" requires a parenthesized selector`);
@@ -9751,13 +9861,7 @@ var parsePanScrewModelParams = (raw) => {
 var model32 = defineModel({
   name: "panscrew",
   schema: panScrewModelDefinitionSchema,
-  parse: parsePanScrewModelParams,
-  normalizeString: (value) => normalizeModelStringFlags(
-    value,
-    stringFlags9,
-    parsePanScrewModelParams,
-    omittedStringFlags9
-  )
+  parse: parsePanScrewModelParams
 });
 function register32(registry2) {
   registry2.register(model32);
@@ -9943,10 +10047,6 @@ var model34 = defineModel({
 function register34(registry2) {
   registry2.register(model34);
 }
-var stringFlags10 = {
-  plainclosed: "style(plainclosed)"
-};
-var omittedStringFlags10 = ["plainclosed"];
 var length18 = external_exports.union([
   external_exports.number(),
   external_exports.string().regex(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|m|in|inch|mil|ft|feet)?$/i).transform((value) => value.toLowerCase())
@@ -9957,7 +10057,7 @@ var shape29 = {
   outerDiameter: positiveLength12,
   /** Overall end-plane distance, including the chamfers. */
   length: positiveLength12,
-  style: external_exports.literal("plainclosed").default("plainclosed"),
+  plainClosed: external_exports.literal(true).default(true),
   /** Equal axial/radial setbacks of all four 45-degree bore/outside rim chamfers. */
   edgeChamfer: length18.refine((value) => value >= 0).default(0)
 };
@@ -10005,9 +10105,7 @@ var lengths16 = {
   edgechamfer: "edgeChamfer"
 };
 function parsePlainBushingModelParams(raw) {
-  const tokens = splitModelStringTokens(
-    expandModelStringFlags(raw.string, stringFlags10)
-  );
+  const tokens = splitModelStringTokens(raw.string);
   if (raw.fn !== "plainbushing" || tokens[0]?.toLowerCase() !== "plainbushing")
     throw new Error("Expected plainbushing without an inline value");
   const props = { fn: "plainbushing" };
@@ -10021,11 +10119,10 @@ function parsePlainBushingModelParams(raw) {
     if (Object.hasOwn(lengths16, name)) {
       property = lengths16[name];
       parsed = value;
-    } else if (name === "style") {
-      property = "style";
-      const style = value.match(/^\(([a-z]+)\)$/i);
-      if (!style) throw new Error("Style requires a parenthesized value");
-      parsed = style[1].toLowerCase();
+    } else if (name === "plainclosed") {
+      property = "plainClosed";
+      if (value !== "") throw new Error("plainclosed is a value-free flag");
+      parsed = true;
     } else throw new Error(`Unknown plain bushing token "${token}"`);
     if (Object.hasOwn(props, property))
       throw new Error(
@@ -10038,13 +10135,7 @@ function parsePlainBushingModelParams(raw) {
 var model35 = defineModel({
   name: "plainbushing",
   schema: plainBushingModelDefinitionSchema,
-  parse: parsePlainBushingModelParams,
-  normalizeString: (value) => normalizeModelStringFlags(
-    value,
-    stringFlags10,
-    parsePlainBushingModelParams,
-    omittedStringFlags10
-  )
+  parse: parsePlainBushingModelParams
 });
 function register35(registry2) {
   registry2.register(model35);
@@ -10242,10 +10333,7 @@ var lengths17 = {
   thickness: "thickness",
   cornerradius: "cornerRadius"
 };
-var flags6 = { flatframe: "flatFrame" };
-var selectors5 = {
-  profile: { value: "flatframe", property: "flatFrame" }
-};
+var flags7 = { flatframe: "flatFrame" };
 var integers2 = {};
 var tuples2 = {};
 function parseRectangularGasketModelParams(raw) {
@@ -10263,9 +10351,7 @@ function parseRectangularGasketModelParams(raw) {
     if (!match) throw new Error(`Malformed rectangulargasket token "${token}"`);
     const key = match[1].toLowerCase(), value = match[2];
     if (Object.hasOwn(lengths17, key) && value) assign(lengths17[key], value);
-    else if (Object.hasOwn(flags6, key) && !value) assign(flags6[key], true);
-    else if (Object.hasOwn(selectors5, key) && value.toLowerCase() === `(${selectors5[key].value})`)
-      assign(selectors5[key].property, true);
+    else if (Object.hasOwn(flags7, key) && !value) assign(flags7[key], true);
     else if (Object.hasOwn(integers2, key) && /^\d+$/.test(value))
       assign(integers2[key], Number(value));
     else if (Object.hasOwn(tuples2, key)) {
@@ -10371,12 +10457,6 @@ var model39 = defineModel({
 function register39(registry2) {
   registry2.register(model39);
 }
-var stringFlags11 = {
-  setscrew: "mount(setscrew)",
-  lefthanded: "threadhand(left)",
-  righthanded: "threadhand(right)"
-};
-var omittedStringFlags11 = ["righthanded"];
 var length23 = external_exports.union([
   external_exports.number().finite(),
   external_exports.string().regex(
@@ -10397,10 +10477,10 @@ var shape34 = {
   screwCount: external_exports.literal(4).default(4),
   screwEndOffset: positive6.optional(),
   screwAngle: external_exports.number().finite().default(0),
-  mount: external_exports.literal("setscrew").default("setscrew"),
+  setScrew: external_exports.literal(true).default(true),
   metricSize: metricBoltSizeSchema,
   threadPitch: positive6.optional(),
-  threadHand: external_exports.enum(["right", "left"]).default("right"),
+  leftHanded: external_exports.boolean().default(false),
   threadClass: external_exports.literal("6H").default("6H"),
   chamfer: nonnegative5.default(0)
 };
@@ -10469,7 +10549,7 @@ function getRigidCouplerDimensions(input) {
       diameter: threadDiameter,
       depth: radius - Math.sqrt((hole.bore / 2) ** 2 - (threadDiameter / 2) ** 2),
       threadPitch: p.threadPitch,
-      threadHand: p.threadHand,
+      leftHanded: p.leftHanded,
       threadGender: "female",
       threadClass: p.threadClass
     };
@@ -10484,10 +10564,8 @@ function getRigidCouplerDimensions(input) {
 var tokenProperties2 = {
   bore: "boreDiameter",
   od: "outerDiameter",
-  mount: "mount",
   m: "metricSize",
   threadpitch: "threadPitch",
-  threadhand: "threadHand",
   threadclass: "threadClass",
   chamfer: "chamfer",
   boreb: "boreBDiameter",
@@ -10498,26 +10576,34 @@ var tokenProperties2 = {
   screwangle: "screwAngle"
 };
 function parseRigidCouplerModelParams(raw) {
-  const tokens = splitModelStringTokens(
-    expandModelStringFlags(raw.string, stringFlags11)
-  );
+  const tokens = splitModelStringTokens(raw.string);
   if (raw.fn !== "rigidcoupler" || tokens[0]?.toLowerCase() !== "rigidcoupler")
     throw new Error("Expected an unadorned rigidcoupler function");
   const props = {};
   for (const token of tokens.slice(1)) {
     const match = token.match(/^([a-z]+)(.*)$/i);
     const name = match?.[1]?.toLowerCase() ?? "";
+    const value = match?.[2] ?? "";
+    if (["setscrew", "lefthanded", "righthanded"].includes(name)) {
+      if (value) throw new Error(`Flag "${name}" does not take a value`);
+      const property2 = name === "setscrew" ? "setScrew" : "leftHanded";
+      if (property2 in props)
+        throw new Error(
+          `Duplicate or conflicting rigidcoupler flag "${property2}"`
+        );
+      props[property2] = name !== "righthanded";
+      continue;
+    }
     const property = tokenProperties2[name];
     if (!property) throw new Error(`Unknown rigidcoupler token "${token}"`);
     if (property in props)
       throw new Error(`Duplicate rigidcoupler property "${property}"`);
-    const value = match[2];
     if (!value) throw new Error(`Token "${name}" requires a value`);
-    if (["mount", "threadHand", "threadClass"].includes(property)) {
+    if (property === "threadClass") {
       const argument = value.match(/^\(([^()]+)\)$/);
       if (!argument)
         throw new Error(`Token "${name}" requires one parenthesized argument`);
-      props[property] = property === "threadClass" ? argument[1].toUpperCase() : argument[1].toLowerCase();
+      props[property] = argument[1].toUpperCase();
     } else if (property === "metricSize") {
       if (!/^\d+(?:\.\d+)?$/.test(value))
         throw new Error("m requires a unitless metric designation");
@@ -10542,13 +10628,7 @@ function parseRigidCouplerModelParams(raw) {
 var model40 = defineModel({
   name: "rigidcoupler",
   schema: rigidCouplerModelDefinitionSchema,
-  parse: parseRigidCouplerModelParams,
-  normalizeString: (value) => normalizeModelStringFlags(
-    value,
-    stringFlags11,
-    parseRigidCouplerModelParams,
-    omittedStringFlags11
-  )
+  parse: parseRigidCouplerModelParams
 });
 function register40(registry2) {
   registry2.register(model40);
@@ -10664,7 +10744,7 @@ var aliases14 = {
   threadrootdiameter: "threadRootDiameter",
   threadpitchdiameter: "threadPitchDiameter"
 };
-var flags7 = {
+var flags8 = {
   hexsocket: "hexSocket",
   cuppoint: "cupPoint",
   lefthanded: "leftHand",
@@ -10690,9 +10770,9 @@ function parseSetScrewModelParams(raw) {
     const value = match?.[2] ?? "";
     let property;
     let parsed;
-    if (flags7[key]) {
+    if (flags8[key]) {
       if (value) throw new Error(`Flag ${key} does not accept a value`);
-      property = flags7[key];
+      property = flags8[key];
       parsed = !["righthanded", "nothreads"].includes(key);
     } else {
       property = aliases14[key] ?? "";
@@ -10726,12 +10806,6 @@ var model41 = defineModel({
 function register41(registry2) {
   registry2.register(model41);
 }
-var stringFlags12 = {
-  setscrew: "mount(setscrew)",
-  lefthanded: "threadhand(left)",
-  righthanded: "threadhand(right)"
-};
-var omittedStringFlags12 = ["righthanded"];
 var length24 = external_exports.union([
   external_exports.number().finite(),
   external_exports.string().regex(
@@ -10750,10 +10824,10 @@ var shape36 = {
   width: positive7,
   screwZ: positive7.optional(),
   screwAngle: external_exports.number().finite().default(0),
-  mount: external_exports.literal("setscrew").default("setscrew"),
+  setScrew: external_exports.literal(true).default(true),
   metricSize: metricBoltSizeSchema,
   threadPitch: positive7.optional(),
-  threadHand: external_exports.enum(["right", "left"]).default("right"),
+  leftHanded: external_exports.boolean().default(false),
   threadClass: external_exports.literal("6H").default("6H"),
   chamfer: nonnegative6.default(0)
 };
@@ -10803,7 +10877,7 @@ function getShaftCollarDimensions(input) {
       diameter: threadDiameter,
       depth: radius - Math.sqrt((p.boreDiameter / 2) ** 2 - (threadDiameter / 2) ** 2),
       threadPitch: p.threadPitch,
-      threadHand: p.threadHand,
+      leftHanded: p.leftHanded,
       threadGender: "female",
       threadClass: p.threadClass
     }
@@ -10812,10 +10886,8 @@ function getShaftCollarDimensions(input) {
 var tokenProperties3 = {
   bore: "boreDiameter",
   od: "outerDiameter",
-  mount: "mount",
   m: "metricSize",
   threadpitch: "threadPitch",
-  threadhand: "threadHand",
   threadclass: "threadClass",
   chamfer: "chamfer",
   w: "width",
@@ -10824,26 +10896,34 @@ var tokenProperties3 = {
   screwangle: "screwAngle"
 };
 function parseShaftCollarModelParams(raw) {
-  const tokens = splitModelStringTokens(
-    expandModelStringFlags(raw.string, stringFlags12)
-  );
+  const tokens = splitModelStringTokens(raw.string);
   if (raw.fn !== "shaftcollar" || tokens[0]?.toLowerCase() !== "shaftcollar")
     throw new Error("Expected an unadorned shaftcollar function");
   const props = {};
   for (const token of tokens.slice(1)) {
     const match = token.match(/^([a-z]+)(.*)$/i);
     const name = match?.[1]?.toLowerCase() ?? "";
+    const value = match?.[2] ?? "";
+    if (["setscrew", "lefthanded", "righthanded"].includes(name)) {
+      if (value) throw new Error(`Flag "${name}" does not take a value`);
+      const property2 = name === "setscrew" ? "setScrew" : "leftHanded";
+      if (property2 in props)
+        throw new Error(
+          `Duplicate or conflicting shaftcollar flag "${property2}"`
+        );
+      props[property2] = name !== "righthanded";
+      continue;
+    }
     const property = tokenProperties3[name];
     if (!property) throw new Error(`Unknown shaftcollar token "${token}"`);
     if (property in props)
       throw new Error(`Duplicate shaftcollar property "${property}"`);
-    const value = match[2];
     if (!value) throw new Error(`Token "${name}" requires a value`);
-    if (["mount", "threadHand", "threadClass"].includes(property)) {
+    if (property === "threadClass") {
       const argument = value.match(/^\(([^()]+)\)$/);
       if (!argument)
         throw new Error(`Token "${name}" requires one parenthesized argument`);
-      props[property] = property === "threadClass" ? argument[1].toUpperCase() : argument[1].toLowerCase();
+      props[property] = argument[1].toUpperCase();
     } else if (property === "metricSize") {
       if (!/^\d+(?:\.\d+)?$/.test(value))
         throw new Error("m requires a unitless metric designation");
@@ -10861,13 +10941,7 @@ function parseShaftCollarModelParams(raw) {
 var model42 = defineModel({
   name: "shaftcollar",
   schema: shaftCollarModelDefinitionSchema,
-  parse: parseShaftCollarModelParams,
-  normalizeString: (value) => normalizeModelStringFlags(
-    value,
-    stringFlags12,
-    parseShaftCollarModelParams,
-    omittedStringFlags12
-  )
+  parse: parseShaftCollarModelParams
 });
 function register42(registry2) {
   registry2.register(model42);
@@ -11137,8 +11211,8 @@ var lengths18 = {
   groovedepth: "grooveDepth",
   splitwidth: "splitWidth"
 };
-var flags8 = {};
-var selectors6 = {};
+var flags9 = {};
+var selectors4 = {};
 var integers3 = {};
 var tuples3 = {};
 function parseSplitGrommetModelParams(raw) {
@@ -11156,9 +11230,9 @@ function parseSplitGrommetModelParams(raw) {
     if (!match) throw new Error(`Malformed splitgrommet token "${token}"`);
     const key = match[1].toLowerCase(), value = match[2];
     if (Object.hasOwn(lengths18, key) && value) assign(lengths18[key], value);
-    else if (Object.hasOwn(flags8, key) && !value) assign(flags8[key], true);
-    else if (Object.hasOwn(selectors6, key) && value.toLowerCase() === `(${selectors6[key].value})`)
-      assign(selectors6[key].property, true);
+    else if (Object.hasOwn(flags9, key) && !value) assign(flags9[key], true);
+    else if (Object.hasOwn(selectors4, key) && value.toLowerCase() === `(${selectors4[key].value})`)
+      assign(selectors4[key].property, true);
     else if (Object.hasOwn(integers3, key) && /^\d+$/.test(value))
       assign(integers3[key], Number(value));
     else if (Object.hasOwn(tuples3, key)) {
@@ -11607,12 +11681,9 @@ var aliases17 = {
   barbh: "barbHeight",
   barbheight: "barbHeight"
 };
-var flags9 = {
+var flags10 = {
   tee: "tee"
 };
-var literals = {
-  profile: ["tee", "tee"]
-};
 function parseTSlotCoverStripModelParams(raw) {
   const [name, ...tokens] = splitModelStringTokens(raw.string);
   if (raw.fn !== "tslotcoverstrip" || name?.toLowerCase() !== "tslotcoverstrip")
@@ -11629,15 +11700,10 @@ function parseTSlotCoverStripModelParams(raw) {
     const value = match?.[2];
     if (!key || value === void 0)
       throw new Error(`Malformed tslotcoverstrip token "${token}"`);
-    if (Object.hasOwn(flags9, key)) {
+    if (Object.hasOwn(flags10, key)) {
       if (value !== "")
         throw new Error(`tslotcoverstrip flag "${key}" takes no value`);
-      assign(flags9[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);
+      assign(flags10[key], true);
     } else if (Object.hasOwn(aliases17, key) && value) {
       const property = aliases17[key];
       assign(property, property === "pinCount" ? Number(value) : value);
@@ -11654,15 +11720,11 @@ var model49 = defineModel({
 function register49(registry2) {
   registry2.register(model49);
 }
-var stringFlags13 = {
-  fourtsolid: "profile(fourtsolid)"
-};
-var omittedStringFlags13 = [];
 var shape44 = {
   width: positiveGearLengthSchema.default(20),
   height: positiveGearLengthSchema.default(20),
   length: positiveGearLengthSchema.default(100),
-  profile: external_exports.literal("fourtsolid").default("fourtsolid"),
+  fourTSolid: external_exports.literal(true).default(true),
   slotWidth: positiveGearLengthSchema.default(6),
   pocketWidth: positiveGearLengthSchema.default(10),
   pocketDepth: positiveGearLengthSchema.default(2),
@@ -11722,9 +11784,7 @@ var lengths22 = {
   cornerradius: "cornerRadius"
 };
 function parseTSlotExtrusionModelParams(raw) {
-  const tokens = splitModelStringTokens(
-    expandModelStringFlags(raw.string, stringFlags13)
-  );
+  const tokens = splitModelStringTokens(raw.string);
   if (raw.fn !== "tslotextrusion" || tokens[0]?.toLowerCase() !== raw.fn)
     throw new Error("Expected tslotextrusion without an inline value");
   const props = { fn: "tslotextrusion" };
@@ -11733,11 +11793,10 @@ function parseTSlotExtrusionModelParams(raw) {
     let property;
     let parsed = value;
     if (name in lengths22) property = lengths22[name];
-    else if (name === "profile") {
-      property = "profile";
-      const match = value.match(/^\(([a-z]+)\)$/i);
-      if (!match) throw new Error("Profile requires one parenthesized identity");
-      parsed = match[1].toLowerCase();
+    else if (name === "fourtsolid") {
+      property = "fourTSolid";
+      if (value !== "") throw new Error("fourtsolid is a value-free flag");
+      parsed = true;
     } else throw new Error(`Unknown T-slot extrusion token "${token}"`);
     if (property in props)
       throw new Error(`T-slot extrusion property "${property}" is repeated`);
@@ -11748,26 +11807,16 @@ function parseTSlotExtrusionModelParams(raw) {
 var model50 = defineModel({
   name: "tslotextrusion",
   schema: tSlotExtrusionModelDefinitionSchema,
-  parse: parseTSlotExtrusionModelParams,
-  normalizeString: (value) => normalizeModelStringFlags(
-    value,
-    stringFlags13,
-    parseTSlotExtrusionModelParams,
-    omittedStringFlags13
-  )
+  parse: parseTSlotExtrusionModelParams
 });
 function register50(registry2) {
   registry2.register(model50);
 }
-var stringFlags14 = {
-  righttriangle: "shape(righttriangle)"
-};
-var omittedStringFlags14 = [];
 var shape45 = {
   width: positiveGearLengthSchema.default(40),
   height: positiveGearLengthSchema.default(40),
   thickness: positiveGearLengthSchema.default(4),
-  shape: external_exports.literal("righttriangle").default("righttriangle"),
+  rightTriangle: external_exports.literal(true).default(true),
   slotCount: external_exports.literal(2).default(2),
   /** Capsule width and overall length, including both semicircular ends. */
   slot: external_exports.tuple([positiveGearLengthSchema, positiveGearLengthSchema]).default([5, 12]),
@@ -11842,9 +11891,7 @@ var lengths23 = {
   edgemargin: "edgeMargin"
 };
 function parseTSlotGussetModelParams(raw) {
-  const tokens = splitModelStringTokens(
-    expandModelStringFlags(raw.string, stringFlags14)
-  );
+  const tokens = splitModelStringTokens(raw.string);
   if (raw.fn !== "tslotgusset" || tokens[0]?.toLowerCase() !== raw.fn)
     throw new Error("Expected tslotgusset without an inline value");
   const props = { fn: "tslotgusset" };
@@ -11856,11 +11903,10 @@ function parseTSlotGussetModelParams(raw) {
     else if (name === "slots" || name === "slotcount") {
       property = "slotCount";
       parsed = parseGearInteger(value, "slotCount");
-    } else if (name === "shape") {
-      property = "shape";
-      const match = value.match(/^\(([a-z]+)\)$/i);
-      if (!match) throw new Error("Shape requires one parenthesized identity");
-      parsed = match[1].toLowerCase();
+    } else if (name === "righttriangle") {
+      property = "rightTriangle";
+      if (value !== "") throw new Error("righttriangle is a value-free flag");
+      parsed = true;
     } else if (name === "slot" || name === "centers") {
       property = name;
       const match = value.match(/^\(([^(),]+),([^(),]+)\)$/);
@@ -11876,13 +11922,7 @@ function parseTSlotGussetModelParams(raw) {
 var model51 = defineModel({
   name: "tslotgusset",
   schema: tSlotGussetModelDefinitionSchema,
-  parse: parseTSlotGussetModelParams,
-  normalizeString: (value) => normalizeModelStringFlags(
-    value,
-    stringFlags14,
-    parseTSlotGussetModelParams,
-    omittedStringFlags14
-  )
+  parse: parseTSlotGussetModelParams
 });
 function register51(registry2) {
   registry2.register(model51);
@@ -12138,24 +12178,24 @@ function getNemaMotorReferencePoints(input) {
     p.bodyWidth / 2 / Math.max(Math.abs(x), Math.abs(y)),
     (p.bodyWidth - p.faceCornerChamfer) / (Math.abs(x) + Math.abs(y))
   );
-  if (p.nemaSize === 34 && p.cornerProfile === "stepped") {
-    const h2 = p.bodyWidth / 2, c = p.bodyCornerChamfer / Math.SQRT2, r = Math.min(4, c / 4);
-    const contains = (distance2) => {
-      const a = Math.abs(distance2 * x), b = Math.abs(distance2 * y);
-      if (a > h2 || b > h2) return false;
-      if (c === 0) return true;
-      if (a > h2 - c && b > h2 - c)
-        return a <= h2 - c + r && b <= h2 - c + r && Math.hypot(a - (h2 - c + r), b - (h2 - c + r)) >= r;
-      if (b > h2 - r && a > h2 - c - r)
-        return Math.hypot(a - (h2 - c - r), b - (h2 - r)) <= r;
-      if (a > h2 - r && b > h2 - c - r)
-        return Math.hypot(a - (h2 - r), b - (h2 - c - r)) <= r;
-      return true;
+  if (p.nemaSize !== 34 || p.stepped) {
+    const profile6 = p.nemaSize === 34 ? {
+      width: p.bodyWidth,
+      chamfer: p.bodyCornerChamfer,
+      stepped: p.stepped,
+      recessRadius: p.bodyCornerRecessRadius,
+      filletRadius: p.bodyCornerFilletRadius
+    } : {
+      width: p.bodyWidth,
+      chamfer: p.rearCornerChamfer,
+      stepped: p.rearStepped,
+      recessRadius: p.rearCornerRecessRadius,
+      filletRadius: p.rearCornerFilletRadius
     };
     let low = 0, high = p.bodyWidth;
     for (let i = 0; i < 50; i++) {
       const mid = (low + high) / 2;
-      if (contains(mid)) low = mid;
+      if (isInsideNemaFace(mid * x, mid * y, profile6)) low = mid;
       else high = mid;
     }
     radius = low;
@@ -12182,7 +12222,7 @@ function getNemaMotorReferencePoints(input) {
       },
       direction: { x, y, z: 0 }
     },
-    shaftflat: p.shaftShape === "d" ? {
+    shaftflat: p.dShaft ? {
       position: {
         x: (p.shaftDiameter / 2 - p.shaftFlatDepth) * Math.cos(flatRadians),
         y: (p.shaftDiameter / 2 - p.shaftFlatDepth) * Math.sin(flatRadians),
@@ -13744,7 +13784,11 @@ function finishShaftMountMesh(geometry) {
 function createClampingShaftCollarMesh(input) {
   const props = clampingShaftCollarModelPropsSchema.parse(input);
   const dimensions5 = getClampingShaftCollarDimensions(props);
-  assertShaftMountResolution([dimensions5.threadedHole]);
+  const threadedHole = {
+    ...dimensions5.threadedHole,
+    threadHand: dimensions5.threadedHole.leftHanded ? "left" : "right"
+  };
+  assertShaftMountResolution([threadedHole]);
   const body = createAnnularSleeve({
     outerRadius: props.outerDiameter / 2,
     boreARadius: props.boreDiameter / 2,
@@ -13770,7 +13814,7 @@ function createClampingShaftCollarMesh(input) {
       body,
       slit,
       createMountingHoleCutter(dimensions5.clearanceHole),
-      createMountingHoleCutter(dimensions5.threadedHole)
+      createMountingHoleCutter(threadedHole)
     )
   );
 }
@@ -13955,7 +13999,7 @@ function createCompressionSpringMesh(input, options = {}) {
     }
   }
   const triangle = (a, b, c) => {
-    if (props.hand === "left") indices.push(a, c, b);
+    if (props.leftHanded) indices.push(a, c, b);
     else indices.push(a, b, c);
   };
   for (let step = 0; step < steps; step++)
@@ -14690,7 +14734,7 @@ function createFlatHeadScrewMesh(input, options = {}) {
       levels.add(-p.length + (shaftEnd + p.length) * i / steps);
   for (const z of [...levels].sort((a, b) => a - b)) {
     const r = add((theta) => {
-      const phase = (((z + p.length) / pitch - (p.threadHand === "right" ? 1 : -1) * theta / (2 * Math.PI)) % 1 + 1) % 1;
+      const phase = (((z + p.length) / pitch - (p.leftHanded ? -1 : 1) * theta / (2 * Math.PI)) % 1 + 1) % 1;
       const d = Math.min(phase, 1 - phase);
       const groove = Math.min(
         major - minor,
@@ -14890,6 +14934,11 @@ var resolveFlexScreenSize = ({
   };
 };
 var resolveOrientation = (props) => {
+  if ("orientation" in props) {
+    throw new Error(
+      "FlexScreen orientation is no longer supported; use a boolean placement flag"
+    );
+  }
   const shortcuts = [
     ["sitsFlat", props.sitsFlat],
     ["sitsFlatBelowBoard", props.sitsFlatBelowBoard],
@@ -14899,13 +14948,24 @@ var resolveOrientation = (props) => {
     ["foldedToFaceBelowBoard", props.foldsBelowBoard],
     ["foldedToRightAngleAboveBoard", props.foldedToRightAngleAboveBoard],
     ["foldedToRightAngleBelowBoard", props.foldedToRightAngleBelowBoard]
-  ].filter((entry) => entry[1]);
-  if (shortcuts.length > 1) {
+  ];
+  for (const [name, value] of shortcuts) {
+    if (value !== void 0 && typeof value !== "boolean") {
+      throw new Error(`FlexScreen placement flag "${name}" must be a boolean`);
+    }
+  }
+  const selected = shortcuts.filter((entry) => entry[1] === true);
+  if (selected.length > 1) {
     throw new Error(
       "Only one FlexScreen boolean orientation shortcut can be true"
     );
   }
-  return shortcuts[0]?.[0] ?? props.orientation ?? "sitsFlat";
+  if (selected.length === 0 && shortcuts.some((entry) => entry[1] !== void 0)) {
+    throw new Error(
+      "A FlexScreen orientation flag must be true when placement flags are supplied"
+    );
+  }
+  return selected[0]?.[0] ?? "sitsFlat";
 };
 var distance = (a, b) => Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
 var interpolate = (a, b, progress) => [
@@ -15777,7 +15837,7 @@ function createTwistedSpurGearMesh(input, twist = 0, segmentsPerTurn = 32) {
 function createHelicalGearMesh(input) {
   const props = helicalGearModelPropsSchema.parse(input);
   const { twistAngle } = getHelicalGearDimensions(props);
-  const { helixAngle, handedness, segmentsPerTurn, ...spur } = props;
+  const { helixAngle, leftHanded, segmentsPerTurn, ...spur } = props;
   return createTwistedSpurGearMesh(
     spur,
     twistAngle * Math.PI / 180,
@@ -15880,7 +15940,7 @@ function createHexBoltMesh(input, options = {}) {
       levels.add(-p.length + (shaftEnd + p.length) * i / steps);
   for (const z of [...levels].sort((a, b) => a - b)) {
     const r = add((theta) => {
-      const phase = (((z + p.length) / pitch - (p.threadHand === "right" ? 1 : -1) * theta / (2 * Math.PI)) % 1 + 1) % 1;
+      const phase = (((z + p.length) / pitch - (p.leftHanded ? -1 : 1) * theta / (2 * Math.PI)) % 1 + 1) % 1;
       const d = Math.min(phase, 1 - phase);
       const groove = Math.min(
         major - minor,
@@ -16510,14 +16570,14 @@ var resolveNemaMotorProps = nemaMotorModelPropsSchema.parse.bind(nemaMotorModelP
 // lib/utils/nemaMotorWireGeometry.ts
 function createNemaMotorWireGeometry(input) {
   const p = resolveNemaMotorProps(input);
-  if (p.wireConnection === "none") return [];
+  if (p.noWires) return [];
   const { position } = getNemaMotorReferencePoints(p).wireside;
   const angle = p.wireSideAngle * Math.PI / 180;
   const place = (geometry) => jscad8.transforms.translate(
     [position.x, position.y, position.z],
     jscad8.transforms.rotateZ(angle, geometry)
   );
-  if (p.wireConnection === "stubs") {
+  if (p.wireStubs) {
     const colors = [
       "#d53f3f",
       "#2463af",
@@ -16630,19 +16690,25 @@ var roundedFace = (width10, radius) => {
     })
   );
 };
-var steppedFace = (width10, chamfer) => {
+var steppedFace = (width10, chamfer, recessRadius, filletRadius) => {
   if (chamfer === 0) return face(width10, 0);
   const h2 = width10 / 2, c = chamfer / Math.SQRT2, r = Math.min(4, c / 4);
   const corner = [];
-  const arc = (x, y, from, to) => {
+  const arc = (x, y, radius, from, to) => {
+    if (radius === 0) {
+      corner.push([x, y]);
+      return;
+    }
     for (let i = 0; i <= 12; i++) {
       const a = (from + (to - from) * i / 12) * Math.PI / 180;
-      corner.push([x + r * Math.cos(a), y + r * Math.sin(a)]);
+      corner.push([x + radius * Math.cos(a), y + radius * Math.sin(a)]);
     }
   };
-  arc(h2 - c - r, h2 - r, 90, 0);
-  arc(h2 - c + r, h2 - c + r, 180, 270);
-  arc(h2 - r, h2 - c - r, 90, 0);
+  const convex = filletRadius ?? r;
+  const concave = recessRadius ?? r;
+  arc(h2 - c - convex, h2 - convex, convex, 90, 0);
+  arc(h2 - c + concave, h2 - c + concave, concave, 180, 270);
+  arc(h2 - convex, h2 - c - convex, convex, 90, 0);
   return [0, 1, 2, 3].flatMap(
     (i) => corner.map(([x, y]) => {
       const a = -i * Math.PI / 2;
@@ -16663,12 +16729,18 @@ function createNemaMotorSections(input) {
     p.bodyWidth,
     p.faceCornerChamfer
   );
-  const profile6 = p.cornerProfile === "stepped" ? steppedFace : face;
-  const core = profile6(p.bodyWidth, p.bodyCornerChamfer);
-  const rear = profile6(
+  const core = p.stepped ? steppedFace(
     p.bodyWidth,
-    p.rearCornerChamfer ?? (p.backFace === "plain" && p.mountingHoleThrough ? p.bodyCornerChamfer : p.faceCornerChamfer)
-  );
+    p.bodyCornerChamfer,
+    p.bodyCornerRecessRadius,
+    p.bodyCornerFilletRadius
+  ) : face(p.bodyWidth, p.bodyCornerChamfer);
+  const rear = p.rearStepped ? steppedFace(
+    p.bodyWidth,
+    p.rearCornerChamfer,
+    p.rearCornerRecessRadius,
+    p.rearCornerFilletRadius
+  ) : face(p.bodyWidth, p.rearCornerChamfer);
   const h2 = p.mountingHoleSpacing / 2;
   const centers = [
     [-h2, -h2],
@@ -16683,12 +16755,13 @@ function createNemaMotorSections(input) {
   add("frontCap", front, -holeDepth, 0, holes);
   add("frontCap", front, -p.frontCapLength, -holeDepth);
   add("body", core, -p.bodyLength + p.rearCapLength, -p.frontCapLength);
-  if (p.backFace === "plain") {
+  if (p.backFacePlain) {
     add("rearCap", rear, -p.bodyLength, -p.bodyLength + p.rearCapLength);
   } else {
-    const halfPitch = p.backFaceHoleSpacing / 2;
-    const rearHoles = [-halfPitch, halfPitch].flatMap(
-      (x) => [-halfPitch, halfPitch].map(
+    const halfPitchX = p.backFaceHoleSpacingX / 2;
+    const halfPitchY = p.backFaceHoleSpacingY / 2;
+    const rearHoles = [-halfPitchX, halfPitchX].flatMap(
+      (x) => [-halfPitchY, halfPitchY].map(
         (y) => circle(p.backFaceHoleDiameter / 2, x, y)
       )
     );
@@ -16709,17 +16782,16 @@ function createNemaMotorSections(input) {
   add("pilot", circle(p.pilotDiameter / 2), 0, p.pilotLength);
   const r = p.shaftDiameter / 2;
   const round = circle(r);
-  if (p.shaftShape === "round")
-    add("shaft", round, p.pilotLength, p.shaftLength);
+  if (p.roundShaft) add("shaft", round, p.pilotLength, p.shaftLength);
   else {
     const cut = r - p.shaftFlatDepth;
     const angle = Math.acos(cut / r);
-    const profile7 = Array.from({ length: 97 }, (_, i) => {
+    const profile6 = Array.from({ length: 97 }, (_, i) => {
       const a = angle + (2 * Math.PI - 2 * angle) * i / 96;
       return [r * Math.cos(a), r * Math.sin(a)];
     });
     const rotation = p.shaftFlatAngle * Math.PI / 180;
-    const d = profile7.map(([x, y]) => [
+    const d = profile6.map(([x, y]) => [
       x * Math.cos(rotation) - y * Math.sin(rotation),
       x * Math.sin(rotation) + y * Math.cos(rotation)
     ]);
@@ -16739,7 +16811,7 @@ function NemaMotor({
   ...props
 }) {
   const p = resolveNemaMotorProps(props);
-  const screw = p.backFace === "screws" ? jscad9.transforms.rotateX(
+  const screw = p.backFaceScrews ? jscad9.transforms.rotateX(
     Math.PI,
     createHexSocketBoltGeom({
       metricSize: p.backFaceScrewSize,
@@ -16747,7 +16819,8 @@ function NemaMotor({
       showThreads: false
     })
   ) : void 0;
-  const halfPitch = p.backFaceHoleSpacing / 2;
+  const halfPitchX = p.backFaceHoleSpacingX / 2;
+  const halfPitchY = p.backFaceHoleSpacingY / 2;
   return /* @__PURE__ */ jsxs(Fragment2, { children: [
     createNemaMotorSections(p).map((section, index) => {
       const outline = jscad9.geometries.geom2.fromPoints(section.outline);
@@ -16792,8 +16865,8 @@ function NemaMotor({
       },
       `front-screw-${index}`
     )),
-    screw && [-halfPitch, halfPitch].flatMap(
-      (x) => [-halfPitch, halfPitch].map((y) => /* @__PURE__ */ jsx(
+    screw && [-halfPitchX, halfPitchX].flatMap(
+      (x) => [-halfPitchY, halfPitchY].map((y) => /* @__PURE__ */ jsx(
         Colorize,
         {
           material: componentMaterials.steel,
@@ -17048,7 +17121,7 @@ function createPanScrewMesh(input, options = {}) {
       levels.add(-p.length + (shaftEnd + p.length) * i / steps);
   for (const z of [...levels].sort((a, b) => a - b)) {
     const r = add((theta) => {
-      const phase = (((z + p.length) / pitch - (p.threadHand === "right" ? 1 : -1) * theta / (2 * Math.PI)) % 1 + 1) % 1;
+      const phase = (((z + p.length) / pitch - (p.leftHanded ? -1 : 1) * theta / (2 * Math.PI)) % 1 + 1) % 1;
       const d = Math.min(phase, 1 - phase);
       const groove = Math.min(
         major - minor,
@@ -17788,7 +17861,11 @@ import "@jscad/modeling";
 function createRigidCouplerMesh(input) {
   const props = rigidCouplerModelPropsSchema.parse(input);
   const dimensions5 = getRigidCouplerDimensions(props);
-  assertShaftMountResolution(dimensions5.screwHoles);
+  const screwHoles = dimensions5.screwHoles.map((hole) => ({
+    ...hole,
+    threadHand: hole.leftHanded ? "left" : "right"
+  }));
+  assertShaftMountResolution(screwHoles);
   const body = createAnnularSleeve({
     outerRadius: props.outerDiameter / 2,
     boreARadius: props.boreDiameter / 2,
@@ -17798,10 +17875,7 @@ function createRigidCouplerMesh(input) {
     stepZ: dimensions5.boreADepth
   });
   return finishShaftMountMesh(
-    subtractShaftMountParts(
-      body,
-      ...dimensions5.screwHoles.map(createMountingHoleCutter)
-    )
+    subtractShaftMountParts(body, ...screwHoles.map(createMountingHoleCutter))
   );
 }
 
@@ -17954,7 +18028,11 @@ import "@jscad/modeling";
 function createShaftCollarMesh(input) {
   const props = shaftCollarModelPropsSchema.parse(input);
   const dimensions5 = getShaftCollarDimensions(props);
-  assertShaftMountResolution([dimensions5.screwHole]);
+  const screwHole = {
+    ...dimensions5.screwHole,
+    threadHand: dimensions5.screwHole.leftHanded ? "left" : "right"
+  };
+  assertShaftMountResolution([screwHole]);
   const body = createAnnularSleeve({
     outerRadius: props.outerDiameter / 2,
     boreARadius: props.boreDiameter / 2,
@@ -17962,10 +18040,7 @@ function createShaftCollarMesh(input) {
     chamfer: props.chamfer
   });
   return finishShaftMountMesh(
-    subtractShaftMountParts(
-      body,
-      createMountingHoleCutter(dimensions5.screwHole)
-    )
+    subtractShaftMountParts(body, createMountingHoleCutter(screwHole))
   );
 }
 
@@ -17991,11 +18066,11 @@ function register92(registry2) {
 // lib/mechanical/sheet-metal-mesh.ts
 import earcut5 from "earcut";
 function holeOutline(hole) {
-  const radius = (hole.shape === "round" ? hole.diameter : hole.width) / 2;
-  const straight = hole.shape === "slot" ? (hole.length - hole.width) / 2 : 0;
+  const radius = (hole.round ? hole.diameter : hole.width) / 2;
+  const straight = hole.slot ? (hole.length - hole.width) / 2 : 0;
   if (straight < 0) throw new Error("Slot length must be at least its width");
   return Array.from({ length: 64 }, (_, i) => {
-    if (hole.shape === "round") {
+    if (hole.round) {
       const angle2 = i * Math.PI / 32;
       return {
         u: hole.u + radius * Math.cos(angle2),
@@ -18006,12 +18081,13 @@ function holeOutline(hole) {
     const angle = -Math.PI / 2 + (i < 32 ? i : i - 32) * Math.PI / 31 + (i < 32 ? 0 : Math.PI);
     const along = half * straight + radius * Math.cos(angle);
     const across = radius * Math.sin(angle);
-    return hole.shape === "slot" && hole.axis === "v" ? { u: hole.u - across, v: hole.v + along } : { u: hole.u + along, v: hole.v + across };
+    return hole.slot && hole.axis === "v" ? { u: hole.u - across, v: hole.v + along } : { u: hole.u + along, v: hole.v + across };
   });
 }
 function createSheetMetalMesh(input) {
   const props = sheetMetalModelPropsSchema.parse(input);
-  const { width: width10, baseLength, flangeHeight, thickness, profile: profile6 } = props;
+  const { width: width10, baseLength, flangeHeight, thickness } = props;
+  const profile6 = props.channel ? "channel" : props.angle ? "angle" : "plate";
   const radius = props.insideBendRadius + thickness / 2;
   const positions = [];
   const indices = [];
@@ -19154,7 +19230,7 @@ var createWormGearMesh = (input) => {
   const positions = [];
   const indices = [];
   const phase = props.phase % 360 * Math.PI / 180;
-  const direction = props.handedness === "right" ? 1 : -1;
+  const direction = props.leftHanded ? -1 : 1;
   const ring = (z) => {
     const first = positions.length / 3;
     const rotation = phase + direction * (z / lead) * Math.PI * 2;