jscad-electronics 0.0.238 → 0.0.239

package/dist/vanilla.js

@@ -12179,7 +12179,7 @@ function getNemaMotorReferencePoints(input) {
     (p.bodyWidth - p.faceCornerChamfer) / (Math.abs(x) + Math.abs(y))
   );
   if (p.nemaSize !== 34 || p.stepped) {
-    const profile6 = p.nemaSize === 34 ? {
+    const profile5 = p.nemaSize === 34 ? {
       width: p.bodyWidth,
       chamfer: p.bodyCornerChamfer,
       stepped: p.stepped,
@@ -12195,7 +12195,7 @@ function getNemaMotorReferencePoints(input) {
     let low = 0, high = p.bodyWidth;
     for (let i = 0; i < 50; i++) {
       const mid = (low + high) / 2;
-      if (isInsideNemaFace(mid * x, mid * y, profile6)) low = mid;
+      if (isInsideNemaFace(mid * x, mid * y, profile5)) low = mid;
       else high = mid;
     }
     radius = low;
@@ -12383,6 +12383,746 @@ var componentMaterials = {
   steel: { metalness: 1, roughness: 0.25 }
 };
 
+// node_modules/@tscircuit/jscad/lib/cleanup-subtraction.ts
+import insertTjunctions from "@jscad/modeling/src/operations/modifiers/insertTjunctions.js";
+function cleanupSubtraction(kernel, geometry) {
+  const { geom3 } = kernel.geometries;
+  if (!geometry.polygons.length) return geometry;
+  const source = structuredClone(geometry);
+  const polygons = geom3.toPolygons(source);
+  const extent = Math.max(...kernel.measurements.measureDimensions(source));
+  if (!Number.isFinite(extent) || extent <= 0)
+    throw new Error("Subtraction requires finite nonempty geometry");
+  const epsilon = Math.max(extent * 1e-10, 1e-12);
+  source.polygons = polygons.map((polygon4) => ({
+    ...polygon4,
+    vertices: polygon4.vertices.map((point) => {
+      if (!point.every(Number.isFinite))
+        throw new Error("Subtraction requires finite coordinates");
+      return point.map((value) => Math.round(value / epsilon) * epsilon);
+    })
+  }));
+  const triangles = insertTjunctions(source.polygons).flatMap((polygon4) => {
+    if (polygon4.vertices.length === 3) return [polygon4];
+    const center = [0, 0, 0];
+    for (const point of polygon4.vertices)
+      for (let axis = 0; axis < 3; axis++)
+        center[axis] += point[axis] / polygon4.vertices.length;
+    return polygon4.vertices.map((point, index) => {
+      const triangle = kernel.geometries.poly3.create([
+        center,
+        point,
+        polygon4.vertices[(index + 1) % polygon4.vertices.length]
+      ]);
+      if (polygon4.color) triangle.color = polygon4.color;
+      return triangle;
+    });
+  });
+  const cleaned = geom3.create(triangles);
+  return {
+    ...geometry,
+    polygons: cleaned.polygons,
+    transforms: cleaned.transforms
+  };
+}
+
+// node_modules/@tscircuit/jscad/lib/with-references.ts
+import modeling from "@jscad/modeling";
+var metadata = /* @__PURE__ */ Symbol.for("@tscircuit/jscad/references/v1");
+var cache = /* @__PURE__ */ new WeakMap();
+var snapshot = (value) => structuredClone(value);
+var assertName = (name) => {
+  if (typeof name !== "string" || !name.trim())
+    throw new Error("Reference name must be nonempty");
+};
+function withReferences(kernel = modeling) {
+  if (cache.has(kernel)) return cache.get(kernel);
+  const k = kernel;
+  const { mat4 } = k.maths;
+  const identity = () => Array.from(mat4.create());
+  const multiply = (a, b) => Array.from(mat4.multiply(mat4.create(), a, b));
+  const isGeometry = (g) => g && (k.geometries.geom2.isA(g) || k.geometries.path2.isA(g) || k.geometries.geom3.isA(g));
+  const inputs = (args) => args.flat(Infinity).filter(isGeometry);
+  const read = (g) => g?.[metadata] ?? /* @__PURE__ */ Object.create(null);
+  const merge = (geometries9) => {
+    const refs = /* @__PURE__ */ Object.create(null);
+    for (const g of geometries9)
+      for (const [name, ref] of Object.entries(read(g))) {
+        if (Object.hasOwn(refs, name) && refs[name] !== ref)
+          throw new Error(`Duplicate reference: ${name}`);
+        refs[name] = ref;
+      }
+    return refs;
+  };
+  const attach = (g, refs) => {
+    if (!Object.keys(refs).length) return g;
+    if (Array.isArray(g)) return g.map((item) => attach(item, refs));
+    return isGeometry(g) ? Object.assign({}, g, { [metadata]: refs }) : g;
+  };
+  const moved = (refs, matrix) => Object.fromEntries(
+    Object.entries(refs).map(([name, ref]) => [
+      name,
+      { geometry: ref.geometry, matrix: multiply(matrix, ref.matrix) }
+    ])
+  );
+  const add = (refs, name, ref) => {
+    assertName(name);
+    if (Object.hasOwn(refs, name))
+      throw new Error(`Duplicate reference: ${name}`);
+    refs[name] = ref;
+  };
+  const planar = (g) => {
+    if (!k.geometries.geom2.isA(g) && !k.geometries.path2.isA(g))
+      throw new Error("References require native planar geometry");
+  };
+  const references2 = {
+    name(name, geometry) {
+      planar(geometry);
+      const refs = merge([geometry]);
+      add(refs, name, { geometry: snapshot(geometry), matrix: identity() });
+      return attach(geometry, refs);
+    },
+    nameOutlines(geometry, names) {
+      if (!k.geometries.geom2.isA(geometry))
+        throw new Error("nameOutlines requires a native Geom2");
+      const refs = merge([geometry]);
+      const outlines = k.geometries.geom2.toOutlines(
+        snapshot(geometry)
+      );
+      const area = (points) => points.reduce((sum, p, i) => {
+        const q = points[(i + 1) % points.length];
+        return sum + p[0] * q[1] - p[1] * q[0];
+      }, 0);
+      for (const [role, name] of Object.entries(names)) {
+        if (name === void 0) continue;
+        if (role !== "outer" && role !== "hole")
+          throw new Error(`Unknown outline role: ${role}`);
+        const matches = outlines.filter(
+          (points) => role === "outer" ? area(points) > 0 : area(points) < 0
+        );
+        if (matches.length !== 1)
+          throw new Error(
+            `Expected exactly one ${role} outline, found ${matches.length}`
+          );
+        add(refs, name, {
+          geometry: k.geometries.path2.fromPoints({ closed: true }, matches[0]),
+          matrix: identity()
+        });
+      }
+      return attach(geometry, refs);
+    },
+    reference(name, geometry) {
+      return attach(
+        k.geometries.geom3.create(),
+        read(references2.name(name, geometry))
+      );
+    },
+    get(geometry, name) {
+      const ref = read(geometry)[name];
+      if (!Object.hasOwn(read(geometry), name))
+        throw new Error(`Unknown reference: ${name}`);
+      return snapshot(ref);
+    },
+    list(geometry) {
+      return Object.keys(read(geometry));
+    },
+    collect(geometries9) {
+      return snapshot(merge(inputs([geometries9])));
+    }
+  };
+  const wrapped = { ...k, references: references2 };
+  for (const namespace of [
+    "booleans",
+    "hulls",
+    "expansions",
+    "modifiers",
+    "extrusions",
+    "colors"
+  ]) {
+    wrapped[namespace] = { ...k[namespace] };
+    for (const [name, fn] of Object.entries(k[namespace]))
+      if (typeof fn === "function") {
+        wrapped[namespace][name] = (...args) => {
+          const refs = merge(inputs(args));
+          let result = fn(...args);
+          if (namespace === "booleans" && name === "subtract" && k.geometries.geom3.isA(result)) {
+            result = cleanupSubtraction(kernel, result);
+          }
+          return attach(result, refs);
+        };
+      }
+  }
+  const transformResult = (fn, args, offset, boundsBased = false) => {
+    const gs = inputs(args.slice(offset));
+    if (!gs.some((g) => Object.keys(read(g)).length)) return fn(...args);
+    const maps = gs.map((g) => read(g));
+    const before = boundsBased ? gs.map((g) => k.measurements.measureBoundingBox(snapshot(g))[0]) : [];
+    const matrix = boundsBased ? null : fn(...args.slice(0, offset), k.geometries.geom3.create()).transforms;
+    const result = fn(...args);
+    const results = Array.isArray(result) ? result : [result];
+    const output = results.map((g, i) => {
+      let m = matrix;
+      if (boundsBased) {
+        const after = k.measurements.measureBoundingBox(snapshot(g))[0];
+        m = mat4.fromTranslation(
+          mat4.create(),
+          after.map((n, axis) => n - before[i][axis])
+        );
+      }
+      return attach(g, moved(maps[i], Array.from(m)));
+    });
+    return Array.isArray(result) ? output : output[0];
+  };
+  wrapped.transforms = { ...k.transforms };
+  for (const [name, fn] of Object.entries(k.transforms)) {
+    const boundsBased = /^(center|align)/.test(name);
+    const offset = /^center[XYZ]$|^mirror[XYZ]$/.test(name) ? 0 : 1;
+    wrapped.transforms[name] = (...args) => transformResult(fn, args, offset, boundsBased);
+  }
+  wrapped.geometries = { ...k.geometries };
+  for (const ns of ["geom2", "geom3", "path2"]) {
+    wrapped.geometries[ns] = {
+      ...k.geometries[ns],
+      transform: (matrix, g) => attach(k.geometries[ns].transform(matrix, g), moved(read(g), matrix))
+    };
+  }
+  wrapped.extrusions.extrudeLinear = (options, ...objects) => {
+    const gs = inputs(objects);
+    const { topOutlineName, bottomOutlineName } = options ?? {};
+    if (topOutlineName === void 0 && bottomOutlineName === void 0) {
+      const refs2 = gs.map(read);
+      const result = k.extrusions.extrudeLinear(options, ...objects);
+      return Array.isArray(result) ? result.map((g, i) => attach(g, refs2[i])) : attach(result, refs2[0] ?? {});
+    }
+    if (gs.length !== 1)
+      throw new Error("Named extrusion outlines require exactly one profile");
+    const profile5 = gs[0];
+    planar(profile5);
+    if (k.geometries.path2.isA(profile5) && !profile5.isClosed)
+      throw new Error("Named extrusion outlines require a closed path");
+    const { height: height10 = 1, twistAngle = 0, twistSteps = 1 } = options;
+    if (!Number.isFinite(height10) || !Number.isFinite(twistAngle) || !Number.isInteger(twistSteps) || twistSteps < 1)
+      throw new Error(
+        "Invalid named extrusion height, twistAngle or twistSteps"
+      );
+    const refs = merge(gs);
+    const source = snapshot(profile5);
+    const top = multiply(
+      Array.from(mat4.fromTranslation(mat4.create(), [0, 0, height10])),
+      Array.from(mat4.fromZRotation(mat4.create(), twistAngle))
+    );
+    for (const [prefix, matrix] of [
+      [bottomOutlineName, identity()],
+      [topOutlineName, top]
+    ]) {
+      if (prefix === void 0) continue;
+      add(refs, prefix, { geometry: source, matrix });
+      for (const [name, ref] of Object.entries(read(profile5)))
+        add(refs, `${prefix}.${name}`, {
+          geometry: ref.geometry,
+          matrix: multiply(matrix, ref.matrix)
+        });
+    }
+    return attach(k.extrusions.extrudeLinear(options, ...objects), refs);
+  };
+  cache.set(kernel, wrapped);
+  cache.set(wrapped, wrapped);
+  return wrapped;
+}
+
+// node_modules/@tscircuit/jscad/lib/geom3-to-indexed-mesh.ts
+import jscad from "@jscad/modeling";
+var edgeKey = (a, b) => a < b ? `${a},${b}` : `${b},${a}`;
+function geom3ToIndexedMesh(input) {
+  const generalize8 = jscad.modifiers.generalize;
+  input = structuredClone(input);
+  const inputExtent = Math.max(...jscad.measurements.measureDimensions(input));
+  if (!Number.isFinite(inputExtent) || inputExtent <= 0)
+    throw new Error("Expected finite nonempty geometry");
+  const weldTolerance = Math.max(inputExtent * 1e-10, 1e-12);
+  const cells = /* @__PURE__ */ new Map();
+  const weld = (v) => {
+    if (v.length !== 3 || v.some((value) => !Number.isFinite(value)))
+      throw new Error("Expected finite mesh coordinates");
+    const cell = v.map((value) => Math.floor(value / weldTolerance));
+    for (let x = -1; x <= 1; x++)
+      for (let y = -1; y <= 1; y++)
+        for (let z = -1; z <= 1; z++) {
+          const entries2 = cells.get(
+            `${cell[0] + x},${cell[1] + y},${cell[2] + z}`
+          );
+          const existing = entries2?.find(
+            (point3) => Math.hypot(...v.map((value, axis) => value - point3[axis])) <= weldTolerance
+          );
+          if (existing) return existing;
+        }
+    const point2 = [v[0], v[1], v[2]], key = cell.join(","), entries = cells.get(key);
+    if (entries) entries.push(point2);
+    else cells.set(key, [point2]);
+    return point2;
+  };
+  const welded = jscad.geometries.geom3.fromPoints(
+    jscad.geometries.geom3.toPolygons(input).map((poly) => poly.vertices.map(weld))
+  );
+  const geom = generalize8({ snap: true, triangulate: true }, welded);
+  const extent = Math.max(...jscad.measurements.measureDimensions(geom));
+  if (!Number.isFinite(extent) || extent <= 0)
+    throw new Error("Expected finite nonempty geometry");
+  const epsilon = Math.max(extent * 1e-10, 1e-12);
+  const snapTolerance = Math.max(
+    2 * jscad.measurements.measureEpsilon(geom),
+    epsilon
+  );
+  const positions = [], indices = [];
+  const lookup = /* @__PURE__ */ new Map();
+  const point = (index) => [
+    positions[index * 3],
+    positions[index * 3 + 1],
+    positions[index * 3 + 2]
+  ];
+  const vertex = (v) => {
+    if (v.length !== 3 || v.some((value) => !Number.isFinite(value)))
+      throw new Error("Expected finite mesh coordinates");
+    const key = v.map((x) => Math.round(x / epsilon)).join(",");
+    let index = lookup.get(key);
+    if (index === void 0) {
+      index = positions.length / 3;
+      positions.push(...v);
+      lookup.set(key, index);
+    }
+    return index;
+  };
+  const area = ([a, b, c]) => {
+    const pa = point(a), pb = point(b), pc = point(c);
+    const u = pb.map((x, i) => x - pa[i]), v = pc.map((x, i) => x - pa[i]);
+    return Math.hypot(
+      u[1] * v[2] - u[2] * v[1],
+      u[2] * v[0] - u[0] * v[2],
+      u[0] * v[1] - u[1] * v[0]
+    );
+  };
+  const triangles = [];
+  const edges = /* @__PURE__ */ new Map();
+  for (const poly of jscad.geometries.geom3.toPolygons(geom)) {
+    for (let i = 1; i < poly.vertices.length - 1; i++) {
+      const triangle = [
+        vertex(poly.vertices[0]),
+        vertex(poly.vertices[i]),
+        vertex(poly.vertices[i + 1])
+      ];
+      if (area(triangle) <= epsilon * epsilon) continue;
+      triangles.push(triangle);
+      triangle.forEach((a, i2) => {
+        const b = triangle[(i2 + 1) % 3], key = edgeKey(a, b), entry = edges.get(key);
+        if (entry) entry.count++;
+        else edges.set(key, { a, b, count: 1 });
+      });
+    }
+  }
+  const unmatched = [...edges.values()].filter(({ count }) => count === 1);
+  const candidates = [...new Set(unmatched.flatMap(({ a, b }) => [a, b]))];
+  const sorted = [0, 1, 2].map(
+    (axis) => [...candidates].sort(
+      (a, b) => positions[a * 3 + axis] - positions[b * 3 + axis]
+    )
+  );
+  const subdivisions = /* @__PURE__ */ new Map();
+  for (const { a, b } of unmatched) {
+    const pa = point(a), pb = point(b), direction = pb.map((x, i) => x - pa[i]), length32 = Math.hypot(...direction);
+    if (length32 <= epsilon) continue;
+    const axis = direction.reduce(
+      (best, x, i) => Math.abs(x) > Math.abs(direction[best]) ? i : best,
+      0
+    );
+    const unit = direction.map((x) => x / length32), low = Math.min(pa[axis], pb[axis]), high = Math.max(pa[axis], pb[axis]);
+    const byAxis = sorted[axis];
+    let left = 0, right = byAxis.length;
+    while (left < right) {
+      const mid = left + right >>> 1;
+      if (positions[byAxis[mid] * 3 + axis] < low) left = mid + 1;
+      else right = mid;
+    }
+    const splits = [];
+    for (let i = left; i < byAxis.length; i++) {
+      const index = byAxis[i], p = point(index);
+      if (p[axis] > high) break;
+      if (index === a || index === b) continue;
+      const delta = p.map((x, j) => x - pa[j]), along = delta.reduce((sum, x, j) => sum + x * unit[j], 0);
+      if (along <= epsilon || along >= length32 - epsilon) continue;
+      const distance2 = Math.hypot(...delta.map((x, j) => x - along * unit[j]));
+      if (distance2 <= snapTolerance) splits.push({ index, t: along / length32 });
+    }
+    if (splits.length)
+      subdivisions.set(
+        edgeKey(a, b),
+        splits.sort((x, y) => x.t - y.t).map(({ index }) => index)
+      );
+  }
+  for (const triangle of triangles) {
+    const boundary = triangle.flatMap((a, i) => {
+      const b = triangle[(i + 1) % 3], splits = subdivisions.get(edgeKey(a, b));
+      if (!splits) return [a];
+      const edge = edges.get(edgeKey(a, b));
+      return [a, ...edge.a === a ? splits : [...splits].reverse()];
+    });
+    if (boundary.length === 3) {
+      indices.push(...triangle);
+      continue;
+    }
+    const origin = point(boundary[0]);
+    const center = origin.map(
+      (value, axis) => value + boundary.reduce(
+        (sum, index) => sum + (point(index)[axis] - value) / boundary.length,
+        0
+      )
+    );
+    const middle = vertex(center);
+    for (let i = 0; i < boundary.length; i++) {
+      const part = [
+        middle,
+        boundary[i],
+        boundary[(i + 1) % boundary.length]
+      ];
+      if (area(part) <= epsilon * epsilon)
+        throw new Error("Unable to preserve a degenerate mesh boundary");
+      indices.push(...part);
+    }
+  }
+  const compactPositions = [], compactIndices = [], remap = /* @__PURE__ */ new Map();
+  for (const original of indices) {
+    let index = remap.get(original);
+    if (index === void 0) {
+      index = compactPositions.length / 3;
+      compactPositions.push(...point(original));
+      remap.set(original, index);
+    }
+    compactIndices.push(index);
+  }
+  if (!compactIndices.length)
+    throw new Error("Expected finite nonempty geometry");
+  return { positions: compactPositions, indices: compactIndices };
+}
+
+// node_modules/@tscircuit/jscad/lib/index.ts
+var jscad2 = withReferences();
+var {
+  booleans,
+  colors,
+  curves,
+  expansions,
+  extrusions,
+  geometries,
+  hulls,
+  maths,
+  measurements,
+  modifiers,
+  primitives,
+  text,
+  transforms,
+  utils,
+  references
+} = jscad2;
+
+// lib/vanilla/render.ts
+var isVNode = (n) => n && typeof n === "object" && "type" in n;
+var degToRad = (v) => {
+  if (typeof v === "number") return v;
+  if (typeof v === "string") {
+    const m = /^(-?\d+(?:\.\d+)?)\s*deg$/i.exec(v);
+    if (m) return parseFloat(m[1]) * Math.PI / 180;
+    const n = Number(v);
+    if (!Number.isNaN(n)) return n;
+  }
+  return 0;
+};
+var toVec3 = (v) => {
+  if (Array.isArray(v))
+    return [Number(v[0]) || 0, Number(v[1]) || 0, Number(v[2]) || 0];
+  if (typeof v === "object" && v)
+    return [Number(v.x) || 0, Number(v.y) || 0, Number(v.z) || 0];
+  return [0, 0, 0];
+};
+var assertFiniteFeatureTransform = (values) => {
+  if (!values.every(Number.isFinite))
+    throw new Error("JSCAD reference feature transforms must be finite");
+};
+var transformFeatureContext = (context, local) => {
+  if (!context.referenceFeatures) return context;
+  const { mat4 } = context.jscad.maths;
+  const matrix = mat4.multiply(mat4.create(), context.matrix, local);
+  assertFiniteFeatureTransform(matrix);
+  return { ...context, matrix };
+};
+var validateFeatureName = (name) => {
+  if (name !== void 0 && (typeof name !== "string" || !name.trim()))
+    throw new Error("Named JSCAD features require a nonblank name");
+};
+var recordFeature = (context, name, geometry) => {
+  if (!context.referenceFeatures || name === void 0) return;
+  if (Object.hasOwn(context.referenceFeatures, name))
+    throw new Error(`Duplicate JSCAD feature name "${name}"`);
+  const { geometries: geometries9 } = context.jscad;
+  if (!geometries9.geom2.isA(geometry) && !geometries9.path2.isA(geometry) && !geometries9.geom3.isA(geometry))
+    throw new Error(`Named JSCAD feature "${name}" requires native geometry`);
+  assertFiniteFeatureTransform(context.matrix);
+  context.referenceFeatures[name] = {
+    geometry,
+    matrix: [...context.matrix]
+  };
+};
+function renderNode(node, colorCtx, renderCtx) {
+  const {
+    jscad: { primitives: primitives9, booleans: booleans5, hulls: hulls2, geometries: geometries9, extrusions: extrusions9, transforms: transforms3 }
+  } = renderCtx;
+  if (node == null || node === false) return [];
+  if (Array.isArray(node))
+    return node.flatMap((n) => renderNode(n, colorCtx, renderCtx));
+  if (!isVNode(node)) return [];
+  const { type, props, children } = node;
+  if (props?.material) {
+    const { material, ...rest } = props;
+    return renderNode({ ...node, props: rest }, colorCtx, renderCtx).map(
+      (entry) => ({
+        ...entry,
+        material: { ...material },
+        geom: { ...entry.geom, material: { ...material } }
+      })
+    );
+  }
+  if (type === Fragment) {
+    return (children ?? []).flatMap((c) => renderNode(c, colorCtx, renderCtx));
+  }
+  if (type === Colorize) {
+    const newColor = props?.color;
+    return (children ?? []).flatMap(
+      (c) => renderNode(c, newColor ?? colorCtx, renderCtx)
+    );
+  }
+  if (type === Translate) {
+    const offset = props?.offset ?? props?.center ?? { x: props?.x, y: props?.y, z: props?.z };
+    if (renderCtx.referenceFeatures)
+      assertFiniteFeatureTransform(
+        (Array.isArray(offset) ? offset.slice(0, 3) : [offset?.x, offset?.y, offset?.z]).map((value) => Number(value ?? 0))
+      );
+    const off = toVec3(offset);
+    const { mat4 } = renderCtx.jscad.maths;
+    const childContext = transformFeatureContext(
+      renderCtx,
+      mat4.fromTranslation(mat4.create(), off)
+    );
+    const geoms = (children ?? []).flatMap(
+      (c) => renderNode(c, colorCtx, childContext)
+    );
+    return geoms.map(({ geom, color, material }) => ({
+      material,
+      geom: transforms3.translate(off, geom),
+      color: color ?? colorCtx
+    }));
+  }
+  if (type === Rotate) {
+    const angles = props?.angles ?? props?.rotation;
+    if (renderCtx.referenceFeatures)
+      assertFiniteFeatureTransform(
+        (Array.isArray(angles) ? angles.slice(0, 3) : [props?.x, props?.y, props?.z]).map(
+          (value) => Number(
+            typeof value === "string" ? value.replace(/\s*deg$/i, "") : value ?? 0
+          )
+        )
+      );
+    const rot = Array.isArray(angles) ? [degToRad(angles[0]), degToRad(angles[1]), degToRad(angles[2])] : [
+      degToRad(props?.x ?? 0),
+      degToRad(props?.y ?? 0),
+      degToRad(props?.z ?? 0)
+    ];
+    const { mat4 } = renderCtx.jscad.maths;
+    const childContext = transformFeatureContext(
+      renderCtx,
+      mat4.fromTaitBryanRotation(mat4.create(), rot[2], rot[1], rot[0])
+    );
+    const geoms = (children ?? []).flatMap(
+      (c) => renderNode(c, colorCtx, childContext)
+    );
+    return geoms.map(({ geom, color, material }) => ({
+      material,
+      geom: transforms3.rotateZ(
+        rot[2],
+        transforms3.rotateY(rot[1], transforms3.rotateX(rot[0], geom))
+      ),
+      color
+    }));
+  }
+  if (type === Union || type === Subtract || type === Hull) {
+    const entries = (children ?? []).flatMap(
+      (c) => renderNode(c, colorCtx, renderCtx)
+    );
+    const geoms = entries.map((g) => g.geom);
+    if (geoms.length === 0) return [];
+    let geom;
+    if (type === Union) geom = booleans5.union(geoms);
+    else if (type === Subtract)
+      geom = booleans5.subtract(geoms[0], geoms.slice(1));
+    else geom = hulls2.hull(geoms);
+    return [
+      {
+        geom,
+        color: colorCtx,
+        material: type === Subtract ? entries[0]?.material : void 0
+      }
+    ];
+  }
+  if (type === Custom) {
+    const { name, reference, geometry } = props;
+    validateFeatureName(name);
+    if (reference && name === void 0)
+      throw new Error("Named JSCAD features require a nonblank name");
+    recordFeature(renderCtx, name, geometry);
+    if (reference) return [];
+    return [{ geom: props.geometry, color: colorCtx }];
+  }
+  if (type === Polygon) {
+    const points = props?.points ?? [];
+    const origin = points[0] ?? [0, 0];
+    const area = points.reduce((sum, point, index) => {
+      const next = points[(index + 1) % points.length];
+      return sum + (point[0] - origin[0]) * (next[1] - origin[1]) - (next[0] - origin[0]) * (point[1] - origin[1]);
+    }, 0);
+    const oriented = area < 0 ? [...points].reverse() : points;
+    const g2 = geometries9.geom2.fromPoints(oriented);
+    return [{ geom: g2, color: colorCtx ?? props?.color }];
+  }
+  if (type === ExtrudeLinear) {
+    const { topOutlineName, bottomOutlineName, twistAngle, twistSteps } = props;
+    const namedOutline = topOutlineName !== void 0 || bottomOutlineName !== void 0;
+    const height10 = props?.height ?? props?.h ?? 1;
+    validateFeatureName(topOutlineName);
+    validateFeatureName(bottomOutlineName);
+    if (namedOutline) {
+      if (!Number.isFinite(height10) || !Number.isFinite(twistAngle ?? 0))
+        throw new Error(
+          "Named extrusion outlines require finite height and twistAngle"
+        );
+      if (twistSteps !== void 0 && (!Number.isInteger(twistSteps) || twistSteps < 1))
+        throw new Error(
+          "Named extrusion outlines require positive integer twistSteps"
+        );
+    }
+    const entries = (children ?? []).flatMap(
+      (c) => renderNode(c, colorCtx, renderCtx)
+    );
+    const geoms2 = entries.map((g) => g.geom);
+    if (geoms2.length === 0) return [];
+    if (namedOutline && geoms2.length !== 1)
+      throw new Error("Named extrusion outlines require exactly one profile");
+    const base2 = geoms2.length > 1 ? booleans5.union(geoms2) : geoms2[0];
+    if (namedOutline && !geometries9.geom2.isA(base2) && !(geometries9.path2.isA(base2) && base2.isClosed))
+      throw new Error(
+        "Named extrusion outlines require a geom2 or closed path2 profile"
+      );
+    if (namedOutline && renderCtx.referenceFeatures) {
+      const { mat4 } = renderCtx.jscad.maths;
+      const topContext = transformFeatureContext(
+        renderCtx,
+        mat4.multiply(
+          mat4.create(),
+          mat4.fromTranslation(mat4.create(), [0, 0, height10]),
+          mat4.fromZRotation(mat4.create(), twistAngle ?? 0)
+        )
+      );
+      recordFeature(topContext, topOutlineName, base2);
+      recordFeature(renderCtx, bottomOutlineName, base2);
+    }
+    const g3 = extrusions9.extrudeLinear(
+      {
+        height: height10,
+        ...twistAngle !== void 0 ? { twistAngle } : {},
+        ...twistSteps !== void 0 ? { twistSteps } : {}
+      },
+      base2
+    );
+    return [
+      {
+        geom: g3,
+        color: colorCtx ?? props?.color,
+        material: entries.length === 1 ? entries[0]?.material : void 0
+      }
+    ];
+  }
+  if (type === Cuboid || type === Cube || type === Cylinder || type === Sphere || type === RoundedCuboid || type === RoundedCylinder) {
+    let g;
+    if (type === Cuboid) {
+      const size = props?.size ?? [1, 1, 1];
+      const offset = props?.offset;
+      const center = props?.center ?? (offset ? [offset[0], offset[1], offset[2]] : [0, 0, 0]);
+      g = primitives9.cuboid({ size, center });
+    } else if (type === Cube) {
+      const size = props?.size ?? 1;
+      const offset = props?.offset;
+      const center = props?.center ?? (offset ? [offset[0], offset[1], offset[2]] : [0, 0, 0]);
+      g = primitives9.cube({ size, center });
+    } else if (type === Cylinder) {
+      const height10 = props?.height ?? 1;
+      const radius = props?.radius ?? 1;
+      const center = props?.center ?? [0, 0, 0];
+      g = primitives9.cylinder({ height: height10, radius, center });
+    } else if (type === Sphere) {
+      const radius = props?.radius ?? 1;
+      const center = props?.center ?? [0, 0, 0];
+      g = primitives9.sphere({ radius, center });
+    } else if (type === RoundedCylinder) {
+      const height10 = props?.height ?? 1;
+      const radius = props?.radius ?? 1;
+      const roundRadius = props?.roundRadius ?? 0.1;
+      const center = props?.center ?? [0, 0, 0];
+      g = primitives9.roundedCylinder({ height: height10, radius, roundRadius, center });
+    } else {
+      const size = props?.size ?? [1, 1, 1];
+      const roundRadius = props?.roundRadius ?? 0.1;
+      const center = props?.center ?? [0, 0, 0];
+      g = primitives9.roundedCuboid({ size, roundRadius, center });
+    }
+    return [{ geom: g, color: colorCtx ?? props?.color }];
+  }
+  if (typeof type === "function") {
+    const out = type(props ?? {});
+    return renderNode(out, colorCtx, renderCtx);
+  }
+  return (children ?? []).flatMap((c) => renderNode(c, colorCtx, renderCtx));
+}
+function render(root, jscad22) {
+  jscad22 = withReferences(
+    jscad22
+  );
+  const geometries9 = renderNode(root, void 0, { jscad: jscad22 });
+  return {
+    geometries: geometries9.map(
+      (entry) => entry.material ? { ...entry, geom: { ...entry.geom, material: entry.material } } : entry
+    )
+  };
+}
+function renderToJscadModel(root, jscad22) {
+  jscad22 = withReferences(
+    jscad22
+  );
+  const referenceFeatures = /* @__PURE__ */ Object.create(null);
+  const geometries9 = renderNode(root, void 0, {
+    jscad: jscad22,
+    referenceFeatures,
+    matrix: jscad22.maths.mat4.create()
+  });
+  return {
+    geometries: geometries9.map(({ geom, color }) => {
+      if (color === void 0) return geom;
+      const { colors: colors2 } = jscad22;
+      const rgb = typeof color === "string" ? color.startsWith("#") ? colors2.hexToRgb(
+        /^#[\da-f]{3,4}$/i.test(color) ? `#${[...color.slice(1)].map((c) => c + c).join("")}` : color
+      ) : colors2.colorNameToRgb(color) : color;
+      if (!rgb) throw new Error(`Unknown JSCAD color "${color}"`);
+      return colors2.colorize(rgb, geom);
+    }),
+    referenceFeatures
+  };
+}
+
 // lib/vanilla/primitives.ts
 var Cuboid = /* @__PURE__ */ Symbol("Cuboid");
 var Cube = /* @__PURE__ */ Symbol("Cube");
@@ -12573,11 +13313,11 @@ var ModelRendererRegistry = class {
 };
 
 // lib/models/anglebar/geometry.ts
-import jscad from "@jscad/modeling";
-var { primitives, extrusions, geometries, modifiers, measurements } = jscad;
-var generalize = modifiers.generalize;
-var { rectangle, roundedRectangle, polygon } = primitives;
-var profile = (shape49, height10) => extrusions.extrudeLinear({ height: height10 }, shape49);
+import jscad3 from "@jscad/modeling";
+var { primitives: primitives2, extrusions: extrusions2, geometries: geometries2, modifiers: modifiers2, measurements: measurements2 } = jscad3;
+var generalize = modifiers2.generalize;
+var { rectangle, roundedRectangle, polygon } = primitives2;
+var profile = (shape49, height10) => extrusions2.extrudeLinear({ height: height10 }, shape49);
 function filletProfile(points, radii, width10, height10) {
   const outline = [];
   for (let i = 0; i < points.length; i++) {
@@ -12636,7 +13376,7 @@ function createAngleBarMesh(input) {
     { snap: true, triangulate: true },
     createAngleBarGeom(input)
   );
-  const epsilon = Math.max(...measurements.measureDimensions(geom)) * 1e-10;
+  const epsilon = Math.max(...measurements2.measureDimensions(geom)) * 1e-10;
   const positions = [];
   const indices = [];
   const lookup = /* @__PURE__ */ new Map();
@@ -12650,7 +13390,7 @@ function createAngleBarMesh(input) {
     }
     return index;
   };
-  for (const poly of geometries.geom3.toPolygons(geom)) {
+  for (const poly of geometries2.geom3.toPolygons(geom)) {
     for (let i = 1; i < poly.vertices.length - 1; i++) {
       const a = poly.vertices[0], b = poly.vertices[i], c = poly.vertices[i + 1];
       const u = b.map((x, j) => x - a[j]), v = c.map((x, j) => x - a[j]);
@@ -12683,7 +13423,7 @@ function register55(registry2) {
 }
 
 // lib/mechanical/indexedMeshToGeom3.ts
-import jscad2 from "@jscad/modeling";
+import jscad4 from "@jscad/modeling";
 function indexedMeshToGeom3(mesh) {
   const polygons = [];
   for (let i = 0; i < mesh.indices.length; i += 3)
@@ -12694,7 +13434,7 @@ function indexedMeshToGeom3(mesh) {
         mesh.positions[index * 3 + 2]
       ])
     );
-  return jscad2.geometries.geom3.fromPoints(polygons);
+  return jscad4.geometries.geom3.fromPoints(polygons);
 }
 
 // lib/models/ballbearing/mesh.ts
@@ -12823,11 +13563,11 @@ function createBallBearingMesh(input = {}, options = {}) {
       [ri + 0.15 * (ro - ri), 0.5 * t],
       [ro - 0.15 * (ro - ri), 0.5 * t]
     ];
-    const profile6 = sign === -1 ? shape49 : shape49.map(([r, z]) => [r, d.width - z]).reverse();
+    const profile5 = sign === -1 ? shape49 : shape49.map(([r, z]) => [r, d.width - z]).reverse();
     parts.push({
       name: `${face2} ${sign < 0 ? "lower" : "upper"}`,
       color: face2 === "sealed" ? "#252a30" : "#b5bbc3",
-      mesh: revolve(profile6, segments)
+      mesh: revolve(profile5, segments)
     });
   }
   return { ...combine(parts), parts };
@@ -12844,21 +13584,21 @@ function checkPrecision(lengths25) {
       "Bearing dimensions exceed the renderer's numerical resolution"
     );
 }
-function revolve(profile6, segments) {
+function revolve(profile5, segments) {
   const positions = [];
   const indices = [];
-  for (const [radius, z] of profile6)
+  for (const [radius, z] of profile5)
     for (let i = 0; i < segments; i++) {
       const angle = i * Math.PI * 2 / segments;
       const r = typeof radius === "number" ? radius : radius(angle);
       positions.push(r * Math.cos(angle), r * Math.sin(angle), z);
     }
-  for (let j = 0; j < profile6.length; j++)
+  for (let j = 0; j < profile5.length; j++)
     for (let i = 0; i < segments; i++) {
       const a = j * segments + i;
       const b = j * segments + (i + 1) % segments;
-      const c = (j + 1) % profile6.length * segments + (i + 1) % segments;
-      const e = (j + 1) % profile6.length * segments + i;
+      const c = (j + 1) % profile5.length * segments + (i + 1) % segments;
+      const e = (j + 1) % profile5.length * segments + i;
       indices.push(a, b, c, a, c, e);
     }
   return { positions, indices };
@@ -12869,7 +13609,7 @@ function annularSector(inner, outer, z0, z1, start, end, segments) {
     Math.ceil((end - start) / (2 * Math.PI) * segments)
   );
   const count = steps + 1;
-  const profile6 = [
+  const profile5 = [
     [outer, z0],
     [outer, z1],
     [inner, z1],
@@ -12877,7 +13617,7 @@ function annularSector(inner, outer, z0, z1, start, end, segments) {
   ];
   const positions = [];
   const indices = [];
-  for (const [r, z] of profile6)
+  for (const [r, z] of profile5)
     for (let i = 0; i <= steps; i++) {
       const angle = start + (end - start) * i / steps;
       positions.push(r * Math.cos(angle), r * Math.sin(angle), z);
@@ -13068,7 +13808,7 @@ function createBallTransferUnitMesh(input = {}) {
     );
   const segments = 96;
   const latitude = 48;
-  const profile6 = [
+  const profile5 = [
     [d.bodyRadius, 0],
     [d.bodyRadius, d.flangeBottomZ],
     [d.flangeRadius, d.flangeBottomZ],
@@ -13081,12 +13821,12 @@ function createBallTransferUnitMesh(input = {}) {
   for (let j = 1; j < latitude; j++) {
     const angle = j * Math.PI / latitude;
     if ((angle - openingAngle) * d.socketRadius > resolution7)
-      profile6.push([
+      profile5.push([
         d.socketRadius * Math.sin(angle),
         d.ballCenterZ + d.socketRadius * Math.cos(angle)
       ]);
   }
-  profile6.push([0, d.socketBottomZ], [0, 0]);
+  profile5.push([0, d.socketBottomZ], [0, 0]);
   const holes = d.mountingHoles.map(
     ({ x, y, diameter }) => circularProfile(x, y, diameter / 2, segments)
   );
@@ -13094,7 +13834,7 @@ function createBallTransferUnitMesh(input = {}) {
   const housing = joinProfileMeshes([
     // Cap faces are triangulated with all openings, rather than covered by
     // annular triangles and repaired afterward with Boolean subtraction.
-    revolve2(profile6, segments, /* @__PURE__ */ new Set([1, 3])),
+    revolve2(profile5, segments, /* @__PURE__ */ new Set([1, 3])),
     cap(
       flangeOutline,
       [circularProfile(0, 0, d.bodyRadius, segments), ...holes],
@@ -13131,10 +13871,10 @@ function createBallTransferUnitMesh(input = {}) {
   ];
   return { positions, indices, parts };
 }
-function revolve2(profile6, segments, omittedEdges = /* @__PURE__ */ new Set()) {
+function revolve2(profile5, segments, omittedEdges = /* @__PURE__ */ new Set()) {
   const positions = [];
   const indices = [];
-  const rings = profile6.map(([radius, z]) => {
+  const rings = profile5.map(([radius, z]) => {
     const start = positions.length / 3;
     const count = radius === 0 ? 1 : segments;
     for (let i = 0; i < count; i++) {
@@ -13416,11 +14156,11 @@ function register59(registry2) {
 }
 
 // lib/models/channelbar/geometry.ts
-import jscad3 from "@jscad/modeling";
-var { primitives: primitives2, extrusions: extrusions2, geometries: geometries2, modifiers: modifiers2, measurements: measurements2 } = jscad3;
-var generalize2 = modifiers2.generalize;
-var { rectangle: rectangle2, roundedRectangle: roundedRectangle2, polygon: polygon2 } = primitives2;
-var profile2 = (shape49, height10) => extrusions2.extrudeLinear({ height: height10 }, shape49);
+import jscad5 from "@jscad/modeling";
+var { primitives: primitives3, extrusions: extrusions3, geometries: geometries3, modifiers: modifiers3, measurements: measurements3 } = jscad5;
+var generalize2 = modifiers3.generalize;
+var { rectangle: rectangle2, roundedRectangle: roundedRectangle2, polygon: polygon2 } = primitives3;
+var profile2 = (shape49, height10) => extrusions3.extrudeLinear({ height: height10 }, shape49);
 function filletProfile2(points, radii, width10, height10) {
   const outline = [];
   for (let i = 0; i < points.length; i++) {
@@ -13490,7 +14230,7 @@ function createChannelBarMesh(input) {
     { snap: true, triangulate: true },
     createChannelBarGeom(input)
   );
-  const epsilon = Math.max(...measurements2.measureDimensions(geom)) * 1e-10;
+  const epsilon = Math.max(...measurements3.measureDimensions(geom)) * 1e-10;
   const positions = [];
   const indices = [];
   const lookup = /* @__PURE__ */ new Map();
@@ -13504,7 +14244,7 @@ function createChannelBarMesh(input) {
     }
     return index;
   };
-  for (const poly of geometries2.geom3.toPolygons(geom)) {
+  for (const poly of geometries3.geom3.toPolygons(geom)) {
     for (let i = 1; i < poly.vertices.length - 1; i++) {
       const a = poly.vertices[0], b = poly.vertices[i], c = poly.vertices[i + 1];
       const u = b.map((x, j) => x - a[j]), v = c.map((x, j) => x - a[j]);
@@ -13537,10 +14277,10 @@ function register60(registry2) {
 }
 
 // lib/models/clampingshaftcollar/mesh.ts
-import jscad5 from "@jscad/modeling";
+import jscad7 from "@jscad/modeling";
 
 // lib/mechanical/shaft-mount-geometry.ts
-import jscad4 from "@jscad/modeling";
+import jscad6 from "@jscad/modeling";
 var bodySegments = 64;
 var threadSegments = 24;
 var samplesPerTurn = 12;
@@ -13583,22 +14323,22 @@ function createAnnularSleeve({
     [chamfer, boreARadius, true],
     [0, boreARadius + chamfer, true]
   ];
-  const profile6 = raw.filter(
+  const profile5 = raw.filter(
     ([z, r], i) => i === 0 || z !== raw[i - 1][0] || r !== raw[i - 1][1]
   );
   const positions = [];
   const indices = [];
-  for (const [z, r, isBore] of profile6)
+  for (const [z, r, isBore] of profile5)
     for (let i = 0; i < bodySegments; i++) {
       const angle = (i + (isBore ? 0.5 : 0)) * Math.PI * 2 / bodySegments;
       const radius = isBore ? r / cosine : r;
       positions.push(radius * Math.cos(angle), radius * Math.sin(angle), z);
     }
-  for (let row = 0; row < profile6.length; row++)
+  for (let row = 0; row < profile5.length; row++)
     for (let i = 0; i < bodySegments; i++) {
       const next = (i + 1) % bodySegments;
       const a = row * bodySegments + i, b = row * bodySegments + next;
-      const c = (row + 1) % profile6.length * bodySegments + next, d = (row + 1) % profile6.length * bodySegments + i;
+      const c = (row + 1) % profile5.length * bodySegments + next, d = (row + 1) % profile5.length * bodySegments + i;
       indices.push(a, b, c, a, c, d);
     }
   return indexedMeshToGeom3({ positions, indices });
@@ -13656,10 +14396,10 @@ function createMountingHoleCutter(hole) {
 function subtractShaftMountParts(body, ...cutters) {
   const factor = 100;
   const scaled = [body, ...cutters].map(
-    (geometry) => jscad4.transforms.scale([factor, factor, factor], geometry)
+    (geometry) => jscad6.transforms.scale([factor, factor, factor], geometry)
   );
-  const result = jscad4.booleans.subtract(scaled[0], ...scaled.slice(1));
-  return jscad4.transforms.scale([1 / factor, 1 / factor, 1 / factor], result);
+  const result = jscad6.booleans.subtract(scaled[0], ...scaled.slice(1));
+  return jscad6.transforms.scale([1 / factor, 1 / factor, 1 / factor], result);
 }
 function finishShaftMountMesh(geometry) {
   const positions = [];
@@ -13685,7 +14425,7 @@ function finishShaftMountMesh(geometry) {
     vertices.set(key, [...vertices.get(key) ?? [], index]);
     return index;
   };
-  const polygons = jscad4.geometries.geom3.toPolygons(geometry).map(
+  const polygons = jscad6.geometries.geom3.toPolygons(geometry).map(
     (polygon4) => polygon4.vertices.map(weld).filter((id, i, ids) => id !== ids[(i + ids.length - 1) % ids.length])
   ).map((ids) => [...new Set(ids)]).filter((ids) => ids.length >= 3).filter((ids) => {
     let longest = 0;
@@ -13708,11 +14448,11 @@ function finishShaftMountMesh(geometry) {
       return Math.hypot(...delta.map((v, axis) => v - t * direction[axis])) >= tolerance;
     });
   });
-  const edgeKey = (a, b) => `${Math.min(a, b)},${Math.max(a, b)}`;
+  const edgeKey2 = (a, b) => `${Math.min(a, b)},${Math.max(a, b)}`;
   const edges = /* @__PURE__ */ new Map();
   for (const polygon4 of polygons)
     for (let i = 0; i < polygon4.length; i++) {
-      const a = polygon4[i], b = polygon4[(i + 1) % polygon4.length], key = edgeKey(a, b);
+      const a = polygon4[i], b = polygon4[(i + 1) % polygon4.length], key = edgeKey2(a, b);
       const edge = edges.get(key) ?? { a, b, count: 0 };
       edge.count++;
       edges.set(key, edge);
@@ -13797,7 +14537,7 @@ function createClampingShaftCollarMesh(input) {
   });
   const s = dimensions5.split;
   const epsilon = 1e-4;
-  const slit = jscad5.primitives.cuboid({
+  const slit = jscad7.primitives.cuboid({
     size: [
       s.xMax - s.xMin + epsilon,
       s.yMax - s.yMin,
@@ -14372,7 +15112,7 @@ function createFlangedBushingMesh(input) {
   const ri = d.innerDiameter / 2;
   const ro = d.outerDiameter / 2;
   const rf = d.flangeDiameter / 2;
-  const profile6 = [
+  const profile5 = [
     [rf, 0],
     [rf, d.shoulderZ],
     [ro, d.shoulderZ],
@@ -14383,14 +15123,14 @@ function createFlangedBushingMesh(input) {
   const segments = 96;
   const positions = [];
   const indices = [];
-  for (const [radius, z] of profile6)
+  for (const [radius, z] of profile5)
     for (let i = 0; i < segments; i++) {
       const angle = i * Math.PI * 2 / segments;
       positions.push(radius * Math.cos(angle), radius * Math.sin(angle), z);
     }
-  for (let ring = 0; ring < profile6.length; ring++) {
+  for (let ring = 0; ring < profile5.length; ring++) {
     const a = ring * segments;
-    const b = (ring + 1) % profile6.length * segments;
+    const b = (ring + 1) % profile5.length * segments;
     for (let i = 0; i < segments; i++) {
       const next = (i + 1) % segments;
       indices.push(a + i, a + next, b + next, a + i, b + next, b + i);
@@ -14535,15 +15275,15 @@ function register67(registry2) {
 }
 
 // lib/models/flatcableclip/geometry.ts
-import jscad6 from "@jscad/modeling";
+import jscad8 from "@jscad/modeling";
 var {
-  primitives: primitives3,
-  extrusions: extrusions3,
-  transforms,
-  booleans,
-  geometries: geometries3,
-  measurements: measurements3
-} = jscad6;
+  primitives: primitives4,
+  extrusions: extrusions4,
+  transforms: transforms2,
+  booleans: booleans2,
+  geometries: geometries4,
+  measurements: measurements4
+} = jscad8;
 function createFlatCableClipSolid(input) {
   const p = flatCableClipModelPropsSchema.parse(input);
   const legOuter = p.innerWidth / 2 + p.thickness, half = legOuter + p.footLength;
@@ -14561,25 +15301,25 @@ function createFlatCableClipSolid(input) {
     [-legOuter, p.thickness],
     [-half, p.thickness]
   ];
-  const bridge = transforms.translate(
+  const bridge = transforms2.translate(
     [0, p.depth / 2, 0],
-    transforms.rotateX(
+    transforms2.rotateX(
       Math.PI / 2,
-      extrusions3.extrudeLinear(
+      extrusions4.extrudeLinear(
         { height: p.depth },
-        primitives3.polygon({ points })
+        primitives4.polygon({ points })
       )
     )
   );
   const bores = [-1, 1].map(
-    (sign) => primitives3.cylinder({
+    (sign) => primitives4.cylinder({
       radius: p.holeDiameter / 2,
       height: p.thickness + 2,
       center: [sign * p.holePitch / 2, 0, p.thickness / 2],
       segments: 96
     })
   );
-  return booleans.subtract(bridge, ...bores);
+  return booleans2.subtract(bridge, ...bores);
 }
 function createFlatCableClipMesh(input) {
   const p = flatCableClipModelPropsSchema.parse(input);
@@ -14590,8 +15330,8 @@ function createFlatCableClipMesh(input) {
     [0, p.thickness, p.innerHeight, p.innerHeight + p.thickness]
   ];
   const geom = createFlatCableClipSolid(p);
-  const tolerance = Math.max(...measurements3.measureDimensions(geom)) * 1e-5;
-  const polygons = geometries3.geom3.toPolygons(geom).map(
+  const tolerance = Math.max(...measurements4.measureDimensions(geom)) * 1e-5;
+  const polygons = geometries4.geom3.toPolygons(geom).map(
     (poly) => poly.vertices.map(
       (point) => point.map((value, axis) => {
         const nearest = planes[axis].reduce(
@@ -14601,7 +15341,7 @@ function createFlatCableClipMesh(input) {
       })
     )
   );
-  return finishShaftMountMesh(geometries3.geom3.fromPoints(polygons));
+  return finishShaftMountMesh(geometries4.geom3.fromPoints(polygons));
 }
 function createFlatCableClipGeom(input) {
   return indexedMeshToGeom3(createFlatCableClipMesh(input));
@@ -16504,7 +17244,7 @@ function register79(registry2) {
 }
 
 // lib/utils/nemaMotorAssemblyGeometry.ts
-import jscad7 from "@jscad/modeling";
+import jscad9 from "@jscad/modeling";
 function nema34AssemblyCenters(p) {
   const edge = p.bodyWidth / 2;
   return [-1, 1].flatMap(
@@ -16514,16 +17254,16 @@ function nema34AssemblyCenters(p) {
   );
 }
 function cutNema34FrontRecesses(geometry, p) {
-  return jscad7.booleans.subtract(
+  return jscad9.booleans.subtract(
     geometry,
     ...nema34AssemblyCenters(p).flatMap(([x, y]) => [
-      jscad7.primitives.cylinder({
+      jscad9.primitives.cylinder({
         radius: 1.6,
         height: p.frontCapLength + 0.2,
         center: [x, y, -p.frontCapLength / 2],
         segments: 32
       }),
-      jscad7.primitives.cylinder({
+      jscad9.primitives.cylinder({
         radius: 5,
         height: Math.min(4, p.frontCapLength / 2) + 0.1,
         center: [
@@ -16537,8 +17277,8 @@ function cutNema34FrontRecesses(geometry, p) {
   );
 }
 function createNema34FrontScrews(p) {
-  const head = jscad7.booleans.subtract(
-    jscad7.primitives.ellipsoid({
+  const head = jscad9.booleans.subtract(
+    jscad9.primitives.ellipsoid({
       radius: [3.2, 3.2, 1.5],
       center: [0, 0, -1.8],
       segments: 32
@@ -16547,22 +17287,22 @@ function createNema34FrontScrews(p) {
       [3.7, 0.8, 1.1],
       [0.8, 3.7, 1.1]
     ].map(
-      (size) => jscad7.primitives.cuboid({
+      (size) => jscad9.primitives.cuboid({
         size,
         center: [0, 0, -0.8]
       })
     )
   );
   return nema34AssemblyCenters(p).map(
-    ([x, y]) => jscad7.transforms.translate([x, y, 0], head)
+    ([x, y]) => jscad9.transforms.translate([x, y, 0], head)
   );
 }
 
 // lib/NemaMotor.tsx
-import jscad9 from "@jscad/modeling";
+import jscad11 from "@jscad/modeling";
 
 // lib/utils/nemaMotorWireGeometry.ts
-import jscad8 from "@jscad/modeling";
+import jscad10 from "@jscad/modeling";
 
 // lib/utils/nemaMotorParameters.ts
 var resolveNemaMotorProps = nemaMotorModelPropsSchema.parse.bind(nemaMotorModelPropsSchema);
@@ -16573,12 +17313,12 @@ function createNemaMotorWireGeometry(input) {
   if (p.noWires) return [];
   const { position } = getNemaMotorReferencePoints(p).wireside;
   const angle = p.wireSideAngle * Math.PI / 180;
-  const place = (geometry) => jscad8.transforms.translate(
+  const place = (geometry) => jscad10.transforms.translate(
     [position.x, position.y, position.z],
-    jscad8.transforms.rotateZ(angle, geometry)
+    jscad10.transforms.rotateZ(angle, geometry)
   );
   if (p.wireStubs) {
-    const colors = [
+    const colors2 = [
       "#d53f3f",
       "#2463af",
       "#3b934b",
@@ -16589,17 +17329,17 @@ function createNemaMotorWireGeometry(input) {
       "#803e91"
     ];
     const wires = Array.from({ length: p.wireCount }, (_, i) => ({
-      color: colors[i],
+      color: colors2[i],
       geometry: place(
-        jscad8.transforms.translate(
+        jscad10.transforms.translate(
           [
             (p.wireLength - 0.15) / 2,
             (i - (p.wireCount - 1) / 2) * p.wireDiameter * 1.5,
             0
           ],
-          jscad8.transforms.rotateY(
+          jscad10.transforms.rotateY(
             Math.PI / 2,
-            jscad8.primitives.cylinder({
+            jscad10.primitives.cylinder({
               height: p.wireLength + 0.15,
               radius: p.wireDiameter / 2,
               segments: 24
@@ -16612,7 +17352,7 @@ function createNemaMotorWireGeometry(input) {
       wires.unshift({
         color: "#252830",
         geometry: place(
-          jscad8.primitives.roundedCuboid({
+          jscad10.primitives.roundedCuboid({
             size: [3, p.wireCount * p.wireDiameter * 1.5 + 3, 6],
             center: [0.8, 0, 0],
             roundRadius: 1,
@@ -16627,12 +17367,12 @@ function createNemaMotorWireGeometry(input) {
   const wall = pitch === 2 ? 0.6 : 0.3;
   const contactLength = pitch === 2 ? 3.4 : 2.4;
   const contactSize = pitch === 2 ? 0.5 : 0.3;
-  const shell = jscad8.booleans.subtract(
-    jscad8.primitives.cuboid({
+  const shell = jscad10.booleans.subtract(
+    jscad10.primitives.cuboid({
       size: [matingDepth + 0.1, bodyWidth, bodyHeight],
       center: [(matingDepth - 0.1) / 2, 0, 0]
     }),
-    jscad8.primitives.cuboid({
+    jscad10.primitives.cuboid({
       size: [matingDepth - 0.5, bodyWidth - 2 * wall, bodyHeight - 2 * wall],
       center: [matingDepth / 2 + 0.55, 0, 0]
     })
@@ -16642,7 +17382,7 @@ function createNemaMotorWireGeometry(input) {
     ...Array.from({ length: pinCount }, (_, i) => ({
       color: "#b8bec6",
       geometry: place(
-        jscad8.primitives.cuboid({
+        jscad10.primitives.cuboid({
           size: [contactLength, contactSize, contactSize],
           center: [contactLength / 2, (i - (pinCount - 1) / 2) * pitch, 0]
         })
@@ -16786,12 +17526,12 @@ function createNemaMotorSections(input) {
   else {
     const cut = r - p.shaftFlatDepth;
     const angle = Math.acos(cut / r);
-    const profile6 = Array.from({ length: 97 }, (_, i) => {
+    const profile5 = Array.from({ length: 97 }, (_, i) => {
       const a = angle + (2 * Math.PI - 2 * angle) * i / 96;
       return [r * Math.cos(a), r * Math.sin(a)];
     });
     const rotation = p.shaftFlatAngle * Math.PI / 180;
-    const d = profile6.map(([x, y]) => [
+    const d = profile5.map(([x, y]) => [
       x * Math.cos(rotation) - y * Math.sin(rotation),
       x * Math.sin(rotation) + y * Math.cos(rotation)
     ]);
@@ -16802,7 +17542,7 @@ function createNemaMotorSections(input) {
 }
 
 // lib/NemaMotor.tsx
-var generalize3 = jscad9.modifiers.generalize;
+var generalize3 = jscad11.modifiers.generalize;
 function NemaMotor({
   bodyColor = "#242830",
   capColor = "#aeb5bd",
@@ -16811,7 +17551,7 @@ function NemaMotor({
   ...props
 }) {
   const p = resolveNemaMotorProps(props);
-  const screw = p.backFaceScrews ? jscad9.transforms.rotateX(
+  const screw = p.backFaceScrews ? jscad11.transforms.rotateX(
     Math.PI,
     createHexSocketBoltGeom({
       metricSize: p.backFaceScrewSize,
@@ -16823,16 +17563,16 @@ function NemaMotor({
   const halfPitchY = p.backFaceHoleSpacingY / 2;
   return /* @__PURE__ */ jsxs(Fragment2, { children: [
     createNemaMotorSections(p).map((section, index) => {
-      const outline = jscad9.geometries.geom2.fromPoints(section.outline);
-      const profile6 = section.holes.length ? jscad9.booleans.subtract(
+      const outline = jscad11.geometries.geom2.fromPoints(section.outline);
+      const profile5 = section.holes.length ? jscad11.booleans.subtract(
         outline,
-        ...section.holes.map((h2) => jscad9.geometries.geom2.fromPoints(h2))
+        ...section.holes.map((h2) => jscad11.geometries.geom2.fromPoints(h2))
       ) : outline;
-      let geometry = jscad9.transforms.translate(
+      let geometry = jscad11.transforms.translate(
         [0, 0, section.zMin],
-        jscad9.extrusions.extrudeLinear(
+        jscad11.extrusions.extrudeLinear(
           { height: section.zMax - section.zMin },
-          profile6
+          profile5
         )
       );
       if (p.nemaSize === 34 && section.name === "frontCap")
@@ -16874,7 +17614,7 @@ function NemaMotor({
           children: /* @__PURE__ */ jsx(
             Custom,
             {
-              geometry: jscad9.transforms.translate(
+              geometry: jscad11.transforms.translate(
                 [x, y, -p.bodyLength],
                 generalize3({ simplify: true }, screw)
               )
@@ -17364,19 +18104,19 @@ function register83(registry2) {
 }
 
 // lib/models/perforatedsheet/geometry.ts
-import jscad10 from "@jscad/modeling";
+import jscad12 from "@jscad/modeling";
 var {
-  booleans: booleans2,
-  primitives: primitives4,
-  extrusions: extrusions4,
-  geometries: geometries4,
-  modifiers: modifiers3,
-  measurements: measurements4
-} = jscad10;
-var generalize4 = modifiers3.generalize;
-var { subtract } = booleans2;
-var { rectangle: rectangle3, roundedRectangle: roundedRectangle3, circle: circle2 } = primitives4;
-var profile3 = (shape49, height10) => extrusions4.extrudeLinear({ height: height10 }, shape49);
+  booleans: booleans3,
+  primitives: primitives5,
+  extrusions: extrusions5,
+  geometries: geometries5,
+  modifiers: modifiers4,
+  measurements: measurements5
+} = jscad12;
+var generalize4 = modifiers4.generalize;
+var { subtract } = booleans3;
+var { rectangle: rectangle3, roundedRectangle: roundedRectangle3, circle: circle2 } = primitives5;
+var profile3 = (shape49, height10) => extrusions5.extrudeLinear({ height: height10 }, shape49);
 function perforated(p) {
   const holes = [];
   const rows = Math.floor((p.width - 2 * p.edgeY) / p.pitchY + 1 + 1e-10);
@@ -17407,7 +18147,7 @@ function createPerforatedSheetMesh(input) {
     { snap: true, triangulate: true },
     createPerforatedSheetGeom(input)
   );
-  const epsilon = Math.max(...measurements4.measureDimensions(geom)) * 1e-10;
+  const epsilon = Math.max(...measurements5.measureDimensions(geom)) * 1e-10;
   const positions = [];
   const indices = [];
   const lookup = /* @__PURE__ */ new Map();
@@ -17421,7 +18161,7 @@ function createPerforatedSheetMesh(input) {
     }
     return index;
   };
-  for (const poly of geometries4.geom3.toPolygons(geom)) {
+  for (const poly of geometries5.geom3.toPolygons(geom)) {
     for (let i = 1; i < poly.vertices.length - 1; i++) {
       const a = poly.vertices[0], b = poly.vertices[i], c = poly.vertices[i + 1];
       const u = b.map((x, j) => x - a[j]), v = c.map((x, j) => x - a[j]);
@@ -17463,7 +18203,7 @@ function createPlainBushingMesh(input) {
   const ri = d.innerDiameter / 2;
   const ro = d.outerDiameter / 2;
   const c = props.edgeChamfer;
-  const profile6 = c > 0 ? [
+  const profile5 = c > 0 ? [
     [d.endOuterDiameter / 2, 0],
     [ro, c],
     [ro, d.length - c],
@@ -17481,14 +18221,14 @@ function createPlainBushingMesh(input) {
   const segments = 96;
   const positions = [];
   const indices = [];
-  for (const [radius, z] of profile6)
+  for (const [radius, z] of profile5)
     for (let i = 0; i < segments; i++) {
       const angle = i * Math.PI * 2 / segments;
       positions.push(radius * Math.cos(angle), radius * Math.sin(angle), z);
     }
-  for (let ring = 0; ring < profile6.length; ring++) {
+  for (let ring = 0; ring < profile5.length; ring++) {
     const a = ring * segments;
-    const b = (ring + 1) % profile6.length * segments;
+    const b = (ring + 1) % profile5.length * segments;
     for (let i = 0; i < segments; i++) {
       const next = (i + 1) % segments;
       indices.push(a + i, a + next, b + next, a + i, b + next, b + i);
@@ -17520,13 +18260,13 @@ function register85(registry2) {
 }
 
 // lib/models/pushfitplug/geometry.ts
-import jscad11 from "@jscad/modeling";
-var { primitives: primitives5, extrusions: extrusions5, geometries: geometries5, modifiers: modifiers4, measurements: measurements5 } = jscad11;
-var generalize5 = modifiers4.generalize;
-var { rectangle: rectangle4, roundedRectangle: roundedRectangle4, polygon: polygon3 } = primitives5;
+import jscad13 from "@jscad/modeling";
+var { primitives: primitives6, extrusions: extrusions6, geometries: geometries6, modifiers: modifiers5, measurements: measurements6 } = jscad13;
+var generalize5 = modifiers5.generalize;
+var { rectangle: rectangle4, roundedRectangle: roundedRectangle4, polygon: polygon3 } = primitives6;
 function createPushFitPlugGeom(input) {
   const p = pushFitPlugModelPropsSchema.parse(input);
-  return extrusions5.extrudeRotate(
+  return extrusions6.extrudeRotate(
     { segments: 64 },
     polygon3({
       points: [
@@ -17545,7 +18285,7 @@ function createPushFitPlugMesh(input) {
     { snap: true, triangulate: true },
     createPushFitPlugGeom(input)
   );
-  const epsilon = Math.max(...measurements5.measureDimensions(geom)) * 1e-10;
+  const epsilon = Math.max(...measurements6.measureDimensions(geom)) * 1e-10;
   const positions = [];
   const indices = [];
   const lookup = /* @__PURE__ */ new Map();
@@ -17559,7 +18299,7 @@ function createPushFitPlugMesh(input) {
     }
     return index;
   };
-  for (const poly of geometries5.geom3.toPolygons(geom)) {
+  for (const poly of geometries6.geom3.toPolygons(geom)) {
     for (let i = 1; i < poly.vertices.length - 1; i++) {
       const a = poly.vertices[0], b = poly.vertices[i], c = poly.vertices[i + 1];
       const u = b.map((x, j) => x - a[j]), v = c.map((x, j) => x - a[j]);
@@ -17592,11 +18332,11 @@ function register86(registry2) {
 }
 
 // lib/models/rectangularbar/geometry.ts
-import jscad12 from "@jscad/modeling";
-var { primitives: primitives6, extrusions: extrusions6, geometries: geometries6, modifiers: modifiers5, measurements: measurements6 } = jscad12;
-var generalize6 = modifiers5.generalize;
-var { rectangle: rectangle5, roundedRectangle: roundedRectangle5 } = primitives6;
-var profile4 = (shape49, height10) => extrusions6.extrudeLinear({ height: height10 }, shape49);
+import jscad14 from "@jscad/modeling";
+var { primitives: primitives7, extrusions: extrusions7, geometries: geometries7, modifiers: modifiers6, measurements: measurements7 } = jscad14;
+var generalize6 = modifiers6.generalize;
+var { rectangle: rectangle5, roundedRectangle: roundedRectangle5 } = primitives7;
+var profile4 = (shape49, height10) => extrusions7.extrudeLinear({ height: height10 }, shape49);
 var roundedRect = (width10, height10, radius) => radius ? roundedRectangle5({
   size: [width10, height10],
   roundRadius: radius,
@@ -17611,7 +18351,7 @@ function createRectangularBarMesh(input) {
     { snap: true, triangulate: true },
     createRectangularBarGeom(input)
   );
-  const epsilon = Math.max(...measurements6.measureDimensions(geom)) * 1e-10;
+  const epsilon = Math.max(...measurements7.measureDimensions(geom)) * 1e-10;
   const positions = [];
   const indices = [];
   const lookup = /* @__PURE__ */ new Map();
@@ -17625,7 +18365,7 @@ function createRectangularBarMesh(input) {
     }
     return index;
   };
-  for (const poly of geometries6.geom3.toPolygons(geom)) {
+  for (const poly of geometries7.geom3.toPolygons(geom)) {
     for (let i = 1; i < poly.vertices.length - 1; i++) {
       const a = poly.vertices[0], b = poly.vertices[i], c = poly.vertices[i + 1];
       const u = b.map((x, j) => x - a[j]), v = c.map((x, j) => x - a[j]);
@@ -17769,72 +18509,27 @@ function register88(registry2) {
   registry2.register(model88);
 }
 
-// lib/models/rectangulartube/geometry.ts
-import jscad13 from "@jscad/modeling";
-var {
-  booleans: booleans3,
-  primitives: primitives7,
-  extrusions: extrusions7,
-  geometries: geometries7,
-  modifiers: modifiers6,
-  measurements: measurements7
-} = jscad13;
-var generalize7 = modifiers6.generalize;
-var { subtract: subtract2 } = booleans3;
-var { rectangle: rectangle6, roundedRectangle: roundedRectangle6 } = primitives7;
-var profile5 = (shape49, height10) => extrusions7.extrudeLinear({ height: height10 }, shape49);
-var roundedRect2 = (width10, height10, radius) => radius ? roundedRectangle6({
+// lib/models/rectangulartube/profiles.ts
+import jscad15 from "@jscad/modeling";
+var roundedRectangle6 = (width10, height10, radius) => radius ? jscad15.primitives.roundedRectangle({
   size: [width10, height10],
   roundRadius: radius,
   segments: 64
-}) : rectangle6({ size: [width10, height10] });
-function createRectangularTubeGeom(input) {
+}) : jscad15.primitives.rectangle({ size: [width10, height10] });
+function getRectangularTubeProfiles(input) {
   const p = rectangularTubeModelPropsSchema.parse(input);
-  return profile5(
-    subtract2(
-      roundedRect2(p.width, p.height, p.outerRadius),
-      roundedRect2(
+  const points = (geometry) => jscad15.geometries.geom2.toPoints(geometry);
+  return {
+    length: p.length,
+    outerPoints: points(roundedRectangle6(p.width, p.height, p.outerRadius)),
+    innerPoints: points(
+      roundedRectangle6(
         p.width - 2 * p.wallThickness,
         p.height - 2 * p.wallThickness,
         p.innerRadius
       )
-    ),
-    p.length
-  );
-}
-function createRectangularTubeMesh(input) {
-  const geom = generalize7(
-    { snap: true, triangulate: true },
-    createRectangularTubeGeom(input)
-  );
-  const epsilon = Math.max(...measurements7.measureDimensions(geom)) * 1e-10;
-  const positions = [];
-  const indices = [];
-  const lookup = /* @__PURE__ */ new Map();
-  const vertex = (v) => {
-    const key = v.map((x) => Math.round(x / epsilon)).join(",");
-    let index = lookup.get(key);
-    if (index === void 0) {
-      index = positions.length / 3;
-      positions.push(...v);
-      lookup.set(key, index);
-    }
-    return index;
+    )
   };
-  for (const poly of geometries7.geom3.toPolygons(geom)) {
-    for (let i = 1; i < poly.vertices.length - 1; i++) {
-      const a = poly.vertices[0], b = poly.vertices[i], c = poly.vertices[i + 1];
-      const u = b.map((x, j) => x - a[j]), v = c.map((x, j) => x - a[j]);
-      const area = Math.hypot(
-        u[1] * v[2] - u[2] * v[1],
-        u[2] * v[0] - u[0] * v[2],
-        u[0] * v[1] - u[1] * v[0]
-      );
-      if (area > epsilon * epsilon)
-        indices.push(vertex(a), vertex(b), vertex(c));
-    }
-  }
-  return { positions, indices };
 }
 
 // lib/models/rectangulartube/RectangularTube.tsx
@@ -17842,7 +18537,27 @@ function RectangularTube({
   color = "#929da9",
   ...props
 }) {
-  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createRectangularTubeGeom(props) }) });
+  const { length: length32, outerPoints, innerPoints } = getRectangularTubeProfiles(props);
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsxs(Subtract, { children: [
+    /* @__PURE__ */ jsx(
+      ExtrudeLinear,
+      {
+        height: length32,
+        topOutlineName: "outer_top",
+        bottomOutlineName: "outer_bottom",
+        children: /* @__PURE__ */ jsx(Polygon, { points: outerPoints })
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ExtrudeLinear,
+      {
+        height: length32,
+        topOutlineName: "inner_top",
+        bottomOutlineName: "inner_bottom",
+        children: /* @__PURE__ */ jsx(Polygon, { points: innerPoints })
+      }
+    )
+  ] }) });
 }
 
 // lib/models/rectangulartube/register.tsx
@@ -18087,7 +18802,7 @@ function holeOutline(hole) {
 function createSheetMetalMesh(input) {
   const props = sheetMetalModelPropsSchema.parse(input);
   const { width: width10, baseLength, flangeHeight, thickness } = props;
-  const profile6 = props.channel ? "channel" : props.angle ? "angle" : "plate";
+  const profile5 = props.channel ? "channel" : props.angle ? "angle" : "plate";
   const radius = props.insideBendRadius + thickness / 2;
   const positions = [];
   const indices = [];
@@ -18100,10 +18815,10 @@ function createSheetMetalMesh(input) {
     addTriangle([vertices[0], vertices[1], vertices[2]], reverse);
     addTriangle([vertices[0], vertices[2], vertices[3]], reverse);
   };
-  const panels = profile6 === "plate" ? ["base"] : profile6 === "angle" ? ["base", "right"] : ["base", "left", "right"];
+  const panels = profile5 === "plate" ? ["base"] : profile5 === "angle" ? ["base", "right"] : ["base", "left", "right"];
   for (const hole of props.holes) {
     if (!panels.includes(hole.panel))
-      throw new Error(`No ${hole.panel} panel on ${profile6}`);
+      throw new Error(`No ${hole.panel} panel on ${profile5}`);
   }
   for (const panel of panels) {
     const length32 = panel === "base" ? baseLength : flangeHeight;
@@ -18154,7 +18869,7 @@ function createSheetMetalMesh(input) {
     for (const [loopIndex, loop] of loops.entries())
       for (let i = 0; i < loop.length; i++) {
         const a = loop[i], b = loop[(i + 1) % loop.length];
-        if (loopIndex === 0 && a.u === b.u && (panel === "base" && (a.u > 0 && profile6 !== "plate" || a.u < 0 && profile6 === "channel") || panel !== "base" && a.u < 0))
+        if (loopIndex === 0 && a.u === b.u && (panel === "base" && (a.u > 0 && profile5 !== "plate" || a.u < 0 && profile5 === "channel") || panel !== "base" && a.u < 0))
           continue;
         addQuad(
           [
@@ -18167,7 +18882,7 @@ function createSheetMetalMesh(input) {
         );
       }
   }
-  const sides = profile6 === "plate" ? [] : profile6 === "angle" ? [1] : [-1, 1];
+  const sides = profile5 === "plate" ? [] : profile5 === "angle" ? [1] : [-1, 1];
   for (const side of sides) {
     const project = (angle, crossSection) => {
       const r = radius - crossSection.offset;
@@ -18766,7 +19481,7 @@ function register100(registry2) {
 }
 
 // lib/models/tslotcoverstrip/geometry.ts
-import jscad16 from "@jscad/modeling";
+import jscad18 from "@jscad/modeling";
 var {
   primitives: primitives8,
   extrusions: extrusions8,
@@ -18774,8 +19489,8 @@ var {
   geometries: geometries8,
   modifiers: modifiers7,
   measurements: measurements8
-} = jscad16;
-var generalize8 = modifiers7.generalize;
+} = jscad18;
+var generalize7 = modifiers7.generalize;
 function createTSlotCoverStripGeom(input) {
   const p = tSlotCoverStripModelPropsSchema.parse(input);
   const w = p.width / 2;
@@ -18802,7 +19517,7 @@ function createTSlotCoverStripGeom(input) {
   return extrusions8.extrudeLinear({ height: p.length }, outline);
 }
 function createTSlotCoverStripMesh(input) {
-  const geom = generalize8(
+  const geom = generalize7(
     { snap: false, triangulate: true },
     createTSlotCoverStripGeom(input)
   );
@@ -19056,10 +19771,10 @@ function register104(registry2) {
 }
 
 // lib/models/ufl/geometry.ts
-import jscad17 from "@jscad/modeling";
+import jscad19 from "@jscad/modeling";
 function createUflGeometries(input = {}) {
   const d = getUflDimensions(input);
-  const { booleans: booleans5, primitives: primitives9 } = jscad17;
+  const { booleans: booleans5, primitives: primitives9 } = jscad19;
   const silver = "#bcbfc3";
   const dielectric = "#eee9d5";
   const gold = "#d9b45b";
@@ -19216,17 +19931,17 @@ var createWormGearMesh = (input) => {
         fractions.push(fraction);
     }
   }
-  const profile6 = [];
+  const profile5 = [];
   for (let start = 0; start < props.starts; start++) {
     for (const fraction of fractions) {
       const distance2 = Math.min(fraction, 1 - fraction) * axialPitch;
-      profile6.push({
+      profile5.push({
         angle: (start + fraction) * Math.PI * 2 / props.starts,
         radius: distance2 <= tipHalfWidth ? outsideRadius : distance2 >= rootHalfWidth ? rootRadius : pitchRadius + (toothThickness / 2 - distance2) / pressureTangent
       });
     }
   }
-  const count = profile6.length;
+  const count = profile5.length;
   const positions = [];
   const indices = [];
   const phase = props.phase % 360 * Math.PI / 180;
@@ -19234,7 +19949,7 @@ var createWormGearMesh = (input) => {
   const ring = (z) => {
     const first = positions.length / 3;
     const rotation = phase + direction * (z / lead) * Math.PI * 2;
-    for (const sample of profile6) {
+    for (const sample of profile5) {
       const angle = sample.angle + rotation;
       positions.push(
         sample.radius * Math.cos(angle),
@@ -27737,185 +28452,6 @@ var Footprinter3d = ({ footprint }) => {
   return null;
 };
 
-// lib/vanilla/render.ts
-var isVNode = (n) => n && typeof n === "object" && "type" in n;
-var degToRad = (v) => {
-  if (typeof v === "number") return v;
-  if (typeof v === "string") {
-    const m = /^(-?\d+(?:\.\d+)?)\s*deg$/i.exec(v);
-    if (m) return parseFloat(m[1]) * Math.PI / 180;
-    const n = Number(v);
-    if (!Number.isNaN(n)) return n;
-  }
-  return 0;
-};
-var toVec3 = (v) => {
-  if (Array.isArray(v))
-    return [Number(v[0]) || 0, Number(v[1]) || 0, Number(v[2]) || 0];
-  if (typeof v === "object" && v)
-    return [Number(v.x) || 0, Number(v.y) || 0, Number(v.z) || 0];
-  return [0, 0, 0];
-};
-function renderNode(node, colorCtx, renderCtx) {
-  const {
-    jscad: { primitives: primitives9, booleans: booleans5, hulls, geometries: geometries9, extrusions: extrusions9, transforms: transforms2 }
-  } = renderCtx;
-  if (node == null || node === false) return [];
-  if (Array.isArray(node))
-    return node.flatMap((n) => renderNode(n, colorCtx, renderCtx));
-  if (!isVNode(node)) return [];
-  const { type, props, children } = node;
-  if (props?.material) {
-    const { material, ...rest } = props;
-    return renderNode({ ...node, props: rest }, colorCtx, renderCtx).map(
-      (entry) => ({
-        ...entry,
-        material: { ...material },
-        geom: { ...entry.geom, material: { ...material } }
-      })
-    );
-  }
-  if (type === Fragment) {
-    return (children ?? []).flatMap((c) => renderNode(c, colorCtx, renderCtx));
-  }
-  if (type === Colorize) {
-    const newColor = props?.color;
-    return (children ?? []).flatMap(
-      (c) => renderNode(c, newColor ?? colorCtx, renderCtx)
-    );
-  }
-  if (type === Translate) {
-    const off = toVec3(
-      props?.offset ?? props?.center ?? { x: props?.x, y: props?.y, z: props?.z }
-    );
-    const geoms = (children ?? []).flatMap(
-      (c) => renderNode(c, colorCtx, renderCtx)
-    );
-    return geoms.map(({ geom, color, material }) => ({
-      material,
-      geom: transforms2.translate(off, geom),
-      color: color ?? colorCtx
-    }));
-  }
-  if (type === Rotate) {
-    const angles = props?.angles ?? props?.rotation;
-    const rot = Array.isArray(angles) ? [degToRad(angles[0]), degToRad(angles[1]), degToRad(angles[2])] : [
-      degToRad(props?.x ?? 0),
-      degToRad(props?.y ?? 0),
-      degToRad(props?.z ?? 0)
-    ];
-    const geoms = (children ?? []).flatMap(
-      (c) => renderNode(c, colorCtx, renderCtx)
-    );
-    return geoms.map(({ geom, color, material }) => ({
-      material,
-      geom: transforms2.rotateZ(
-        rot[2],
-        transforms2.rotateY(rot[1], transforms2.rotateX(rot[0], geom))
-      ),
-      color
-    }));
-  }
-  if (type === Union || type === Subtract || type === Hull) {
-    const entries = (children ?? []).flatMap(
-      (c) => renderNode(c, colorCtx, renderCtx)
-    );
-    const geoms = entries.map((g) => g.geom);
-    if (geoms.length === 0) return [];
-    let geom;
-    if (type === Union) geom = booleans5.union(geoms);
-    else if (type === Subtract)
-      geom = booleans5.subtract(geoms[0], geoms.slice(1));
-    else geom = hulls.hull(geoms);
-    return [
-      {
-        geom,
-        color: colorCtx,
-        material: type === Subtract ? entries[0]?.material : void 0
-      }
-    ];
-  }
-  if (type === Custom) {
-    return [{ geom: props.geometry, color: colorCtx }];
-  }
-  if (type === Polygon) {
-    const points = props?.points ?? [];
-    const g2 = geometries9.geom2.fromPoints(points);
-    return [{ geom: g2, color: colorCtx ?? props?.color }];
-  }
-  if (type === ExtrudeLinear) {
-    const entries = (children ?? []).flatMap(
-      (c) => renderNode(c, colorCtx, renderCtx)
-    );
-    const geoms2 = entries.map((g) => g.geom);
-    if (geoms2.length === 0) return [];
-    const base2 = geoms2.length > 1 ? booleans5.union(geoms2) : geoms2[0];
-    const height10 = props?.height ?? props?.h ?? 1;
-    let g3 = extrusions9.extrudeLinear({ height: height10 }, base2);
-    if (g3.polygons) {
-      for (const poly of g3.polygons) {
-        if (!poly.plane || !poly.vertices || poly.vertices.length < 3) continue;
-        poly.vertices.reverse();
-      }
-    }
-    return [
-      {
-        geom: g3,
-        color: colorCtx ?? props?.color,
-        material: entries.length === 1 ? entries[0]?.material : void 0
-      }
-    ];
-  }
-  if (type === Cuboid || type === Cube || type === Cylinder || type === Sphere || type === RoundedCuboid || type === RoundedCylinder) {
-    let g;
-    if (type === Cuboid) {
-      const size = props?.size ?? [1, 1, 1];
-      const offset = props?.offset;
-      const center = props?.center ?? (offset ? [offset[0], offset[1], offset[2]] : [0, 0, 0]);
-      g = primitives9.cuboid({ size, center });
-    } else if (type === Cube) {
-      const size = props?.size ?? 1;
-      const offset = props?.offset;
-      const center = props?.center ?? (offset ? [offset[0], offset[1], offset[2]] : [0, 0, 0]);
-      g = primitives9.cube({ size, center });
-    } else if (type === Cylinder) {
-      const height10 = props?.height ?? 1;
-      const radius = props?.radius ?? 1;
-      const center = props?.center ?? [0, 0, 0];
-      g = primitives9.cylinder({ height: height10, radius, center });
-    } else if (type === Sphere) {
-      const radius = props?.radius ?? 1;
-      const center = props?.center ?? [0, 0, 0];
-      g = primitives9.sphere({ radius, center });
-    } else if (type === RoundedCylinder) {
-      const height10 = props?.height ?? 1;
-      const radius = props?.radius ?? 1;
-      const roundRadius = props?.roundRadius ?? 0.1;
-      const center = props?.center ?? [0, 0, 0];
-      g = primitives9.roundedCylinder({ height: height10, radius, roundRadius, center });
-    } else {
-      const size = props?.size ?? [1, 1, 1];
-      const roundRadius = props?.roundRadius ?? 0.1;
-      const center = props?.center ?? [0, 0, 0];
-      g = primitives9.roundedCuboid({ size, roundRadius, center });
-    }
-    return [{ geom: g, color: colorCtx ?? props?.color }];
-  }
-  if (typeof type === "function") {
-    const out = type(props ?? {});
-    return renderNode(out, colorCtx, renderCtx);
-  }
-  return (children ?? []).flatMap((c) => renderNode(c, colorCtx, renderCtx));
-}
-function render(root, jscad18) {
-  const geometries9 = renderNode(root, void 0, { jscad: jscad18 });
-  return {
-    geometries: geometries9.map(
-      (entry) => entry.material ? { ...entry, geom: { ...entry.geom, material: entry.material } } : entry
-    )
-  };
-}
-
 // lib/vanilla/convertCSGToThreeGeom.ts
 import {
   BufferAttribute,
@@ -27926,16 +28462,16 @@ function convertCSGToThreeGeom(csg) {
   if (csg.polygons) {
     const vertices = [];
     const indices = [];
-    const colors = [];
+    const colors2 = [];
     let idx = 0;
     for (const polygon4 of csg.polygons) {
       for (const vertex of polygon4.vertices) {
         vertex.index = idx;
         vertices.push(vertex[0], vertex[1], vertex[2]);
         if (csg.color && csg.color.length >= 3) {
-          colors.push(csg.color[0], csg.color[1], csg.color[2]);
+          colors2.push(csg.color[0], csg.color[1], csg.color[2]);
         } else {
-          colors.push(1, 1, 1);
+          colors2.push(1, 1, 1);
         }
         idx++;
       }
@@ -27952,29 +28488,29 @@ function convertCSGToThreeGeom(csg) {
       new BufferAttribute(new Float32Array(vertices), 3)
     );
     geo.setIndex(indices);
-    if (colors.length > 0) {
+    if (colors2.length > 0) {
       geo.setAttribute(
         "color",
-        new BufferAttribute(new Float32Array(colors), 3)
+        new BufferAttribute(new Float32Array(colors2), 3)
       );
     }
     if (csg.transforms) {
-      const transforms2 = new Matrix4();
-      transforms2.fromArray(csg.transforms);
-      geo.applyMatrix4(transforms2);
+      const transforms3 = new Matrix4();
+      transforms3.fromArray(csg.transforms);
+      geo.applyMatrix4(transforms3);
     }
     geo.computeVertexNormals();
     return geo;
   }
   if (csg.sides) {
     const vertices = [];
-    const colors = [];
+    const colors2 = [];
     for (const side of csg.sides) {
       vertices.push(side[0][0], side[0][1], 0);
       if (csg.color && csg.color.length >= 3) {
-        colors.push(csg.color[0], csg.color[1], csg.color[2]);
+        colors2.push(csg.color[0], csg.color[1], csg.color[2]);
       } else {
-        colors.push(1, 1, 1);
+        colors2.push(1, 1, 1);
       }
     }
     const geo = new BufferGeometry();
@@ -27982,16 +28518,16 @@ function convertCSGToThreeGeom(csg) {
       "position",
       new BufferAttribute(new Float32Array(vertices), 3)
     );
-    if (colors.length > 0) {
+    if (colors2.length > 0) {
       geo.setAttribute(
         "color",
-        new BufferAttribute(new Float32Array(colors), 3)
+        new BufferAttribute(new Float32Array(colors2), 3)
       );
     }
     if (csg.transforms) {
-      const transforms2 = new Matrix4();
-      transforms2.fromArray(csg.transforms);
-      geo.applyMatrix4(transforms2);
+      const transforms3 = new Matrix4();
+      transforms3.fromArray(csg.transforms);
+      geo.applyMatrix4(transforms3);
     }
     return geo;
   }
@@ -27999,25 +28535,104 @@ function convertCSGToThreeGeom(csg) {
   return new BufferGeometry();
 }
 
+// lib/named-edges.ts
+import jscad20 from "@jscad/modeling";
+function listJscadNamedEdges(model108) {
+  return listJscadReferenceFeatures(model108).filter((name) => {
+    const { geometry } = model108.referenceFeatures[name];
+    return jscad20.geometries.geom2.isA(geometry) || jscad20.geometries.path2.isA(geometry);
+  });
+}
+function listJscadReferenceFeatures(model108) {
+  return Object.keys(model108.referenceFeatures);
+}
+function readJscadReferenceFeature(model108, name) {
+  if (!Object.hasOwn(model108.referenceFeatures, name))
+    throw new Error(`JSCAD model does not define named feature "${name}"`);
+  return model108.referenceFeatures[name];
+}
+function readJscadNamedEdge(model108, name) {
+  const { geometry: feature, matrix } = readJscadReferenceFeature(model108, name);
+  if (matrix.length !== 16 || !matrix.every(Number.isFinite))
+    throw new Error(
+      `Named JSCAD feature "${name}" requires a finite 4x4 matrix`
+    );
+  let points;
+  let closed;
+  if (jscad20.geometries.path2.isA(feature)) {
+    const path = jscad20.geometries.path2.clone(feature);
+    points = jscad20.geometries.path2.toPoints(path);
+    closed = path.isClosed;
+  } else if (jscad20.geometries.geom2.isA(feature)) {
+    const outlines = jscad20.geometries.geom2.toOutlines(
+      jscad20.geometries.geom2.clone(feature)
+    );
+    if (outlines.length !== 1)
+      throw new Error(
+        `Named JSCAD edge "${name}" must identify one contour; name its boundaries separately`
+      );
+    points = outlines[0];
+    closed = true;
+  } else {
+    throw new Error(
+      `Named JSCAD edge "${name}" is not a geom2 or path2 feature`
+    );
+  }
+  if (points.length < 2)
+    throw new Error(`Named JSCAD edge "${name}" has no measurable path`);
+  return {
+    points: points.map(([x, y]) => {
+      const point = jscad20.maths.vec3.transform(
+        jscad20.maths.vec3.create(),
+        [x, y, 0],
+        matrix
+      );
+      return { x: point[0], y: point[1], z: point[2] };
+    }),
+    closed
+  };
+}
+
+// lib/models/rectangulartube/model.tsx
+import jscad21 from "@jscad/modeling";
+function createRectangularTubeModel(input) {
+  const model108 = renderToJscadModel(
+    /* @__PURE__ */ jsx(RectangularTube, { ...input }),
+    jscad21
+  );
+  if (model108.geometries.length !== 1 || !jscad21.geometries.geom3.isA(model108.geometries[0]))
+    throw new Error("RectangularTube must render exactly one native solid");
+  return model108;
+}
+
+// lib/models/rectangulartube/geometry.ts
+function createRectangularTubeGeom(input) {
+  const model108 = createRectangularTubeModel(input);
+  return model108.geometries[0];
+}
+function createRectangularTubeMesh(input) {
+  return geom3ToIndexedMesh(createRectangularTubeGeom(input));
+}
+
 // lib/vanilla/index.ts
-function getJscadModelForFootprint(footprint, jscad18) {
+function getJscadModelForFootprint(footprint, jscad22) {
   const vnode = h(Footprinter3d, { footprint });
-  return render(vnode, jscad18);
+  return render(vnode, jscad22);
 }
-function getJscadModelForFootprintWithPads(footprint, jscad18) {
+function getJscadModelForFootprintWithPads(footprint, jscad22) {
   const vnode = h(
     Fragment,
     {},
     h(Footprinter3d, { footprint }),
     h(ExtrudedPads, { footprint })
   );
-  return render(vnode, jscad18);
+  return render(vnode, jscad22);
 }
-function createJSCADRenderer(jscad18) {
+function createJSCADRenderer(jscad22) {
   function createJSCADRoot(container) {
     return {
       render(element) {
-        const { geometries: geometries9 } = render(element, jscad18);
+        const { geometries: geometries9 } = render(element, jscad22);
         container.splice(0, container.length, ...geometries9);
       }
     };
@@ -28152,6 +28767,7 @@ export {
   createRectangularGasketMesh,
   createRectangularTubeGeom,
   createRectangularTubeMesh,
+  createRectangularTubeModel,
   createRigidCouplerGeom,
   createRigidCouplerMesh,
   createSetScrewGeom,
@@ -28187,8 +28803,14 @@ export {
   createWormGearMesh,
   createZeeBarGeom,
   createZeeBarMesh,
+  geom3ToIndexedMesh,
   getJscadModelForFootprint,
   getJscadModelForFootprintWithPads,
-  h
+  h,
+  listJscadNamedEdges,
+  listJscadReferenceFeatures,
+  readJscadNamedEdge,
+  readJscadReferenceFeature,
+  renderToJscadModel
 };
 //# sourceMappingURL=vanilla.js.map