@tscircuit/3d-viewer 0.0.281 → 0.0.283

package/dist/index.js

@@ -9914,7 +9914,7 @@ var require_vectorText = __commonJS({
       }
       return line3;
     };
-    var vectorText3 = (options, text) => {
+    var vectorText2 = (options, text) => {
       const {
         xOffset,
         yOffset,
@@ -9971,7 +9971,7 @@ var require_vectorText = __commonJS({
       }
       return output;
     };
-    module.exports = vectorText3;
+    module.exports = vectorText2;
   }
 });
 
@@ -13980,7 +13980,7 @@ var require_browser = __commonJS({
 });
 
 // src/CadViewer.tsx
-import { useState as useState11, useRef as useRef8, useEffect as useEffect8 } from "react";
+import { useState as useState10, useRef as useRef8, useEffect as useEffect7 } from "react";
 
 // src/CadViewerJscad.tsx
 import { su as su4 } from "@tscircuit/soup-util";
@@ -17282,7 +17282,7 @@ import {
 // package.json
 var package_default = {
   name: "@tscircuit/3d-viewer",
-  version: "0.0.280",
+  version: "0.0.282",
   main: "./dist/index.js",
   module: "./dist/index.js",
   type: "module",
@@ -17314,7 +17314,7 @@ var package_default = {
     "@react-three/drei": "^9.121.4",
     "@react-three/fiber": "^8.17.14",
     "@tscircuit/core": "^0.0.454",
-    "@tscircuit/props": "^0.0.238",
+    "@tscircuit/props": "^0.0.240",
     "@tscircuit/soup-util": "^0.0.41",
     "jscad-electronics": "^0.0.29",
     "jscad-fiber": "^0.0.79",
@@ -17677,10 +17677,6 @@ var colors = {
   fr1Copper: [0.8, 0.4, 0.2],
   fr1CopperSolderWithMask: [0.9, 0.6, 0.2]
 };
-var MANIFOLD_Z_OFFSET = 1e-3;
-var SMOOTH_CIRCLE_SEGMENTS = 32;
-var DEFAULT_SMT_PAD_THICKNESS = 0.035;
-var TRACE_TEXTURE_RESOLUTION = 50;
 var boardMaterialColors = {
   fr1: colors.fr1Copper,
   fr4: colors.fr4Green
@@ -19056,14 +19052,13 @@ var CadViewerJscad = forwardRef2(
 );
 
 // src/CadViewerManifold.tsx
-import { su as su13 } from "@tscircuit/soup-util";
-import ManifoldModule from "manifold-3d";
-import { useEffect as useEffect6, useMemo as useMemo8, useState as useState9 } from "react";
+import { su as su6 } from "@tscircuit/soup-util";
+import { useMemo as useMemo8 } from "react";
 
 // src/hooks/useManifoldBoardBuilder.ts
 import { useState as useState8, useEffect as useEffect5, useMemo as useMemo7, useRef as useRef6 } from "react";
-import { su as su12 } from "@tscircuit/soup-util";
-import * as THREE10 from "three";
+import { su as su5 } from "@tscircuit/soup-util";
+import * as THREE5 from "three";
 
 // src/utils/manifold-mesh-to-three-geometry.ts
 import * as THREE4 from "three";
@@ -19086,914 +19081,150 @@ function manifoldMeshToThreeGeometry(manifoldMesh) {
   return geometry;
 }
 
-// src/utils/trace-texture.ts
-import * as THREE5 from "three";
-import { su as su5 } from "@tscircuit/soup-util";
-function isWireRoutePoint(point) {
-  return point && point.route_type === "wire" && typeof point.layer === "string" && typeof point.width === "number";
-}
-function createTraceTextureForLayer({
-  layer,
-  circuitJson,
-  boardData,
-  traceColor,
-  traceTextureResolution
-}) {
-  const pcbTraces = su5(circuitJson).pcb_trace.list();
-  const allPcbVias = su5(circuitJson).pcb_via.list();
-  const allPcbPlatedHoles = su5(
-    circuitJson
-  ).pcb_plated_hole.list();
-  const tracesOnLayer = pcbTraces.filter(
-    (t) => t.route.some((p) => isWireRoutePoint(p) && p.layer === layer)
-  );
-  if (tracesOnLayer.length === 0) return null;
-  const canvas = document.createElement("canvas");
-  const canvasWidth = Math.floor(boardData.width * traceTextureResolution);
-  const canvasHeight = Math.floor(boardData.height * traceTextureResolution);
-  canvas.width = canvasWidth;
-  canvas.height = canvasHeight;
-  const ctx = canvas.getContext("2d");
-  if (!ctx) return null;
-  if (layer === "bottom") {
-    ctx.translate(0, canvasHeight);
-    ctx.scale(1, -1);
-  }
-  tracesOnLayer.forEach((trace) => {
-    let firstPoint = true;
-    ctx.beginPath();
-    ctx.strokeStyle = traceColor;
-    ctx.lineCap = "round";
-    ctx.lineJoin = "round";
-    let currentLineWidth = 0;
-    for (const point of trace.route) {
-      if (!isWireRoutePoint(point) || point.layer !== layer) {
-        if (!firstPoint) ctx.stroke();
-        firstPoint = true;
-        continue;
-      }
-      const pcbX = point.x;
-      const pcbY = point.y;
-      currentLineWidth = point.width * traceTextureResolution;
-      ctx.lineWidth = currentLineWidth;
-      const canvasX = (pcbX - boardData.center.x + boardData.width / 2) * traceTextureResolution;
-      const canvasY = (-(pcbY - boardData.center.y) + boardData.height / 2) * traceTextureResolution;
-      if (firstPoint) {
-        ctx.moveTo(canvasX, canvasY);
-        firstPoint = false;
-      } else {
-        ctx.lineTo(canvasX, canvasY);
-      }
-    }
-    if (!firstPoint) {
-      ctx.stroke();
-    }
-  });
-  ctx.globalCompositeOperation = "destination-out";
-  ctx.fillStyle = "black";
-  allPcbVias.forEach((via) => {
-    const canvasX = (via.x - boardData.center.x + boardData.width / 2) * traceTextureResolution;
-    const canvasY = (-(via.y - boardData.center.y) + boardData.height / 2) * traceTextureResolution;
-    const canvasRadius = via.outer_diameter / 2 * traceTextureResolution;
-    ctx.beginPath();
-    ctx.arc(canvasX, canvasY, canvasRadius, 0, 2 * Math.PI, false);
-    ctx.fill();
-  });
-  allPcbPlatedHoles.forEach((ph) => {
-    if (ph.layers.includes(layer) && ph.shape === "circle") {
-      const canvasX = (ph.x - boardData.center.x + boardData.width / 2) * traceTextureResolution;
-      const canvasY = (-(ph.y - boardData.center.y) + boardData.height / 2) * traceTextureResolution;
-      const canvasRadius = ph.outer_diameter / 2 * traceTextureResolution;
-      ctx.beginPath();
-      ctx.arc(canvasX, canvasY, canvasRadius, 0, 2 * Math.PI, false);
-      ctx.fill();
-    }
-  });
-  ctx.globalCompositeOperation = "source-over";
-  const texture = new THREE5.CanvasTexture(canvas);
-  texture.generateMipmaps = true;
-  texture.minFilter = THREE5.LinearMipmapLinearFilter;
-  texture.magFilter = THREE5.LinearFilter;
-  texture.anisotropy = 16;
-  texture.needsUpdate = true;
-  return texture;
-}
-
-// src/utils/silkscreen-texture.ts
-var import_text2 = __toESM(require_text(), 1);
-import * as THREE6 from "three";
-import { su as su6 } from "@tscircuit/soup-util";
-function createSilkscreenTextureForLayer({
-  layer,
-  circuitJson,
-  boardData,
-  silkscreenColor = "rgb(255,255,255)",
-  traceTextureResolution
-}) {
-  const pcbSilkscreenTexts = su6(circuitJson).pcb_silkscreen_text.list();
-  const pcbSilkscreenPaths = su6(circuitJson).pcb_silkscreen_path.list();
-  const textsOnLayer = pcbSilkscreenTexts.filter((t) => t.layer === layer);
-  const pathsOnLayer = pcbSilkscreenPaths.filter((p) => p.layer === layer);
-  if (textsOnLayer.length === 0 && pathsOnLayer.length === 0) return null;
-  const canvas = document.createElement("canvas");
-  const canvasWidth = Math.floor(boardData.width * traceTextureResolution);
-  const canvasHeight = Math.floor(boardData.height * traceTextureResolution);
-  canvas.width = canvasWidth;
-  canvas.height = canvasHeight;
-  const ctx = canvas.getContext("2d");
-  if (!ctx) return null;
-  if (layer === "bottom") {
-    ctx.translate(0, canvasHeight);
-    ctx.scale(1, -1);
-  }
-  ctx.strokeStyle = silkscreenColor;
-  ctx.fillStyle = silkscreenColor;
-  pathsOnLayer.forEach((path) => {
-    if (path.route.length < 2) return;
-    ctx.beginPath();
-    ctx.lineWidth = (path.stroke_width || 0.1) * traceTextureResolution;
-    ctx.lineCap = "round";
-    ctx.lineJoin = "round";
-    path.route.forEach((point, index) => {
-      const canvasX = (point.x - boardData.center.x + boardData.width / 2) * traceTextureResolution;
-      const canvasY = (-(point.y - boardData.center.y) + boardData.height / 2) * traceTextureResolution;
-      if (index === 0) ctx.moveTo(canvasX, canvasY);
-      else ctx.lineTo(canvasX, canvasY);
-    });
-    ctx.stroke();
-  });
-  textsOnLayer.forEach((textS) => {
-    const fontSize = textS.font_size || 0.25;
-    const textStrokeWidth = Math.min(Math.max(0.01, fontSize * 0.1), fontSize * 0.05) * traceTextureResolution;
-    ctx.lineWidth = textStrokeWidth;
-    ctx.lineCap = "butt";
-    ctx.lineJoin = "miter";
-    const rawTextOutlines = (0, import_text2.vectorText)({
-      height: fontSize * 0.45,
-      input: textS.text
-    });
-    const processedTextOutlines = [];
-    rawTextOutlines.forEach((outline) => {
-      if (outline.length === 29) {
-        processedTextOutlines.push(
-          outline.slice(0, 15)
-        );
-        processedTextOutlines.push(
-          outline.slice(14, 29)
-        );
-      } else if (outline.length === 17) {
-        processedTextOutlines.push(
-          outline.slice(0, 10)
-        );
-        processedTextOutlines.push(
-          outline.slice(9, 17)
-        );
-      } else {
-        processedTextOutlines.push(outline);
-      }
-    });
-    const points = processedTextOutlines.flat();
-    const textBounds = {
-      minX: points.length > 0 ? Math.min(...points.map((p) => p[0])) : 0,
-      maxX: points.length > 0 ? Math.max(...points.map((p) => p[0])) : 0,
-      minY: points.length > 0 ? Math.min(...points.map((p) => p[1])) : 0,
-      maxY: points.length > 0 ? Math.max(...points.map((p) => p[1])) : 0
-    };
-    const textCenterX = (textBounds.minX + textBounds.maxX) / 2;
-    const textCenterY = (textBounds.minY + textBounds.maxY) / 2;
-    let xOff = -textCenterX;
-    let yOff = -textCenterY;
-    const alignment = textS.anchor_alignment || "center";
-    if (alignment.includes("left")) {
-      xOff = -textBounds.minX;
-    } else if (alignment.includes("right")) {
-      xOff = -textBounds.maxX;
-    }
-    if (alignment.includes("top")) {
-      yOff = -textBounds.maxY;
-    } else if (alignment.includes("bottom")) {
-      yOff = -textBounds.minY;
-    }
-    const transformMatrices = [];
-    let rotationDeg = textS.ccw_rotation ?? 0;
-    if (textS.layer === "bottom") {
-      transformMatrices.push(
-        translate2(textCenterX, textCenterY),
-        { a: -1, b: 0, c: 0, d: 1, e: 0, f: 0 },
-        translate2(-textCenterX, -textCenterY)
-      );
-      rotationDeg = -rotationDeg;
-    }
-    if (rotationDeg) {
-      const rad = rotationDeg * Math.PI / 180;
-      transformMatrices.push(
-        translate2(textCenterX, textCenterY),
-        rotate(rad),
-        translate2(-textCenterX, -textCenterY)
-      );
-    }
-    const finalTransformMatrix = transformMatrices.length > 0 ? compose(...transformMatrices) : void 0;
-    processedTextOutlines.forEach((segment) => {
-      ctx.beginPath();
-      segment.forEach((p, index) => {
-        let transformedP = { x: p[0], y: p[1] };
-        if (finalTransformMatrix) {
-          transformedP = applyToPoint(finalTransformMatrix, transformedP);
-        }
-        const pcbX = transformedP.x + xOff + textS.anchor_position.x;
-        const pcbY = transformedP.y + yOff + textS.anchor_position.y;
-        const canvasX = (pcbX - boardData.center.x + boardData.width / 2) * traceTextureResolution;
-        const canvasY = (-(pcbY - boardData.center.y) + boardData.height / 2) * traceTextureResolution;
-        if (index === 0) ctx.moveTo(canvasX, canvasY);
-        else ctx.lineTo(canvasX, canvasY);
-      });
-      ctx.stroke();
-    });
-  });
-  const texture = new THREE6.CanvasTexture(canvas);
-  texture.generateMipmaps = true;
-  texture.minFilter = THREE6.LinearMipmapLinearFilter;
-  texture.magFilter = THREE6.LinearFilter;
-  texture.anisotropy = 16;
-  texture.needsUpdate = true;
-  return texture;
-}
-
-// src/utils/manifold/process-non-plated-holes.ts
-import { su as su7 } from "@tscircuit/soup-util";
-
-// src/utils/hole-geoms.ts
-function createCircleHoleDrill({
-  Manifold,
-  x,
-  y,
-  diameter,
-  thickness,
-  segments = 32
-}) {
-  const drill = Manifold.cylinder(
-    thickness * 1.2,
-    diameter / 2,
-    diameter / 2,
-    segments,
-    true
-  );
-  return drill.translate([x, y, 0]);
-}
-function createPlatedHoleDrill({
-  Manifold,
-  x,
-  y,
-  outerDiameter,
-  thickness,
-  zOffset = 1e-3,
-  segments = 32
-}) {
-  const boardHoleRadius = outerDiameter / 2 + zOffset;
-  const drill = Manifold.cylinder(
-    thickness * 1.2,
-    boardHoleRadius,
-    boardHoleRadius,
-    segments,
-    true
-  );
-  return drill.translate([x, y, 0]);
-}
-
-// src/utils/manifold/process-non-plated-holes.ts
-function isCircleHole(hole) {
-  return (hole.shape === "circle" || hole.hole_shape === "circle") && typeof hole.hole_diameter === "number";
-}
-function processNonPlatedHolesForManifold(Manifold, circuitJson, pcbThickness, manifoldInstancesForCleanup) {
-  const nonPlatedHoleBoardDrills = [];
-  const pcbHoles = su7(circuitJson).pcb_hole.list();
-  pcbHoles.forEach((hole) => {
-    if (isCircleHole(hole)) {
-      const translatedDrill = createCircleHoleDrill({
-        Manifold,
-        x: hole.x,
-        y: hole.y,
-        diameter: hole.hole_diameter,
-        thickness: pcbThickness,
-        segments: SMOOTH_CIRCLE_SEGMENTS
-      });
-      manifoldInstancesForCleanup.push(translatedDrill);
-      nonPlatedHoleBoardDrills.push(translatedDrill);
-    }
-  });
-  return { nonPlatedHoleBoardDrills };
-}
-
-// src/utils/manifold/process-plated-holes.ts
-import { su as su8 } from "@tscircuit/soup-util";
-import * as THREE7 from "three";
-var COPPER_COLOR = new THREE7.Color(...colors.copper);
-function processPlatedHolesForManifold(Manifold, circuitJson, pcbThickness, manifoldInstancesForCleanup) {
-  const platedHoleBoardDrills = [];
-  const pcbPlatedHoles = su8(circuitJson).pcb_plated_hole.list();
-  const platedHoleCopperGeoms = [];
-  pcbPlatedHoles.forEach((ph, index) => {
-    if (ph.shape === "circle") {
-      const translatedDrill = createPlatedHoleDrill({
-        Manifold,
-        x: ph.x,
-        y: ph.y,
-        outerDiameter: ph.outer_diameter,
-        // Drill for the board
-        thickness: pcbThickness,
-        zOffset: MANIFOLD_Z_OFFSET,
-        segments: SMOOTH_CIRCLE_SEGMENTS
-      });
-      manifoldInstancesForCleanup.push(translatedDrill);
-      platedHoleBoardDrills.push(translatedDrill);
-      const copperPartThickness = pcbThickness + 2 * MANIFOLD_Z_OFFSET;
-      let platedPart = Manifold.cylinder(
-        copperPartThickness,
-        ph.outer_diameter / 2,
-        ph.outer_diameter / 2,
-        SMOOTH_CIRCLE_SEGMENTS,
-        true
-      );
-      manifoldInstancesForCleanup.push(platedPart);
-      const drillForCopper = Manifold.cylinder(
-        copperPartThickness * 1.05,
-        // ensure it cuts through
-        ph.hole_diameter / 2,
-        ph.hole_diameter / 2,
-        SMOOTH_CIRCLE_SEGMENTS,
-        true
-      );
-      manifoldInstancesForCleanup.push(drillForCopper);
-      const finalPlatedPartOp = platedPart.subtract(drillForCopper);
-      manifoldInstancesForCleanup.push(finalPlatedPartOp);
-      const translatedPlatedPart = finalPlatedPartOp.translate([ph.x, ph.y, 0]);
-      manifoldInstancesForCleanup.push(translatedPlatedPart);
-      const threeGeom = manifoldMeshToThreeGeometry(
-        translatedPlatedPart.getMesh()
-      );
-      platedHoleCopperGeoms.push({
-        key: `ph-${ph.pcb_plated_hole_id || index}`,
-        geometry: threeGeom,
-        color: COPPER_COLOR
-      });
-    } else if (ph.shape === "pill") {
-      const holeWidthRaw = ph.hole_width;
-      const holeHeightRaw = ph.hole_height;
-      const shouldRotate = holeHeightRaw > holeWidthRaw;
-      const holeW = shouldRotate ? holeHeightRaw : holeWidthRaw;
-      const holeH = shouldRotate ? holeWidthRaw : holeHeightRaw;
-      const defaultPadExtension = 0.4;
-      const outerW = shouldRotate ? ph.outer_height ?? holeH + defaultPadExtension / 2 : ph.outer_width ?? holeW + defaultPadExtension / 2;
-      const outerH = shouldRotate ? ph.outer_width ?? holeW + defaultPadExtension / 2 : ph.outer_height ?? holeH + defaultPadExtension / 2;
-      const createPill = (width, height, depth) => {
-        const radius = height / 2;
-        const rectLength = width - height;
-        let pillOp;
-        if (rectLength < 1e-9) {
-          pillOp = Manifold.cylinder(
-            depth,
-            radius,
-            radius,
-            SMOOTH_CIRCLE_SEGMENTS,
-            true
-          );
-        } else {
-          const rect = Manifold.cube(
-            [Math.max(0, rectLength), height, depth],
-            true
-          );
-          const cap1 = Manifold.cylinder(
-            depth,
-            radius,
-            radius,
-            SMOOTH_CIRCLE_SEGMENTS,
-            true
-          ).translate([-rectLength / 2, 0, 0]);
-          const cap2 = Manifold.cylinder(
-            depth,
-            radius,
-            radius,
-            SMOOTH_CIRCLE_SEGMENTS,
-            true
-          ).translate([rectLength / 2, 0, 0]);
-          pillOp = Manifold.union([rect, cap1, cap2]);
-          manifoldInstancesForCleanup.push(rect, cap1, cap2);
-        }
-        manifoldInstancesForCleanup.push(pillOp);
-        return pillOp;
-      };
-      const drillW = holeW + 2 * MANIFOLD_Z_OFFSET;
-      const drillH = holeH + 2 * MANIFOLD_Z_OFFSET;
-      const drillDepth = pcbThickness * 1.2;
-      let boardPillDrillOp = createPill(drillW, drillH, drillDepth);
-      if (shouldRotate) {
-        const rotatedOp = boardPillDrillOp.rotate([0, 0, 90]);
-        manifoldInstancesForCleanup.push(rotatedOp);
-        boardPillDrillOp = rotatedOp;
-      }
-      const translatedBoardPillDrill = boardPillDrillOp.translate([
-        ph.x,
-        ph.y,
-        0
-      ]);
-      manifoldInstancesForCleanup.push(translatedBoardPillDrill);
-      platedHoleBoardDrills.push(translatedBoardPillDrill);
-      const copperPartThickness = pcbThickness + 2 * MANIFOLD_Z_OFFSET;
-      const outerCopperOpUnrotated = createPill(
-        outerW,
-        outerH,
-        copperPartThickness
-      );
-      const innerDrillOpUnrotated = createPill(
-        holeW,
-        holeH,
-        copperPartThickness * 1.05
-        // Make drill slightly thicker to ensure cut
-      );
-      let finalPlatedPartOp = outerCopperOpUnrotated.subtract(
-        innerDrillOpUnrotated
-      );
-      manifoldInstancesForCleanup.push(finalPlatedPartOp);
-      if (shouldRotate) {
-        const rotatedOp = finalPlatedPartOp.rotate([0, 0, 90]);
-        manifoldInstancesForCleanup.push(rotatedOp);
-        finalPlatedPartOp = rotatedOp;
-      }
-      const translatedPlatedPart = finalPlatedPartOp.translate([ph.x, ph.y, 0]);
-      manifoldInstancesForCleanup.push(translatedPlatedPart);
-      const threeGeom = manifoldMeshToThreeGeometry(
-        translatedPlatedPart.getMesh()
-      );
-      platedHoleCopperGeoms.push({
-        key: `ph-${ph.pcb_plated_hole_id || index}`,
-        geometry: threeGeom,
-        color: COPPER_COLOR
-      });
-    }
-  });
-  return { platedHoleBoardDrills, platedHoleCopperGeoms };
-}
-
-// src/utils/manifold/process-vias.ts
-import { su as su9 } from "@tscircuit/soup-util";
-import * as THREE8 from "three";
-
-// src/utils/via-geoms.ts
-function createViaCopper({
-  Manifold,
-  x,
-  y,
-  outerDiameter,
-  holeDiameter,
-  thickness,
-  zOffset = 1e-3,
-  segments = 32
-}) {
-  const copperPartThickness = thickness + 2 * zOffset;
-  let viaCopper = Manifold.cylinder(
-    copperPartThickness,
-    outerDiameter / 2,
-    -1,
-    segments,
-    true
-  );
-  const drill = Manifold.cylinder(
-    copperPartThickness * 1.05,
-    holeDiameter / 2,
-    -1,
-    segments,
-    true
-  );
-  const finalViaCopperOp = viaCopper.subtract(drill);
-  return finalViaCopperOp.translate([x, y, 0]);
-}
-
-// src/utils/manifold/process-vias.ts
-var COPPER_COLOR2 = new THREE8.Color(...colors.copper);
-function processViasForManifold(Manifold, circuitJson, pcbThickness, manifoldInstancesForCleanup) {
-  const viaBoardDrills = [];
-  const pcbVias = su9(circuitJson).pcb_via.list();
-  const viaCopperGeoms = [];
-  pcbVias.forEach((via, index) => {
-    if (typeof via.outer_diameter === "number") {
-      const translatedDrill = createPlatedHoleDrill({
-        Manifold,
-        x: via.x,
-        y: via.y,
-        outerDiameter: via.outer_diameter,
-        thickness: pcbThickness,
-        zOffset: MANIFOLD_Z_OFFSET,
-        segments: SMOOTH_CIRCLE_SEGMENTS
-      });
-      manifoldInstancesForCleanup.push(translatedDrill);
-      viaBoardDrills.push(translatedDrill);
-    }
-    if (typeof via.outer_diameter === "number" && typeof via.hole_diameter === "number") {
-      const translatedViaCopper = createViaCopper({
-        Manifold,
-        x: via.x,
-        y: via.y,
-        outerDiameter: via.outer_diameter,
-        holeDiameter: via.hole_diameter,
-        thickness: pcbThickness,
-        zOffset: MANIFOLD_Z_OFFSET,
-        segments: SMOOTH_CIRCLE_SEGMENTS
-      });
-      manifoldInstancesForCleanup.push(translatedViaCopper);
-      const threeGeom = manifoldMeshToThreeGeometry(
-        translatedViaCopper.getMesh()
-      );
-      viaCopperGeoms.push({
-        key: `via-${via.pcb_via_id || index}`,
-        geometry: threeGeom,
-        color: COPPER_COLOR2
-      });
-    }
-  });
-  return { viaBoardDrills, viaCopperGeoms };
-}
-
-// src/utils/manifold/process-smt-pads.ts
-import { su as su10 } from "@tscircuit/soup-util";
-import * as THREE9 from "three";
-
-// src/utils/pad-geoms.ts
-function createPadManifoldOp({
-  Manifold,
-  pad,
-  padBaseThickness
-}) {
-  if (pad.shape === "rect") {
-    return Manifold.cube([pad.width, pad.height, padBaseThickness], true);
-  } else if (pad.shape === "circle" && pad.radius) {
-    return Manifold.cylinder(padBaseThickness, pad.radius, -1, 32, true);
-  }
-  return null;
-}
-
-// src/utils/manifold/process-smt-pads.ts
-var COPPER_COLOR3 = new THREE9.Color(...colors.copper);
-function processSmtPadsForManifold(Manifold, circuitJson, pcbThickness, manifoldInstancesForCleanup) {
-  const smtPadGeoms = [];
-  const smtPads = su10(circuitJson).pcb_smtpad.list();
-  smtPads.forEach((pad, index) => {
-    const padBaseThickness = DEFAULT_SMT_PAD_THICKNESS;
-    const zPos = pad.layer === "bottom" ? -pcbThickness / 2 - padBaseThickness / 2 - MANIFOLD_Z_OFFSET : pcbThickness / 2 + padBaseThickness / 2 + MANIFOLD_Z_OFFSET;
-    let padManifoldOp = createPadManifoldOp({
-      Manifold,
-      pad,
-      padBaseThickness
-    });
-    if (padManifoldOp) {
-      manifoldInstancesForCleanup.push(padManifoldOp);
-      const translatedPad = padManifoldOp.translate([pad.x, pad.y, zPos]);
-      manifoldInstancesForCleanup.push(translatedPad);
-      const threeGeom = manifoldMeshToThreeGeometry(translatedPad.getMesh());
-      smtPadGeoms.push({
-        key: `pad-${pad.pcb_smtpad_id || index}`,
-        geometry: threeGeom,
-        color: COPPER_COLOR3
-      });
-    }
-  });
-  return { smtPadGeoms };
-}
-
-// src/utils/manifold/create-manifold-board.ts
-var arePointsClockwise2 = (points) => {
-  let area = 0;
-  for (let i = 0; i < points.length; i++) {
-    const j = (i + 1) % points.length;
-    if (points[i] && points[j]) {
-      area += points[i][0] * points[j][1];
-      area -= points[j][0] * points[i][1];
-    }
-  }
-  const signedArea = area / 2;
-  return signedArea <= 0;
-};
-function createManifoldBoard(Manifold, CrossSection, boardData, pcbThickness, manifoldInstancesForCleanup) {
-  let boardOp;
-  if (boardData.outline && boardData.outline.length >= 3) {
-    let outlineVec2 = boardData.outline.map((p) => [
-      p.x,
-      p.y
-    ]);
-    if (arePointsClockwise2(outlineVec2)) {
-      outlineVec2 = outlineVec2.reverse();
-    }
-    const crossSection = CrossSection.ofPolygons([outlineVec2]);
-    manifoldInstancesForCleanup.push(crossSection);
-    boardOp = Manifold.extrude(
-      crossSection,
-      pcbThickness,
-      void 0,
-      // nDivisions
-      void 0,
-      // twistDegrees
-      void 0,
-      // scaleTop
-      true
-      // center (for Z-axis)
-    );
-  } else {
-    if (boardData.outline && boardData.outline.length > 0) {
-      console.warn(
-        "Board outline has fewer than 3 points, falling back to rectangular board."
-      );
-    }
-    boardOp = Manifold.cube(
-      [boardData.width, boardData.height, pcbThickness],
-      true
-      // center (for all axes)
-    );
-  }
-  manifoldInstancesForCleanup.push(boardOp);
-  boardOp = boardOp.translate([boardData.center.x, boardData.center.y, 0]);
-  manifoldInstancesForCleanup.push(boardOp);
-  return boardOp;
-}
-
-// src/utils/manifold/process-cutouts.ts
-import { su as su11 } from "@tscircuit/soup-util";
-var arePointsClockwise3 = (points) => {
-  let area = 0;
-  for (let i = 0; i < points.length; i++) {
-    const j = (i + 1) % points.length;
-    if (points[i] && points[j]) {
-      area += points[i][0] * points[j][1];
-      area -= points[j][0] * points[i][1];
-    }
-  }
-  const signedArea = area / 2;
-  return signedArea <= 0;
-};
-function processCutoutsForManifold(Manifold, CrossSection, circuitJson, pcbThickness, manifoldInstancesForCleanup) {
-  const cutoutOps = [];
-  const pcbCutouts = su11(circuitJson).pcb_cutout.list();
-  for (const cutout of pcbCutouts) {
-    let cutoutOp;
-    const cutoutHeight = pcbThickness * 1.5;
-    switch (cutout.shape) {
-      case "rect":
-        cutoutOp = Manifold.cube(
-          [cutout.width, cutout.height, cutoutHeight],
-          true
-          // centered
-        );
-        manifoldInstancesForCleanup.push(cutoutOp);
-        if (cutout.rotation) {
-          const rotationRadians = cutout.rotation * Math.PI / 180;
-          const rotatedOp = cutoutOp.rotate([0, 0, cutout.rotation]);
-          manifoldInstancesForCleanup.push(rotatedOp);
-          cutoutOp = rotatedOp;
-        }
-        cutoutOp = cutoutOp.translate([
-          cutout.center.x,
-          cutout.center.y,
-          0
-          // Centered vertically by Manifold.cube, so Z is 0 for board plane
-        ]);
-        manifoldInstancesForCleanup.push(cutoutOp);
-        break;
-      case "circle":
-        cutoutOp = Manifold.cylinder(
-          cutoutHeight,
-          cutout.radius,
-          -1,
-          // default for radiusHigh
-          SMOOTH_CIRCLE_SEGMENTS,
-          true
-          // centered
-        );
-        manifoldInstancesForCleanup.push(cutoutOp);
-        cutoutOp = cutoutOp.translate([cutout.center.x, cutout.center.y, 0]);
-        manifoldInstancesForCleanup.push(cutoutOp);
-        break;
-      case "polygon":
-        if (cutout.points.length < 3) {
-          console.warn(
-            `PCB Cutout [${cutout.pcb_cutout_id}] polygon has fewer than 3 points, skipping.`
-          );
-          continue;
-        }
-        let pointsVec2 = cutout.points.map((p) => [
-          p.x,
-          p.y
-        ]);
-        if (arePointsClockwise3(pointsVec2)) {
-          pointsVec2 = pointsVec2.reverse();
-        }
-        const crossSection = CrossSection.ofPolygons([pointsVec2]);
-        manifoldInstancesForCleanup.push(crossSection);
-        cutoutOp = Manifold.extrude(
-          crossSection,
-          cutoutHeight,
-          0,
-          // nDivisions
-          0,
-          // twistDegrees
-          [1, 1],
-          // scaleTop
-          true
-          // center extrusion
-        );
-        manifoldInstancesForCleanup.push(cutoutOp);
-        break;
-      default:
-        console.warn(
-          `Unsupported cutout shape: ${cutout.shape} for cutout ${cutout.pcb_cutout_id}`
-        );
-        continue;
-    }
-    if (cutoutOp) {
-      cutoutOps.push(cutoutOp);
-    }
-  }
-  return { cutoutOps };
-}
-
 // src/hooks/useManifoldBoardBuilder.ts
-var useManifoldBoardBuilder = (manifoldJSModule, circuitJson) => {
+var MANIFOLD_CDN_BASE_URL = "https://cdn.jsdelivr.net/npm/manifold-3d@3.1.1";
+var useManifoldBoardBuilder = (circuitJson) => {
   const [geoms, setGeoms] = useState8(null);
   const [textures, setTextures] = useState8(null);
   const [pcbThickness, setPcbThickness] = useState8(null);
   const [error, setError] = useState8(null);
   const [isLoading, setIsLoading] = useState8(true);
-  const manifoldInstancesForCleanup = useRef6([]);
-  const boardData = useMemo7(() => {
-    if (!circuitJson) return null;
-    const boards = su12(circuitJson).pcb_board.list();
-    if (boards.length === 0) {
-      return null;
-    }
-    return boards[0];
-  }, [circuitJson]);
+  const [boardData, setBoardData] = useState8(null);
+  const workerRef = useRef6(null);
   useEffect5(() => {
-    if (!manifoldJSModule || !circuitJson || !boardData) {
+    if (!circuitJson) {
       setGeoms(null);
       setTextures(null);
       setPcbThickness(null);
-      if (circuitJson && su12(circuitJson).pcb_board.list().length === 0) {
-        setError("No pcb_board found in circuitJson.");
-      }
+      setError(null);
+      setIsLoading(false);
+      setBoardData(null);
+      return;
+    }
+    const boards = su5(circuitJson).pcb_board.list();
+    if (boards.length === 0) {
+      setError("No pcb_board found in circuitJson.");
       setIsLoading(false);
       return;
     }
     setIsLoading(true);
     setError(null);
-    const Manifold = manifoldJSModule.Manifold;
-    const CrossSection = manifoldJSModule.CrossSection;
-    manifoldInstancesForCleanup.current.forEach((inst) => inst.delete());
-    manifoldInstancesForCleanup.current = [];
-    let boardManifold = null;
-    const currentGeoms = {};
-    const currentTextures = {};
-    try {
-      const currentPcbThickness = boardData.thickness || 1.6;
-      setPcbThickness(currentPcbThickness);
-      let currentBoardOp = createManifoldBoard(
-        Manifold,
-        CrossSection,
-        boardData,
-        currentPcbThickness,
-        manifoldInstancesForCleanup.current
-      );
-      const allBoardDrills = [];
-      const { nonPlatedHoleBoardDrills } = processNonPlatedHolesForManifold(
-        Manifold,
-        circuitJson,
-        currentPcbThickness,
-        manifoldInstancesForCleanup.current
-      );
-      allBoardDrills.push(...nonPlatedHoleBoardDrills);
-      const { platedHoleBoardDrills, platedHoleCopperGeoms } = processPlatedHolesForManifold(
-        Manifold,
-        circuitJson,
-        currentPcbThickness,
-        manifoldInstancesForCleanup.current
-      );
-      allBoardDrills.push(...platedHoleBoardDrills);
-      currentGeoms.platedHoles = platedHoleCopperGeoms;
-      const { viaBoardDrills, viaCopperGeoms } = processViasForManifold(
-        Manifold,
-        circuitJson,
-        currentPcbThickness,
-        manifoldInstancesForCleanup.current
-      );
-      allBoardDrills.push(...viaBoardDrills);
-      currentGeoms.vias = viaCopperGeoms;
-      if (allBoardDrills.length > 0) {
-        const unionedDrills = Manifold.union(allBoardDrills);
-        manifoldInstancesForCleanup.current.push(unionedDrills);
-        const nextBoardAfterDrills = currentBoardOp.subtract(unionedDrills);
-        manifoldInstancesForCleanup.current.push(nextBoardAfterDrills);
-        currentBoardOp = nextBoardAfterDrills;
-      }
-      const { cutoutOps } = processCutoutsForManifold(
-        Manifold,
-        CrossSection,
-        circuitJson,
-        currentPcbThickness,
-        manifoldInstancesForCleanup.current
-      );
-      if (cutoutOps.length > 0) {
-        const unionedCutouts = Manifold.union(cutoutOps);
-        manifoldInstancesForCleanup.current.push(unionedCutouts);
-        const nextBoardAfterCutouts = currentBoardOp.subtract(unionedCutouts);
-        manifoldInstancesForCleanup.current.push(nextBoardAfterCutouts);
-        currentBoardOp = nextBoardAfterCutouts;
-      }
-      boardManifold = currentBoardOp;
-      if (boardManifold) {
-        const boardThreeMesh = boardManifold.getMesh();
-        const finalBoardGeom = manifoldMeshToThreeGeometry(boardThreeMesh);
-        const matColorArray = boardMaterialColors[boardData.material] ?? colors.fr4Green;
-        currentGeoms.board = {
-          geometry: finalBoardGeom,
-          color: new THREE10.Color(
-            matColorArray[0],
-            matColorArray[1],
-            matColorArray[2]
-          )
-        };
+    setGeoms(null);
+    setTextures(null);
+    if (workerRef.current) {
+      workerRef.current.terminate();
+    }
+    const worker = new Worker(
+      new URL("../workers/manifold-builder.worker.ts", import.meta.url),
+      { type: "module" }
+    );
+    workerRef.current = worker;
+    worker.postMessage({
+      circuitJson,
+      manifoldPath: `${MANIFOLD_CDN_BASE_URL}/manifold.wasm`
+    });
+    worker.onmessage = (event) => {
+      const { type, payload, error: workerError, message } = event.data;
+      switch (type) {
+        case "pcb_thickness":
+          setPcbThickness(payload);
+          break;
+        case "board_data":
+          setBoardData(payload);
+          break;
+        case "geom_update":
+          setGeoms((prevGeoms) => {
+            const newGeoms = { ...prevGeoms };
+            if (payload.board) {
+              newGeoms.board = {
+                geometry: manifoldMeshToThreeGeometry(payload.board.mesh),
+                color: new THREE5.Color(...payload.board.color)
+              };
+            }
+            const processGeomArray = (key) => {
+              if (payload[key]) {
+                const geomArray = payload[key].map((item) => ({
+                  key: item.key,
+                  geometry: manifoldMeshToThreeGeometry(item.mesh),
+                  color: new THREE5.Color(...item.color)
+                }));
+                newGeoms[key] = [...newGeoms[key] ?? [], ...geomArray];
+              }
+            };
+            processGeomArray("platedHoles");
+            processGeomArray("smtPads");
+            processGeomArray("vias");
+            return newGeoms;
+          });
+          break;
+        case "texture_update":
+          setTextures((prevTextures) => {
+            const newTextures = { ...prevTextures };
+            for (const key in payload) {
+              const imageBitmap = payload[key];
+              const texture = new THREE5.CanvasTexture(imageBitmap);
+              texture.generateMipmaps = true;
+              texture.minFilter = THREE5.LinearMipmapLinearFilter;
+              texture.magFilter = THREE5.LinearFilter;
+              texture.anisotropy = 16;
+              texture.needsUpdate = true;
+              newTextures[key] = texture;
+            }
+            return newTextures;
+          });
+          break;
+        case "done":
+          setIsLoading(false);
+          break;
+        case "error":
+          setError(workerError);
+          setIsLoading(false);
+          break;
+        case "log":
+          console.time(message);
+          break;
+        case "log_end":
+          console.timeEnd(message);
+          break;
       }
-      const { smtPadGeoms } = processSmtPadsForManifold(
-        Manifold,
-        circuitJson,
-        currentPcbThickness,
-        manifoldInstancesForCleanup.current
-      );
-      currentGeoms.smtPads = smtPadGeoms;
-      setGeoms(currentGeoms);
-      const traceColorArr = tracesMaterialColors[boardData.material] ?? colors.fr4GreenSolderWithMask;
-      const traceColor = `rgb(${Math.round(traceColorArr[0] * 255)}, ${Math.round(traceColorArr[1] * 255)}, ${Math.round(traceColorArr[2] * 255)})`;
-      currentTextures.topTrace = createTraceTextureForLayer({
-        layer: "top",
-        circuitJson,
-        boardData,
-        traceColor,
-        traceTextureResolution: TRACE_TEXTURE_RESOLUTION
-      });
-      currentTextures.bottomTrace = createTraceTextureForLayer({
-        layer: "bottom",
-        circuitJson,
-        boardData,
-        traceColor,
-        traceTextureResolution: TRACE_TEXTURE_RESOLUTION
-      });
-      const silkscreenColor = "rgb(255,255,255)";
-      currentTextures.topSilkscreen = createSilkscreenTextureForLayer({
-        layer: "top",
-        circuitJson,
-        boardData,
-        silkscreenColor,
-        traceTextureResolution: TRACE_TEXTURE_RESOLUTION
-      });
-      currentTextures.bottomSilkscreen = createSilkscreenTextureForLayer({
-        layer: "bottom",
-        circuitJson,
-        boardData,
-        silkscreenColor,
-        traceTextureResolution: TRACE_TEXTURE_RESOLUTION
-      });
-      setTextures(currentTextures);
-    } catch (e) {
-      console.error("Error processing geometry with Manifold in hook:", e);
-      setError(
-        e.message || "An unknown error occurred while processing geometry in hook."
-      );
-      setGeoms(null);
-      setTextures(null);
-    } finally {
+    };
+    worker.onerror = (err) => {
+      setError(`Worker error: ${err.message}`);
       setIsLoading(false);
-    }
+    };
     return () => {
-      manifoldInstancesForCleanup.current.forEach((inst) => inst.delete());
-      manifoldInstancesForCleanup.current = [];
+      if (workerRef.current) {
+        workerRef.current.terminate();
+        workerRef.current = null;
+      }
     };
-  }, [manifoldJSModule, circuitJson, boardData]);
+  }, [circuitJson]);
+  const derivedBoardData = useMemo7(() => {
+    if (!circuitJson) return null;
+    const boards = su5(circuitJson).pcb_board.list();
+    return boards[0] ?? null;
+  }, [circuitJson]);
   return {
     geoms,
     textures,
     pcbThickness,
     error,
     isLoading,
-    boardData
+    boardData: boardData ?? derivedBoardData
   };
 };
 
 // src/utils/manifold/create-three-geometry-meshes.ts
-import * as THREE11 from "three";
+import * as THREE6 from "three";
 function createGeometryMeshes(geoms) {
   const meshes = [];
   if (!geoms) return meshes;
   if (geoms.board && geoms.board.geometry) {
-    const mesh = new THREE11.Mesh(
+    const mesh = new THREE6.Mesh(
       geoms.board.geometry,
-      new THREE11.MeshStandardMaterial({
+      new THREE6.MeshStandardMaterial({
         color: geoms.board.color,
-        side: THREE11.DoubleSide,
+        side: THREE6.DoubleSide,
         flatShading: true
       })
     );
@@ -20003,11 +19234,11 @@ function createGeometryMeshes(geoms) {
   const createMeshesFromArray = (geomArray) => {
     if (geomArray) {
       geomArray.forEach((comp) => {
-        const mesh = new THREE11.Mesh(
+        const mesh = new THREE6.Mesh(
           comp.geometry,
-          new THREE11.MeshStandardMaterial({
+          new THREE6.MeshStandardMaterial({
             color: comp.color,
-            side: THREE11.DoubleSide,
+            side: THREE6.DoubleSide,
             flatShading: true
             // Consistent with board
           })
@@ -20024,21 +19255,21 @@ function createGeometryMeshes(geoms) {
 }
 
 // src/utils/manifold/create-three-texture-meshes.ts
-import * as THREE12 from "three";
+import * as THREE7 from "three";
 function createTextureMeshes(textures, boardData, pcbThickness) {
   const meshes = [];
   if (!textures || !boardData || pcbThickness === null) return meshes;
   const createTexturePlane = (texture, yOffset, isBottomLayer, keySuffix) => {
     if (!texture) return null;
-    const planeGeom = new THREE12.PlaneGeometry(boardData.width, boardData.height);
-    const material = new THREE12.MeshBasicMaterial({
+    const planeGeom = new THREE7.PlaneGeometry(boardData.width, boardData.height);
+    const material = new THREE7.MeshBasicMaterial({
       map: texture,
       transparent: true,
-      side: THREE12.DoubleSide,
+      side: THREE7.DoubleSide,
       depthWrite: false
       // Important for layers to avoid z-fighting issues with board itself
     });
-    const mesh = new THREE12.Mesh(planeGeom, material);
+    const mesh = new THREE7.Mesh(planeGeom, material);
     mesh.position.set(boardData.center.x, boardData.center.y, yOffset);
     if (isBottomLayer) {
       mesh.rotation.set(Math.PI, 0, 0);
@@ -20081,40 +19312,11 @@ function createTextureMeshes(textures, boardData, pcbThickness) {
 
 // src/CadViewerManifold.tsx
 import { jsx as jsx11, jsxs as jsxs8 } from "react/jsx-runtime";
-var MANIFOLD_CDN_BASE_URL = "https://cdn.jsdelivr.net/npm/manifold-3d@3.1.1";
 var CadViewerManifold = ({
   circuitJson,
   autoRotateDisabled,
   clickToInteractEnabled
 }) => {
-  const [manifoldJSModule, setManifoldJSModule] = useState9(null);
-  const [manifoldLoadingError, setManifoldLoadingError] = useState9(null);
-  useEffect6(() => {
-    const loadManifoldWasmFromCDN = async () => {
-      try {
-        const wasmUrl = `${MANIFOLD_CDN_BASE_URL}/manifold.wasm`;
-        const manifoldConfig = {
-          locateFile: (path, scriptDirectory) => {
-            if (path === "manifold.wasm") {
-              return wasmUrl;
-            }
-            return scriptDirectory + path;
-          }
-        };
-        const loadedModule = await ManifoldModule(
-          manifoldConfig
-        );
-        loadedModule.setup();
-        setManifoldJSModule(loadedModule);
-      } catch (error) {
-        console.error("Failed to load Manifold from CDN:", error);
-        setManifoldLoadingError(
-          `Failed to load Manifold module: ${error instanceof Error ? error.message : "Unknown error"}`
-        );
-      }
-    };
-    loadManifoldWasmFromCDN();
-  }, []);
   const {
     geoms,
     textures,
@@ -20122,14 +19324,14 @@ var CadViewerManifold = ({
     error: builderError,
     isLoading: builderIsLoading,
     boardData
-  } = useManifoldBoardBuilder(manifoldJSModule, circuitJson);
+  } = useManifoldBoardBuilder(circuitJson);
   const geometryMeshes = useMemo8(() => createGeometryMeshes(geoms), [geoms]);
   const textureMeshes = useMemo8(
     () => createTextureMeshes(textures, boardData, pcbThickness),
     [textures, boardData, pcbThickness]
   );
   const cadComponents = useMemo8(
-    () => circuitJson ? su13(circuitJson).cad_component.list() : [],
+    () => circuitJson ? su6(circuitJson).cad_component.list() : [],
     [circuitJson]
   );
   const boardDimensions = useMemo8(() => {
@@ -20145,26 +19347,6 @@ var CadViewerManifold = ({
     const largestDim = Math.max(safeWidth, safeHeight, 5);
     return [largestDim * 0.75, largestDim * 0.75, largestDim * 0.75];
   }, [boardData]);
-  if (manifoldLoadingError) {
-    return /* @__PURE__ */ jsxs8(
-      "div",
-      {
-        style: {
-          color: "red",
-          padding: "1em",
-          border: "1px solid red",
-          margin: "1em"
-        },
-        children: [
-          "Error: ",
-          manifoldLoadingError
-        ]
-      }
-    );
-  }
-  if (!manifoldJSModule) {
-    return /* @__PURE__ */ jsx11("div", { style: { padding: "1em" }, children: "Loading Manifold module..." });
-  }
   if (builderError) {
     return /* @__PURE__ */ jsxs8(
       "div",
@@ -20182,7 +19364,7 @@ var CadViewerManifold = ({
       }
     );
   }
-  if (builderIsLoading || !boardData || !geoms || !textures) {
+  if (builderIsLoading && !geoms) {
     return /* @__PURE__ */ jsx11("div", { style: { padding: "1em" }, children: "Processing board geometry..." });
   }
   return /* @__PURE__ */ jsxs8(
@@ -20216,10 +19398,10 @@ var CadViewerManifold = ({
 var CadViewerManifold_default = CadViewerManifold;
 
 // src/hooks/useContextMenu.ts
-import { useState as useState10, useCallback as useCallback5, useRef as useRef7, useEffect as useEffect7 } from "react";
+import { useState as useState9, useCallback as useCallback5, useRef as useRef7, useEffect as useEffect6 } from "react";
 var useContextMenu = ({ containerRef }) => {
-  const [menuVisible, setMenuVisible] = useState10(false);
-  const [menuPos, setMenuPos] = useState10({
+  const [menuVisible, setMenuVisible] = useState9(false);
+  const [menuPos, setMenuPos] = useState9({
     x: 0,
     y: 0
   });
@@ -20288,7 +19470,7 @@ var useContextMenu = ({ containerRef }) => {
       setMenuVisible(false);
     }
   }, []);
-  useEffect7(() => {
+  useEffect6(() => {
     if (menuVisible) {
       document.addEventListener("mousedown", handleClickAway);
       return () => document.removeEventListener("mousedown", handleClickAway);
@@ -20320,7 +19502,7 @@ var useContextMenu = ({ containerRef }) => {
 // src/CadViewer.tsx
 import { jsx as jsx12, jsxs as jsxs9 } from "react/jsx-runtime";
 var CadViewer = (props) => {
-  const [engine, setEngine] = useState11("jscad");
+  const [engine, setEngine] = useState10("jscad");
   const containerRef = useRef8(null);
   const {
     menuVisible,
@@ -20333,13 +19515,13 @@ var CadViewer = (props) => {
     setEngine(newEngine);
     setMenuVisible(false);
   };
-  useEffect8(() => {
+  useEffect7(() => {
     const stored = window.localStorage.getItem("cadViewerEngine");
     if (stored === "jscad" || stored === "manifold") {
       setEngine(stored);
     }
   }, []);
-  useEffect8(() => {
+  useEffect7(() => {
     window.localStorage.setItem("cadViewerEngine", engine);
   }, [engine]);
   const viewerKey = props.circuitJson ? JSON.stringify(props.circuitJson) : void 0;
@@ -20438,12 +19620,12 @@ var CadViewer = (props) => {
 
 // src/convert-circuit-json-to-3d-svg.ts
 var import_debug = __toESM(require_browser(), 1);
-import { su as su14 } from "@tscircuit/soup-util";
-import * as THREE16 from "three";
+import { su as su7 } from "@tscircuit/soup-util";
+import * as THREE11 from "three";
 import { SVGRenderer } from "three/examples/jsm/renderers/SVGRenderer.js";
 
 // src/utils/create-geometry-from-polygons.ts
-import * as THREE13 from "three";
+import * as THREE8 from "three";
 import { BufferGeometry as BufferGeometry4, Float32BufferAttribute as Float32BufferAttribute4 } from "three";
 function createGeometryFromPolygons(polygons) {
   const geometry = new BufferGeometry4();
@@ -20457,12 +19639,12 @@ function createGeometryFromPolygons(polygons) {
         ...polygon2.vertices[i + 1]
         // Third vertex
       );
-      const v1 = new THREE13.Vector3(...polygon2.vertices[0]);
-      const v2 = new THREE13.Vector3(...polygon2.vertices[i]);
-      const v3 = new THREE13.Vector3(...polygon2.vertices[i + 1]);
-      const normal = new THREE13.Vector3().crossVectors(
-        new THREE13.Vector3().subVectors(v2, v1),
-        new THREE13.Vector3().subVectors(v3, v1)
+      const v1 = new THREE8.Vector3(...polygon2.vertices[0]);
+      const v2 = new THREE8.Vector3(...polygon2.vertices[i]);
+      const v3 = new THREE8.Vector3(...polygon2.vertices[i + 1]);
+      const normal = new THREE8.Vector3().crossVectors(
+        new THREE8.Vector3().subVectors(v2, v1),
+        new THREE8.Vector3().subVectors(v3, v1)
       ).normalize();
       normals.push(
         normal.x,
@@ -20488,22 +19670,22 @@ import { Footprinter3d as Footprinter3d2 } from "jscad-electronics";
 import { convertCSGToThreeGeom as convertCSGToThreeGeom2 } from "jscad-fiber/three";
 import { createJSCADRenderer as createJSCADRenderer2 } from "jscad-fiber";
 import { executeJscadOperations as executeJscadOperations2, jscadPlanner as jscadPlanner2 } from "jscad-planner";
-import * as THREE15 from "three";
+import * as THREE10 from "three";
 
 // src/utils/load-model.ts
-import * as THREE14 from "three";
+import * as THREE9 from "three";
 import { OBJLoader as OBJLoader3 } from "three/examples/jsm/loaders/OBJLoader.js";
 import { STLLoader as STLLoader2 } from "three/examples/jsm/loaders/STLLoader.js";
 async function load3DModel(url) {
   if (url.endsWith(".stl")) {
     const loader = new STLLoader2();
     const geometry = await loader.loadAsync(url);
-    const material = new THREE14.MeshStandardMaterial({
+    const material = new THREE9.MeshStandardMaterial({
       color: 8947848,
       metalness: 0.5,
       roughness: 0.5
     });
-    return new THREE14.Mesh(geometry, material);
+    return new THREE9.Mesh(geometry, material);
   }
   if (url.endsWith(".obj")) {
     const loader = new OBJLoader3();
@@ -20530,9 +19712,9 @@ async function renderComponent(component, scene) {
       }
       if (component.rotation) {
         model.rotation.set(
-          THREE15.MathUtils.degToRad(component.rotation.x ?? 0),
-          THREE15.MathUtils.degToRad(component.rotation.y ?? 0),
-          THREE15.MathUtils.degToRad(component.rotation.z ?? 0)
+          THREE10.MathUtils.degToRad(component.rotation.x ?? 0),
+          THREE10.MathUtils.degToRad(component.rotation.y ?? 0),
+          THREE10.MathUtils.degToRad(component.rotation.z ?? 0)
         );
       }
       scene.add(model);
@@ -20545,13 +19727,13 @@ async function renderComponent(component, scene) {
       component.model_jscad
     );
     const threeGeom = convertCSGToThreeGeom2(jscadObject);
-    const material2 = new THREE15.MeshStandardMaterial({
+    const material2 = new THREE10.MeshStandardMaterial({
       color: 8947848,
       metalness: 0.5,
       roughness: 0.5,
-      side: THREE15.DoubleSide
+      side: THREE10.DoubleSide
     });
-    const mesh2 = new THREE15.Mesh(threeGeom, material2);
+    const mesh2 = new THREE10.Mesh(threeGeom, material2);
     if (component.position) {
       mesh2.position.set(
         component.position.x ?? 0,
@@ -20561,9 +19743,9 @@ async function renderComponent(component, scene) {
     }
     if (component.rotation) {
       mesh2.rotation.set(
-        THREE15.MathUtils.degToRad(component.rotation.x ?? 0),
-        THREE15.MathUtils.degToRad(component.rotation.y ?? 0),
-        THREE15.MathUtils.degToRad(component.rotation.z ?? 0)
+        THREE10.MathUtils.degToRad(component.rotation.x ?? 0),
+        THREE10.MathUtils.degToRad(component.rotation.y ?? 0),
+        THREE10.MathUtils.degToRad(component.rotation.z ?? 0)
       );
     }
     scene.add(mesh2);
@@ -20576,13 +19758,13 @@ async function renderComponent(component, scene) {
     for (const operation of jscadOperations) {
       const jscadObject = executeJscadOperations2(import_modeling2.default, operation);
       const threeGeom = convertCSGToThreeGeom2(jscadObject);
-      const material2 = new THREE15.MeshStandardMaterial({
+      const material2 = new THREE10.MeshStandardMaterial({
         color: 4473924,
         metalness: 0.2,
         roughness: 0.8,
-        side: THREE15.DoubleSide
+        side: THREE10.DoubleSide
       });
-      const mesh2 = new THREE15.Mesh(threeGeom, material2);
+      const mesh2 = new THREE10.Mesh(threeGeom, material2);
       if (component.position) {
         mesh2.position.set(
           component.position.x ?? 0,
@@ -20592,22 +19774,22 @@ async function renderComponent(component, scene) {
       }
       if (component.rotation) {
         mesh2.rotation.set(
-          THREE15.MathUtils.degToRad(component.rotation.x ?? 0),
-          THREE15.MathUtils.degToRad(component.rotation.y ?? 0),
-          THREE15.MathUtils.degToRad(component.rotation.z ?? 0)
+          THREE10.MathUtils.degToRad(component.rotation.x ?? 0),
+          THREE10.MathUtils.degToRad(component.rotation.y ?? 0),
+          THREE10.MathUtils.degToRad(component.rotation.z ?? 0)
         );
       }
       scene.add(mesh2);
     }
     return;
   }
-  const geometry = new THREE15.BoxGeometry(0.5, 0.5, 0.5);
-  const material = new THREE15.MeshStandardMaterial({
+  const geometry = new THREE10.BoxGeometry(0.5, 0.5, 0.5);
+  const material = new THREE10.MeshStandardMaterial({
     color: 16711680,
     transparent: true,
     opacity: 0.25
   });
-  const mesh = new THREE15.Mesh(geometry, material);
+  const mesh = new THREE10.Mesh(geometry, material);
   if (component.position) {
     mesh.position.set(
       component.position.x ?? 0,
@@ -20628,11 +19810,11 @@ async function convertCircuitJsonTo3dSvg(circuitJson, options = {}) {
     padding = 20,
     zoom = 1.5
   } = options;
-  const scene = new THREE16.Scene();
+  const scene = new THREE11.Scene();
   const renderer = new SVGRenderer();
   renderer.setSize(width, height);
-  renderer.setClearColor(new THREE16.Color(backgroundColor), 1);
-  const camera = new THREE16.OrthographicCamera();
+  renderer.setClearColor(new THREE11.Color(backgroundColor), 1);
+  const camera = new THREE11.OrthographicCamera();
   const aspect = width / height;
   const frustumSize = 100;
   const halfFrustumSize = frustumSize / 2 / zoom;
@@ -20646,14 +19828,14 @@ async function convertCircuitJsonTo3dSvg(circuitJson, options = {}) {
   camera.position.set(position.x, position.y, position.z);
   camera.up.set(0, 1, 0);
   const lookAt = options.camera?.lookAt ?? { x: 0, y: 0, z: 0 };
-  camera.lookAt(new THREE16.Vector3(lookAt.x, lookAt.y, lookAt.z));
+  camera.lookAt(new THREE11.Vector3(lookAt.x, lookAt.y, lookAt.z));
   camera.updateProjectionMatrix();
-  const ambientLight = new THREE16.AmbientLight(16777215, Math.PI / 2);
+  const ambientLight = new THREE11.AmbientLight(16777215, Math.PI / 2);
   scene.add(ambientLight);
-  const pointLight = new THREE16.PointLight(16777215, Math.PI / 4);
+  const pointLight = new THREE11.PointLight(16777215, Math.PI / 4);
   pointLight.position.set(-10, -10, 10);
   scene.add(pointLight);
-  const components = su14(circuitJson).cad_component.list();
+  const components = su7(circuitJson).cad_component.list();
   for (const component of components) {
     await renderComponent(component, scene);
   }
@@ -20661,8 +19843,8 @@ async function convertCircuitJsonTo3dSvg(circuitJson, options = {}) {
   if (boardGeom) {
     for (const geom of boardGeom) {
       const geometry = createGeometryFromPolygons(geom.polygons);
-      const material = new THREE16.MeshStandardMaterial({
-        color: new THREE16.Color(
+      const material = new THREE11.MeshStandardMaterial({
+        color: new THREE11.Color(
           geom.color?.[0] ?? 0,
           geom.color?.[1] ?? 0,
           geom.color?.[2] ?? 0
@@ -20671,18 +19853,18 @@ async function convertCircuitJsonTo3dSvg(circuitJson, options = {}) {
         roughness: 0.8,
         opacity: 0.9,
         transparent: true,
-        side: THREE16.DoubleSide
+        side: THREE11.DoubleSide
       });
-      const mesh = new THREE16.Mesh(geometry, material);
+      const mesh = new THREE11.Mesh(geometry, material);
       scene.add(mesh);
     }
   }
-  const gridHelper = new THREE16.GridHelper(100, 100);
+  const gridHelper = new THREE11.GridHelper(100, 100);
   gridHelper.rotation.x = Math.PI / 2;
   scene.add(gridHelper);
-  const box = new THREE16.Box3().setFromObject(scene);
-  const center = box.getCenter(new THREE16.Vector3());
-  const size = box.getSize(new THREE16.Vector3());
+  const box = new THREE11.Box3().setFromObject(scene);
+  const center = box.getCenter(new THREE11.Vector3());
+  const size = box.getSize(new THREE11.Vector3());
   scene.position.sub(center);
   const maxDim = Math.max(size.x, size.y, size.z);
   if (maxDim > 0) {
@@ -20699,7 +19881,7 @@ async function convertCircuitJsonTo3dSvg(circuitJson, options = {}) {
 }
 
 // src/hooks/exporter/gltf.ts
-import { useEffect as useEffect9, useState as useState12, useMemo as useMemo9, useCallback as useCallback7 } from "react";
+import { useEffect as useEffect8, useState as useState11, useMemo as useMemo9, useCallback as useCallback7 } from "react";
 function useSaveGltfAs(options = {}) {
   const parse = useParser(options);
   const link = useMemo9(() => document.createElement("a"), []);
@@ -20712,7 +19894,7 @@ function useSaveGltfAs(options = {}) {
     link.dispatchEvent(new MouseEvent("click"));
     URL.revokeObjectURL(url);
   };
-  useEffect9(
+  useEffect8(
     () => () => {
       link.remove();
       instance = null;
@@ -20727,13 +19909,13 @@ function useSaveGltfAs(options = {}) {
 }
 function useExportGltfUrl(options = {}) {
   const parse = useParser(options);
-  const [url, setUrl] = useState12();
-  const [error, setError] = useState12();
+  const [url, setUrl] = useState11();
+  const [error, setError] = useState11();
   const ref = useCallback7(
     (instance) => parse(instance).then(setUrl).catch(setError),
     []
   );
-  useEffect9(() => () => URL.revokeObjectURL(url), [url]);
+  useEffect8(() => () => URL.revokeObjectURL(url), [url]);
   return [ref, url, error];
 }
 function useParser(options = {}) {