npm - @tscircuit/3d-viewer - Versions diffs - 0.0.476 → 0.0.478 - Mend

@tscircuit/3d-viewer 0.0.476 → 0.0.478

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/index.js CHANGED Viewed

@@ -805,13 +805,13 @@ var require_cross = __commonJS({
 var require_distance = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec3/distance.js"(exports, module) {
     "use strict";
-    var distance2 = (a, b) => {
+    var distance3 = (a, b) => {
       const x = b[0] - a[0];
       const y = b[1] - a[1];
       const z138 = b[2] - a[2];
       return Math.sqrt(x * x + y * y + z138 * z138);
     };
-    module.exports = distance2;
+    module.exports = distance3;
   }
 });
@@ -1933,12 +1933,12 @@ var require_cross2 = __commonJS({
 var require_distance2 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec2/distance.js"(exports, module) {
     "use strict";
-    var distance2 = (a, b) => {
+    var distance3 = (a, b) => {
       const x = b[0] - a[0];
       const y = b[1] - a[1];
       return Math.sqrt(x * x + y * y);
     };
-    module.exports = distance2;
+    module.exports = distance3;
   }
 });
@@ -2861,7 +2861,7 @@ var require_Vertex = __commonJS({
 var require_HalfEdge = __commonJS({
   "node_modules/@jscad/modeling/src/operations/hulls/quickhull/HalfEdge.js"(exports, module) {
     "use strict";
-    var distance2 = require_distance();
+    var distance3 = require_distance();
     var squaredDistance = require_squaredDistance();
     var HalfEdge = class {
       constructor(vertex, face) {
@@ -2879,7 +2879,7 @@ var require_HalfEdge = __commonJS({
       }
       length() {
         if (this.tail()) {
-          return distance2(
+          return distance3(
             this.tail().point,
             this.head().point
           );
@@ -3216,8 +3216,8 @@ var require_QuickHull = __commonJS({
             let nextVertex;
             for (let vertex = faceVertices; vertex; vertex = nextVertex) {
               nextVertex = vertex.next;
-              const distance2 = absorbingFace.distanceToPlane(vertex.point);
-              if (distance2 > this.tolerance) {
+              const distance3 = absorbingFace.distanceToPlane(vertex.point);
+              if (distance3 > this.tolerance) {
                 this.addVertexToFace(vertex, absorbingFace);
               } else {
                 this.unclaimed.add(vertex);
@@ -3304,9 +3304,9 @@ var require_QuickHull = __commonJS({
         let maxDistance = 0;
         let indexMax = 0;
         for (i = 0; i < 3; i += 1) {
-          const distance2 = max2[i].point[i] - min2[i].point[i];
-          if (distance2 > maxDistance) {
-            maxDistance = distance2;
+          const distance3 = max2[i].point[i] - min2[i].point[i];
+          if (distance3 > maxDistance) {
+            maxDistance = distance3;
             indexMax = i;
           }
         }
@@ -3316,13 +3316,13 @@ var require_QuickHull = __commonJS({
         for (i = 0; i < this.vertices.length; i += 1) {
           const vertex = this.vertices[i];
           if (vertex !== v0 && vertex !== v1) {
-            const distance2 = pointLineDistance(
+            const distance3 = pointLineDistance(
               vertex.point,
               v0.point,
               v1.point
             );
-            if (distance2 > maxDistance) {
-              maxDistance = distance2;
+            if (distance3 > maxDistance) {
+              maxDistance = distance3;
               v2 = vertex;
             }
           }
@@ -3333,9 +3333,9 @@ var require_QuickHull = __commonJS({
         for (i = 0; i < this.vertices.length; i += 1) {
           const vertex = this.vertices[i];
           if (vertex !== v0 && vertex !== v1 && vertex !== v2) {
-            const distance2 = Math.abs(dot(normal, vertex.point) - distPO);
-            if (distance2 > maxDistance) {
-              maxDistance = distance2;
+            const distance3 = Math.abs(dot(normal, vertex.point) - distPO);
+            if (distance3 > maxDistance) {
+              maxDistance = distance3;
               v3 = vertex;
             }
           }
@@ -3375,9 +3375,9 @@ var require_QuickHull = __commonJS({
             maxDistance = this.tolerance;
             let maxFace;
             for (j = 0; j < 4; j += 1) {
-              const distance2 = faces[j].distanceToPlane(vertex.point);
-              if (distance2 > maxDistance) {
-                maxDistance = distance2;
+              const distance3 = faces[j].distanceToPlane(vertex.point);
+              if (distance3 > maxDistance) {
+                maxDistance = distance3;
                 maxFace = faces[j];
               }
             }
@@ -3433,9 +3433,9 @@ var require_QuickHull = __commonJS({
           let maxDistance = 0;
           const eyeFace = this.claimed.first().face;
           for (vertex = eyeFace.outside; vertex && vertex.face === eyeFace; vertex = vertex.next) {
-            const distance2 = eyeFace.distanceToPlane(vertex.point);
-            if (distance2 > maxDistance) {
-              maxDistance = distance2;
+            const distance3 = eyeFace.distanceToPlane(vertex.point);
+            if (distance3 > maxDistance) {
+              maxDistance = distance3;
               eyeVertex = vertex;
             }
           }
@@ -6069,13 +6069,13 @@ var require_arcLengthToT = __commonJS({
         distance: 0,
         segments: 100
       };
-      const { distance: distance2, segments } = Object.assign({}, defaults, options);
+      const { distance: distance3, segments } = Object.assign({}, defaults, options);
       const arcLengths = lengths(segments, bezier);
       let startIndex = 0;
       let endIndex = segments;
       while (startIndex <= endIndex) {
         const middleIndex = Math.floor(startIndex + (endIndex - startIndex) / 2);
-        const diff = arcLengths[middleIndex] - distance2;
+        const diff = arcLengths[middleIndex] - distance3;
         if (diff < 0) {
           startIndex = middleIndex + 1;
         } else if (diff > 0) {
@@ -6086,13 +6086,13 @@ var require_arcLengthToT = __commonJS({
         }
       }
       const targetIndex = endIndex;
-      if (arcLengths[targetIndex] === distance2) {
+      if (arcLengths[targetIndex] === distance3) {
         return targetIndex / segments;
       }
       const lengthBefore = arcLengths[targetIndex];
       const lengthAfter = arcLengths[targetIndex + 1];
       const segmentLength = lengthAfter - lengthBefore;
-      const segmentFraction = (distance2 - lengthBefore) / segmentLength;
+      const segmentFraction = (distance3 - lengthBefore) / segmentLength;
       return (targetIndex + segmentFraction) / segments;
     };
     module.exports = arcLengthToT;
@@ -6342,9 +6342,9 @@ var require_distanceToPoint = __commonJS({
     "use strict";
     var vec2 = require_vec2();
     var distanceToPoint = (line2, point2) => {
-      let distance2 = vec2.dot(point2, line2);
-      distance2 = Math.abs(distance2 - line2[2]);
-      return distance2;
+      let distance3 = vec2.dot(point2, line2);
+      distance3 = Math.abs(distance3 - line2[2]);
+      return distance3;
     };
     module.exports = distanceToPoint;
   }
@@ -6368,10 +6368,10 @@ var require_fromPoints6 = __commonJS({
       const vector = vec2.subtract(vec2.create(), point2, point1);
       vec2.normal(vector, vector);
       vec2.normalize(vector, vector);
-      const distance2 = vec2.dot(point1, vector);
+      const distance3 = vec2.dot(point1, vector);
       out[0] = vector[0];
       out[1] = vector[1];
-      out[2] = distance2;
+      out[2] = distance3;
       return out;
     };
     module.exports = fromPoints;
@@ -6513,8 +6513,8 @@ var require_reverse3 = __commonJS({
     var fromValues = require_fromValues5();
     var reverse = (out, line2) => {
       const normal = vec2.negate(vec2.create(), line2);
-      const distance2 = -line2[2];
-      return copy(out, fromValues(normal[0], normal[1], distance2));
+      const distance3 = -line2[2];
+      return copy(out, fromValues(normal[0], normal[1], distance3));
     };
     module.exports = reverse;
   }
@@ -7862,7 +7862,7 @@ var require_polyhedron = __commonJS({
         colors: void 0,
         orientation: "outward"
       };
-      const { points, faces, colors: colors2, orientation } = Object.assign({}, defaults, options);
+      const { points, faces, colors: colors2, orientation: orientation2 } = Object.assign({}, defaults, options);
       if (!(Array.isArray(points) && Array.isArray(faces))) {
         throw new Error("points and faces must be arrays");
       }
@@ -7887,7 +7887,7 @@ var require_polyhedron = __commonJS({
         if (face.length < 3) throw new Error(`face ${i} must contain 3 or more indexes`);
         if (!isNumberArray(face, face.length)) throw new Error(`face ${i} must be an array of numbers`);
       });
-      if (orientation !== "outward") {
+      if (orientation2 !== "outward") {
         faces.forEach((face) => face.reverse());
       }
       const polygons = faces.map((face, findex) => {
@@ -8052,7 +8052,7 @@ var require_polygon = __commonJS({
         paths: [],
         orientation: "counterclockwise"
       };
-      const { points, paths, orientation } = Object.assign({}, defaults, options);
+      const { points, paths, orientation: orientation2 } = Object.assign({}, defaults, options);
       if (!(Array.isArray(points) && Array.isArray(paths))) throw new Error("points and paths must be arrays");
       let listofpolys = points;
       if (Array.isArray(points[0])) {
@@ -8082,7 +8082,7 @@ var require_polygon = __commonJS({
         sides2 = sides2.concat(geom2.toSides(geometry2));
       });
       let geometry = geom2.create(sides2);
-      if (orientation === "clockwise") {
+      if (orientation2 === "clockwise") {
         geometry = geom2.reverse(geometry);
       }
       return geometry;
@@ -8597,16 +8597,16 @@ var require_calculatePlane = __commonJS({
     var calculatePlane = (slice) => {
       const edges = slice.edges;
       if (edges.length < 3) throw new Error("slices must have 3 or more edges to calculate a plane");
-      const midpoint = edges.reduce((point2, edge) => vec3.add(vec3.create(), point2, edge[0]), vec3.create());
-      vec3.scale(midpoint, midpoint, 1 / edges.length);
+      const midpoint2 = edges.reduce((point2, edge) => vec3.add(vec3.create(), point2, edge[0]), vec3.create());
+      vec3.scale(midpoint2, midpoint2, 1 / edges.length);
       let farthestEdge;
-      let distance2 = 0;
+      let distance3 = 0;
       edges.forEach((edge) => {
         if (!vec3.equals(edge[0], edge[1])) {
-          const d = vec3.squaredDistance(midpoint, edge[0]);
-          if (d > distance2) {
+          const d = vec3.squaredDistance(midpoint2, edge[0]);
+          if (d > distance3) {
             farthestEdge = edge;
-            distance2 = d;
+            distance3 = d;
           }
         }
       });
@@ -8969,13 +8969,13 @@ var require_linkedPolygon = __commonJS({
       const o3 = Math.sign(area(p2, q2, p1));
       const o4 = Math.sign(area(p2, q2, q1));
       if (o1 !== o2 && o3 !== o4) return true;
-      if (o1 === 0 && onSegment(p1, p2, q1)) return true;
-      if (o2 === 0 && onSegment(p1, q2, q1)) return true;
-      if (o3 === 0 && onSegment(p2, p1, q2)) return true;
-      if (o4 === 0 && onSegment(p2, q1, q2)) return true;
+      if (o1 === 0 && onSegment2(p1, p2, q1)) return true;
+      if (o2 === 0 && onSegment2(p1, q2, q1)) return true;
+      if (o3 === 0 && onSegment2(p2, p1, q2)) return true;
+      if (o4 === 0 && onSegment2(p2, q1, q2)) return true;
       return false;
     };
-    var onSegment = (p, q, r) => q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+    var onSegment2 = (p, q, r) => q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
     var signedArea = (data, start, end, dim) => {
       let sum = 0;
       for (let i = start, j = end - dim; i < end; i += dim) {
@@ -9454,9 +9454,9 @@ var require_repair = __commonJS({
         let bestReplacement;
         missingOut.forEach((key2) => {
           const v2 = vertexMap.get(key2);
-          const distance2 = vec3.distance(v1, v2);
-          if (distance2 < bestDistance) {
-            bestDistance = distance2;
+          const distance3 = vec3.distance(v1, v2);
+          if (distance3 < bestDistance) {
+            bestDistance = distance3;
             bestReplacement = v2;
           }
         });
@@ -11802,7 +11802,7 @@ var require_offsetFromPoints = __commonJS({
       if (Math.abs(delta) < EPS) return points;
       let rotation2 = options.closed ? area(points) : 1;
       if (rotation2 === 0) rotation2 = 1;
-      const orientation = rotation2 > 0 && delta >= 0 || rotation2 < 0 && delta < 0;
+      const orientation2 = rotation2 > 0 && delta >= 0 || rotation2 < 0 && delta < 0;
       delta = Math.abs(delta);
       let previousSegment = null;
       let newPoints = [];
@@ -11813,7 +11813,7 @@ var require_offsetFromPoints = __commonJS({
         const j = (i + 1) % n;
         const p0 = points[i];
         const p1 = points[j];
-        orientation ? vec2.subtract(of, p0, p1) : vec2.subtract(of, p1, p0);
+        orientation2 ? vec2.subtract(of, p0, p1) : vec2.subtract(of, p1, p0);
         vec2.normal(of, of);
         vec2.normalize(of, of);
         vec2.scale(of, of, delta);
@@ -11877,11 +11877,11 @@ var require_offsetFromPoints = __commonJS({
         newCorners.forEach((corner) => {
           let rotation3 = vec2.angle(vec2.subtract(v0, corner.s1[0], corner.c));
           rotation3 -= vec2.angle(vec2.subtract(v0, corner.s0[1], corner.c));
-          if (orientation && rotation3 < 0) {
+          if (orientation2 && rotation3 < 0) {
             rotation3 = rotation3 + Math.PI;
             if (rotation3 < 0) rotation3 = rotation3 + Math.PI;
           }
-          if (!orientation && rotation3 > 0) {
+          if (!orientation2 && rotation3 > 0) {
             rotation3 = rotation3 - Math.PI;
             if (rotation3 > 0) rotation3 = rotation3 - Math.PI;
           }
@@ -12718,8 +12718,8 @@ var require_hullPoints2 = __commonJS({
       const points = [];
       uniquePoints.forEach((point2) => {
         const angle = fakeAtan2(point2[1] - min2[1], point2[0] - min2[0]);
-        const distSq = vec2.squaredDistance(point2, min2);
-        points.push({ point: point2, angle, distSq });
+        const distSq2 = vec2.squaredDistance(point2, min2);
+        points.push({ point: point2, angle, distSq: distSq2 });
       });
       points.sort((pt1, pt2) => pt1.angle !== pt2.angle ? pt1.angle - pt2.angle : pt1.distSq - pt2.distSq);
       const stack = [];
@@ -13361,11 +13361,11 @@ var require_triangulatePolygons = __commonJS({
       const nv = polygon3.vertices.length;
       if (nv > 3) {
         if (nv > 4) {
-          const midpoint = [0, 0, 0];
-          polygon3.vertices.forEach((vertice) => vec3.add(midpoint, midpoint, vertice));
-          vec3.snap(midpoint, vec3.divide(midpoint, midpoint, [nv, nv, nv]), epsilon);
+          const midpoint2 = [0, 0, 0];
+          polygon3.vertices.forEach((vertice) => vec3.add(midpoint2, midpoint2, vertice));
+          vec3.snap(midpoint2, vec3.divide(midpoint2, midpoint2, [nv, nv, nv]), epsilon);
           for (let i = 0; i < nv; i++) {
-            const poly = poly3.create([midpoint, polygon3.vertices[i], polygon3.vertices[(i + 1) % nv]]);
+            const poly = poly3.create([midpoint2, polygon3.vertices[i], polygon3.vertices[(i + 1) % nv]]);
             if (polygon3.color) poly.color = polygon3.color;
             triangles.push(poly);
           }
@@ -18225,12 +18225,12 @@ var bga_def = z510.object({
 });
 var bga = (raw_params) => {
   const parameters = bga_def.parse(raw_params);
-  let { num_pins, grid, p, w, h: h2, ball, pad: pad2, missing } = parameters;
+  let { num_pins, grid: grid2, p, w, h: h2, ball, pad: pad2, missing } = parameters;
   ball ??= 0.75 / 1.27 * p;
   pad2 ??= ball * 0.8;
   const pads = [];
   const missing_pin_nums = (missing ?? []).filter((a) => typeof a === "number");
-  const num_pins_missing = grid.x * grid.y - num_pins;
+  const num_pins_missing = grid2.x * grid2.y - num_pins;
   if (missing.length === 0 && num_pins_missing > 0) {
     if (Math.sqrt(num_pins_missing) % 1 === 0) {
       missing.push("center");
@@ -18240,11 +18240,11 @@ var bga = (raw_params) => {
   }
   if (missing?.includes("center")) {
     const square_size = Math.floor(Math.sqrt(num_pins_missing));
-    const inner_square_x = Math.floor((grid.x - square_size) / 2);
-    const inner_square_y = Math.floor((grid.y - square_size) / 2);
+    const inner_square_x = Math.floor((grid2.x - square_size) / 2);
+    const inner_square_y = Math.floor((grid2.y - square_size) / 2);
     for (let y = inner_square_y; y < inner_square_y + square_size; y++) {
       for (let x = inner_square_x; x < inner_square_x + square_size; x++) {
-        missing_pin_nums.push(y * grid.x + x + 1);
+        missing_pin_nums.push(y * grid2.x + x + 1);
       }
     }
   }
@@ -18253,30 +18253,30 @@ var bga = (raw_params) => {
   }
   const missing_pin_nums_set = new Set(missing_pin_nums);
   let missing_pins_passed = 0;
-  for (let y = 0; y < grid.y; y++) {
-    for (let x = 0; x < grid.x; x++) {
-      const pad_x = (x - (grid.x - 1) / 2) * p;
-      const pad_y = (y - (grid.y - 1) / 2) * p;
+  for (let y = 0; y < grid2.y; y++) {
+    for (let x = 0; x < grid2.x; x++) {
+      const pad_x = (x - (grid2.x - 1) / 2) * p;
+      const pad_y = (y - (grid2.y - 1) / 2) * p;
       let pin_x = x;
       let pin_y = y;
       switch (parameters.origin) {
         case "bl":
           pin_x = x;
-          pin_y = grid.y - 1 - y;
+          pin_y = grid2.y - 1 - y;
           break;
         case "br":
-          pin_x = grid.x - 1 - x;
-          pin_y = grid.y - 1 - y;
+          pin_x = grid2.x - 1 - x;
+          pin_y = grid2.y - 1 - y;
           break;
         case "tr":
-          pin_x = grid.x - 1 - x;
+          pin_x = grid2.x - 1 - x;
           pin_y = y;
           break;
         case "tl":
         default:
           break;
       }
-      let pin_num = pin_y * grid.x + pin_x + 1;
+      let pin_num = pin_y * grid2.x + pin_x + 1;
       if (missing_pin_nums_set.has(pin_num)) {
         missing_pins_passed++;
         continue;
@@ -18294,13 +18294,13 @@ var bga = (raw_params) => {
   }
   const silkscreenRefText = silkscreenRef(
     0,
-    grid.y * p / 2,
+    grid2.y * p / 2,
     0.2
   );
   const pin1MarkerSize = p / 6;
   let markerRoute;
-  const edgeX = grid.x * p / 2;
-  const edgeY = grid.y * p / 2;
+  const edgeX = grid2.x * p / 2;
+  const edgeY = grid2.y * p / 2;
   switch (parameters.origin) {
     case "bl":
       markerRoute = [
@@ -18614,7 +18614,7 @@ var quad = (raw_params) => {
     const {
       x,
       y,
-      o: orientation
+      o: orientation2
     } = getQuadCoords({
       pin_count: parameters.num_pins,
       pn: i + 1,
@@ -18626,7 +18626,7 @@ var quad = (raw_params) => {
     });
     let pw = parameters.pw;
     let pl = parameters.pl;
-    if (orientation === "vert") {
+    if (orientation2 === "vert") {
       ;
       [pw, pl] = [pl, pw];
     }
@@ -25622,7 +25622,7 @@ var QFN = ({
     const {
       x,
       y,
-      o: orientation
+      o: orientation2
     } = getQuadCoords2({
       pin_count: num_pins,
       pn: i + 1,
@@ -25634,7 +25634,7 @@ var QFN = ({
     });
     let pw = padWidth;
     let pl = padLength;
-    if (orientation === "vert") {
+    if (orientation2 === "vert") {
       ;
       [pw, pl] = [pl, pw];
     }
@@ -29492,7 +29492,7 @@ import * as THREE15 from "three";
 // package.json
 var package_default = {
   name: "@tscircuit/3d-viewer",
-  version: "0.0.475",
+  version: "0.0.477",
   main: "./dist/index.js",
   module: "./dist/index.js",
   type: "module",
@@ -29521,6 +29521,7 @@ var package_default = {
   dependencies: {
     "@jscad/regl-renderer": "^2.6.12",
     "@jscad/stl-serializer": "^2.1.20",
+    "circuit-to-canvas": "^0.0.26",
     "react-hot-toast": "^2.6.0",
     three: "^0.165.0",
     "three-stdlib": "^2.36.0",
@@ -29652,12 +29653,12 @@ var CameraControllerProvider = ({ children, defaultTarget, initialCameraPosition
   );
   const baseDistance = useMemo8(() => {
     const [x, y, z138] = initialCameraPosition ?? [5, -5, 5];
-    const distance2 = Math.hypot(
+    const distance3 = Math.hypot(
       x - defaultTarget.x,
       y - defaultTarget.y,
       z138 - defaultTarget.z
     );
-    return distance2 > 0 ? distance2 : 5;
+    return distance3 > 0 ? distance3 : 5;
   }, [initialCameraPosition, defaultTarget]);
   const getPresetConfig = useCallback4(
     (preset) => {
@@ -29668,13 +29669,13 @@ var CameraControllerProvider = ({ children, defaultTarget, initialCameraPosition
       ];
       const camera = mainCameraRef.current;
       const controls = controlsRef.current;
-      let distance2 = baseDistance;
+      let distance3 = baseDistance;
       if (camera && controls) {
-        distance2 = camera.position.distanceTo(controls.target);
+        distance3 = camera.position.distanceTo(controls.target);
       }
       switch (preset) {
         case "Top Center Angled": {
-          const angledOffset = distance2 / Math.sqrt(2);
+          const angledOffset = distance3 / Math.sqrt(2);
           return {
             position: [
               defaultTarget.x,
@@ -29690,7 +29691,7 @@ var CameraControllerProvider = ({ children, defaultTarget, initialCameraPosition
             position: [
               defaultTarget.x,
               defaultTarget.y,
-              defaultTarget.z + distance2
+              defaultTarget.z + distance3
             ],
             target: targetVector,
             up: [0, 0, 1]
@@ -29698,9 +29699,9 @@ var CameraControllerProvider = ({ children, defaultTarget, initialCameraPosition
         case "Top Left Corner":
           return {
             position: [
-              defaultTarget.x - distance2 * 0.6,
-              defaultTarget.y - distance2 * 0.6,
-              defaultTarget.z + distance2 * 0.6
+              defaultTarget.x - distance3 * 0.6,
+              defaultTarget.y - distance3 * 0.6,
+              defaultTarget.z + distance3 * 0.6
             ],
             target: targetVector,
             up: [0, 0, 1]
@@ -29708,9 +29709,9 @@ var CameraControllerProvider = ({ children, defaultTarget, initialCameraPosition
         case "Top Right Corner":
           return {
             position: [
-              defaultTarget.x + distance2 * 0.6,
-              defaultTarget.y - distance2 * 0.6,
-              defaultTarget.z + distance2 * 0.6
+              defaultTarget.x + distance3 * 0.6,
+              defaultTarget.y - distance3 * 0.6,
+              defaultTarget.z + distance3 * 0.6
             ],
             target: targetVector,
             up: [0, 0, 1]
@@ -29718,7 +29719,7 @@ var CameraControllerProvider = ({ children, defaultTarget, initialCameraPosition
         case "Left Sideview":
           return {
             position: [
-              defaultTarget.x - distance2,
+              defaultTarget.x - distance3,
               defaultTarget.y,
               defaultTarget.z
             ],
@@ -29728,7 +29729,7 @@ var CameraControllerProvider = ({ children, defaultTarget, initialCameraPosition
         case "Right Sideview":
           return {
             position: [
-              defaultTarget.x + distance2,
+              defaultTarget.x + distance3,
               defaultTarget.y,
               defaultTarget.z
             ],
@@ -29739,7 +29740,7 @@ var CameraControllerProvider = ({ children, defaultTarget, initialCameraPosition
           return {
             position: [
               defaultTarget.x,
-              defaultTarget.y - distance2,
+              defaultTarget.y - distance3,
               defaultTarget.z
             ],
             target: targetVector,
@@ -30321,13 +30322,13 @@ import { useEffect as useEffect15, useRef as useRef7 } from "react";
 import * as THREE14 from "three";
 import { Text as TroikaText } from "troika-three-text";
 import { jsx as jsx12 } from "react/jsx-runtime";
-function computePointInFront(rotationVector, distance2) {
+function computePointInFront(rotationVector, distance3) {
   const quaternion = new THREE14.Quaternion().setFromEuler(
     new THREE14.Euler(rotationVector.x, rotationVector.y, rotationVector.z)
   );
   const forwardVector = new THREE14.Vector3(0, 0, 1);
   forwardVector.applyQuaternion(quaternion);
-  const result = forwardVector.multiplyScalar(distance2);
+  const result = forwardVector.multiplyScalar(distance3);
   return result;
 }
 var OrientationCubeCanvas = () => {
@@ -32607,6 +32608,58 @@ import { su as su9 } from "@tscircuit/circuit-json-util";
 // src/utils/soldermask-texture.ts
 import * as THREE18 from "three";
 import { su as su5 } from "@tscircuit/circuit-json-util";
+// node_modules/@tscircuit/math-utils/dist/chunk-5N7UJNVK.js
+var getBoundsFromPoints = (points) => {
+  if (points.length === 0) {
+    return null;
+  }
+  let minX = points[0].x;
+  let minY = points[0].y;
+  let maxX = points[0].x;
+  let maxY = points[0].y;
+  for (let i = 1; i < points.length; i++) {
+    const point2 = points[i];
+    if (point2.x < minX) minX = point2.x;
+    if (point2.y < minY) minY = point2.y;
+    if (point2.x > maxX) maxX = point2.x;
+    if (point2.y > maxY) maxY = point2.y;
+  }
+  return { minX, minY, maxX, maxY };
+};
+// src/utils/outline-bounds.ts
+function calculateOutlineBounds(boardData) {
+  if (boardData.outline && boardData.outline.length >= 3) {
+    const bounds2 = getBoundsFromPoints(boardData.outline);
+    return {
+      ...bounds2,
+      width: bounds2.maxX - bounds2.minX,
+      height: bounds2.maxY - bounds2.minY,
+      centerX: (bounds2.minX + bounds2.maxX) / 2,
+      centerY: (bounds2.minY + bounds2.maxY) / 2
+    };
+  }
+  const boardWidth = boardData.width ?? 0;
+  const boardHeight = boardData.height ?? 0;
+  const boardCenterX = boardData.center?.x ?? 0;
+  const boardCenterY = boardData.center?.y ?? 0;
+  const bounds = {
+    minX: boardCenterX - boardWidth / 2,
+    maxX: boardCenterX + boardWidth / 2,
+    minY: boardCenterY - boardHeight / 2,
+    maxY: boardCenterY + boardHeight / 2
+  };
+  return {
+    ...bounds,
+    width: boardWidth,
+    height: boardHeight,
+    centerX: boardCenterX,
+    centerY: boardCenterY
+  };
+}
+// src/utils/soldermask-texture.ts
 function createSoldermaskTextureForLayer({
   layer,
   circuitJson,
@@ -32614,9 +32667,14 @@ function createSoldermaskTextureForLayer({
   soldermaskColor,
   traceTextureResolution
 }) {
+  const boardOutlineBounds = calculateOutlineBounds(boardData);
   const canvas = document.createElement("canvas");
-  const canvasWidth = Math.floor(boardData.width * traceTextureResolution);
-  const canvasHeight = Math.floor(boardData.height * traceTextureResolution);
+  const canvasWidth = Math.floor(
+    boardOutlineBounds.width * traceTextureResolution
+  );
+  const canvasHeight = Math.floor(
+    boardOutlineBounds.height * traceTextureResolution
+  );
   canvas.width = canvasWidth;
   canvas.height = canvasHeight;
   const ctx = canvas.getContext("2d");
@@ -32625,8 +32683,8 @@ function createSoldermaskTextureForLayer({
     ctx.translate(0, canvasHeight);
     ctx.scale(1, -1);
   }
-  const canvasXFromPcb = (pcbX) => (pcbX - boardData.center.x + boardData.width / 2) * traceTextureResolution;
-  const canvasYFromPcb = (pcbY) => (-(pcbY - boardData.center.y) + boardData.height / 2) * traceTextureResolution;
+  const canvasXFromPcb = (pcbX) => (pcbX - boardOutlineBounds.minX) * traceTextureResolution;
+  const canvasYFromPcb = (pcbY) => (boardOutlineBounds.maxY - pcbY) * traceTextureResolution;
   ctx.fillStyle = soldermaskColor;
   if (boardData.outline && boardData.outline.length >= 3) {
     ctx.beginPath();
@@ -33409,9 +33467,14 @@ function createSilkscreenTextureForLayer({
   if (textsOnLayer.length === 0 && pathsOnLayer.length === 0 && linesOnLayer.length === 0 && rectsOnLayer.length === 0 && circlesOnLayer.length === 0 && fabricationNoteRectsOnLayer.length === 0 && noteLinesOnLayer.length === 0) {
     return null;
   }
+  const boardOutlineBounds = calculateOutlineBounds(boardData);
   const canvas = document.createElement("canvas");
-  const canvasWidth = Math.floor(boardData.width * traceTextureResolution);
-  const canvasHeight = Math.floor(boardData.height * traceTextureResolution);
+  const canvasWidth = Math.floor(
+    boardOutlineBounds.width * traceTextureResolution
+  );
+  const canvasHeight = Math.floor(
+    boardOutlineBounds.height * traceTextureResolution
+  );
   canvas.width = canvasWidth;
   canvas.height = canvasHeight;
   const ctx = canvas.getContext("2d");
@@ -33422,8 +33485,8 @@ function createSilkscreenTextureForLayer({
   }
   ctx.strokeStyle = silkscreenColor;
   ctx.fillStyle = silkscreenColor;
-  const canvasXFromPcb = (pcbX) => (pcbX - boardData.center.x + boardData.width / 2) * traceTextureResolution;
-  const canvasYFromPcb = (pcbY) => (-(pcbY - boardData.center.y) + boardData.height / 2) * traceTextureResolution;
+  const canvasXFromPcb = (pcbX) => (pcbX - boardOutlineBounds.minX) * traceTextureResolution;
+  const canvasYFromPcb = (pcbY) => (boardOutlineBounds.maxY - pcbY) * traceTextureResolution;
   linesOnLayer.forEach((lineEl) => {
     const startXmm = parseDimensionToMm(lineEl.x1) ?? 0;
     const startYmm = parseDimensionToMm(lineEl.y1) ?? 0;
@@ -33789,9 +33852,14 @@ function createTraceTextureForLayer({
     (t) => t.route.some((p) => isWireRoutePoint(p) && p.layer === layer)
   );
   if (tracesOnLayer.length === 0) return null;
+  const boardOutlineBounds = calculateOutlineBounds(boardData);
   const canvas = document.createElement("canvas");
-  const canvasWidth = Math.floor(boardData.width * traceTextureResolution);
-  const canvasHeight = Math.floor(boardData.height * traceTextureResolution);
+  const canvasWidth = Math.floor(
+    boardOutlineBounds.width * traceTextureResolution
+  );
+  const canvasHeight = Math.floor(
+    boardOutlineBounds.height * traceTextureResolution
+  );
   canvas.width = canvasWidth;
   canvas.height = canvasHeight;
   const ctx = canvas.getContext("2d");
@@ -33817,8 +33885,8 @@ function createTraceTextureForLayer({
       const pcbY = point2.y;
       currentLineWidth = point2.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;
+      const canvasX = (pcbX - boardOutlineBounds.minX) * traceTextureResolution;
+      const canvasY = (boardOutlineBounds.maxY - pcbY) * traceTextureResolution;
       if (firstPoint) {
         ctx.moveTo(canvasX, canvasY);
         firstPoint = false;
@@ -33833,8 +33901,8 @@ function createTraceTextureForLayer({
   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 canvasX = (via.x - boardOutlineBounds.minX) * traceTextureResolution;
+    const canvasY = (boardOutlineBounds.maxY - via.y) * traceTextureResolution;
     const canvasRadius = via.outer_diameter / 2 * traceTextureResolution;
     ctx.beginPath();
     ctx.arc(canvasX, canvasY, canvasRadius, 0, 2 * Math.PI, false);
@@ -33842,8 +33910,8 @@ function createTraceTextureForLayer({
   });
   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 canvasX = (ph.x - boardOutlineBounds.minX) * traceTextureResolution;
+      const canvasY = (boardOutlineBounds.maxY - ph.y) * traceTextureResolution;
       const canvasRadius = ph.outer_diameter / 2 * traceTextureResolution;
       ctx.beginPath();
       ctx.arc(canvasX, canvasY, canvasRadius, 0, 2 * Math.PI, false);
@@ -34038,9 +34106,14 @@ function createCopperTextTextureForLayer({
   if (textsOnLayer.length === 0) {
     return null;
   }
+  const boardOutlineBounds = calculateOutlineBounds(boardData);
   const canvas = document.createElement("canvas");
-  const canvasWidth = Math.floor(boardData.width * traceTextureResolution);
-  const canvasHeight = Math.floor(boardData.height * traceTextureResolution);
+  const canvasWidth = Math.floor(
+    boardOutlineBounds.width * traceTextureResolution
+  );
+  const canvasHeight = Math.floor(
+    boardOutlineBounds.height * traceTextureResolution
+  );
   canvas.width = canvasWidth;
   canvas.height = canvasHeight;
   const ctx = canvas.getContext("2d");
@@ -34051,8 +34124,8 @@ function createCopperTextTextureForLayer({
   }
   ctx.strokeStyle = copperColor;
   ctx.fillStyle = copperColor;
-  const canvasXFromPcb = (pcbX) => (pcbX - boardData.center.x + boardData.width / 2) * traceTextureResolution;
-  const canvasYFromPcb = (pcbY) => (-(pcbY - boardData.center.y) + boardData.height / 2) * traceTextureResolution;
+  const canvasXFromPcb = (pcbX) => (pcbX - boardOutlineBounds.minX) * traceTextureResolution;
+  const canvasYFromPcb = (pcbY) => (boardOutlineBounds.maxY - pcbY) * traceTextureResolution;
   textsOnLayer.forEach((textS) => {
     const fontSize = typeof textS.font_size === "number" ? textS.font_size : 0.2;
     const textStrokeWidth = Math.max(0.02, fontSize * 0.08) * traceTextureResolution;
@@ -34285,11 +34358,12 @@ function JscadBoardTextures({
   useEffect22(() => {
     if (!rootObject || !boardData || !textures) return;
     const meshes = [];
-    const createTexturePlane = (texture, zOffset, isBottomLayer, name, usePolygonOffset = false, depthWrite = false) => {
+    const createTexturePlane2 = (texture, zOffset, isBottomLayer, name, usePolygonOffset = false, depthWrite = false) => {
       if (!texture) return null;
+      const boardOutlineBounds = calculateOutlineBounds(boardData);
       const planeGeom = new THREE23.PlaneGeometry(
-        boardData.width,
-        boardData.height
+        boardOutlineBounds.width,
+        boardOutlineBounds.height
       );
       const material = new THREE23.MeshBasicMaterial({
         map: texture,
@@ -34301,7 +34375,11 @@ function JscadBoardTextures({
         polygonOffsetUnits: usePolygonOffset ? -1 : 0
       });
       const mesh = new THREE23.Mesh(planeGeom, material);
-      mesh.position.set(boardData.center.x, boardData.center.y, zOffset);
+      mesh.position.set(
+        boardOutlineBounds.centerX,
+        boardOutlineBounds.centerY,
+        zOffset
+      );
       if (isBottomLayer) {
         mesh.rotation.set(Math.PI, 0, 0);
       }
@@ -34310,7 +34388,7 @@ function JscadBoardTextures({
     };
     const SURFACE_OFFSET = 1e-3;
     if (visibility.topMask) {
-      const topSoldermaskMesh = createTexturePlane(
+      const topSoldermaskMesh = createTexturePlane2(
         textures.topSoldermask,
         pcbThickness / 2 + SURFACE_OFFSET,
         false,
@@ -34323,7 +34401,7 @@ function JscadBoardTextures({
       }
     }
     if (visibility.bottomMask) {
-      const bottomSoldermaskMesh = createTexturePlane(
+      const bottomSoldermaskMesh = createTexturePlane2(
         textures.bottomSoldermask,
         -pcbThickness / 2 - SURFACE_OFFSET,
         true,
@@ -34336,7 +34414,7 @@ function JscadBoardTextures({
       }
     }
     if (visibility.topCopper && visibility.topMask) {
-      const topTraceWithMaskMesh = createTexturePlane(
+      const topTraceWithMaskMesh = createTexturePlane2(
         textures.topTraceWithMask,
         pcbThickness / 2 + BOARD_SURFACE_OFFSET.traces + 4e-3,
         false,
@@ -34348,7 +34426,7 @@ function JscadBoardTextures({
       }
     }
     if (visibility.bottomCopper && visibility.bottomMask) {
-      const bottomTraceWithMaskMesh = createTexturePlane(
+      const bottomTraceWithMaskMesh = createTexturePlane2(
         textures.bottomTraceWithMask,
         -pcbThickness / 2 - BOARD_SURFACE_OFFSET.traces - 5e-3,
         true,
@@ -34360,7 +34438,7 @@ function JscadBoardTextures({
       }
     }
     if (visibility.topSilkscreen) {
-      const topSilkscreenMesh = createTexturePlane(
+      const topSilkscreenMesh = createTexturePlane2(
         textures.topSilkscreen,
         pcbThickness / 2 + SURFACE_OFFSET + 2e-3,
         false,
@@ -34372,7 +34450,7 @@ function JscadBoardTextures({
       }
     }
     if (visibility.bottomSilkscreen) {
-      const bottomSilkscreenMesh = createTexturePlane(
+      const bottomSilkscreenMesh = createTexturePlane2(
         textures.bottomSilkscreen,
         -pcbThickness / 2 - SURFACE_OFFSET - 2e-3,
         true,
@@ -34384,7 +34462,7 @@ function JscadBoardTextures({
       }
     }
     if (visibility.topCopper) {
-      const topCopperTextMesh = createTexturePlane(
+      const topCopperTextMesh = createTexturePlane2(
         textures.topCopperText,
         pcbThickness / 2 + BOARD_SURFACE_OFFSET.copper,
         false,
@@ -34396,7 +34474,7 @@ function JscadBoardTextures({
       }
     }
     if (visibility.bottomCopper) {
-      const bottomCopperTextMesh = createTexturePlane(
+      const bottomCopperTextMesh = createTexturePlane2(
         textures.bottomCopperText,
         -pcbThickness / 2 - BOARD_SURFACE_OFFSET.copper,
         true,
@@ -34408,7 +34486,7 @@ function JscadBoardTextures({
       }
     }
     if (visibility.boardBody) {
-      const topPanelOutlinesMesh = createTexturePlane(
+      const topPanelOutlinesMesh = createTexturePlane2(
         textures.topPanelOutlines,
         pcbThickness / 2 + SURFACE_OFFSET + 3e-3,
         // Above silkscreen
@@ -34421,7 +34499,7 @@ function JscadBoardTextures({
         meshes.push(topPanelOutlinesMesh);
         rootObject.add(topPanelOutlinesMesh);
       }
-      const bottomPanelOutlinesMesh = createTexturePlane(
+      const bottomPanelOutlinesMesh = createTexturePlane2(
         textures.bottomPanelOutlines,
         -pcbThickness / 2 - SURFACE_OFFSET - 3e-3,
         // Below bottom silkscreen
@@ -34673,7 +34751,7 @@ import { useEffect as useEffect24, useMemo as useMemo22, useState as useState15
 // src/hooks/useManifoldBoardBuilder.ts
 import { useState as useState14, useEffect as useEffect23, useMemo as useMemo21, useRef as useRef9 } from "react";
 import { su as su18 } from "@tscircuit/circuit-json-util";
-import * as THREE29 from "three";
+import * as THREE30 from "three";
 // src/utils/manifold/create-manifold-board.ts
 var arePointsClockwise3 = (points) => {
@@ -34733,202 +34811,6 @@ function createManifoldBoard(Manifold, CrossSection, boardData, pcbThickness, ma
   return { boardOp, outlineCrossSection };
 }
-// src/utils/manifold/process-copper-pours.ts
-import * as THREE25 from "three";
-// src/utils/manifold-mesh-to-three-geometry.ts
-import * as THREE24 from "three";
-function manifoldMeshToThreeGeometry(manifoldMesh) {
-  const geometry = new THREE24.BufferGeometry();
-  geometry.setAttribute(
-    "position",
-    new THREE24.Float32BufferAttribute(manifoldMesh.vertProperties, 3)
-  );
-  geometry.setIndex(new THREE24.Uint32BufferAttribute(manifoldMesh.triVerts, 1));
-  if (manifoldMesh.runIndex && manifoldMesh.runIndex.length > 1 && manifoldMesh.runOriginalID) {
-    for (let i = 0; i < manifoldMesh.runIndex.length - 1; i++) {
-      const start = manifoldMesh.runIndex[i];
-      const count3 = manifoldMesh.runIndex[i + 1] - start;
-      geometry.addGroup(start, count3, 0);
-    }
-  } else {
-    geometry.addGroup(0, manifoldMesh.triVerts.length, 0);
-  }
-  return geometry;
-}
-// src/utils/manifold/process-copper-pours.ts
-var arePointsClockwise4 = (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 segmentToPoints2(p1, p2, bulge, arcSegments) {
-  if (!bulge || Math.abs(bulge) < 1e-9) {
-    return [];
-  }
-  const theta = 4 * Math.atan(bulge);
-  const dx = p2[0] - p1[0];
-  const dy = p2[1] - p1[1];
-  const dist = Math.sqrt(dx * dx + dy * dy);
-  if (dist < 1e-9) return [];
-  const radius = Math.abs(dist / (2 * Math.sin(theta / 2)));
-  const m = Math.sqrt(Math.max(0, radius * radius - dist / 2 * (dist / 2)));
-  const midPoint = [(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2];
-  const ux = dx / dist;
-  const uy = dy / dist;
-  const nx = -uy;
-  const ny = ux;
-  const centerX = midPoint[0] + nx * m * Math.sign(bulge);
-  const centerY = midPoint[1] + ny * m * Math.sign(bulge);
-  const startAngle = Math.atan2(p1[1] - centerY, p1[0] - centerX);
-  const points = [];
-  const numSteps = Math.max(
-    2,
-    Math.ceil(arcSegments * Math.abs(theta) / (Math.PI * 2) * 4)
-  );
-  const angleStep = theta / numSteps;
-  for (let i = 1; i < numSteps; i++) {
-    const angle = startAngle + angleStep * i;
-    points.push([
-      centerX + radius * Math.cos(angle),
-      centerY + radius * Math.sin(angle)
-    ]);
-  }
-  return points;
-}
-function ringToPoints2(ring2, arcSegments) {
-  const allPoints = [];
-  const vertices = ring2.vertices;
-  for (let i = 0; i < vertices.length; i++) {
-    const p1 = vertices[i];
-    const p2 = vertices[(i + 1) % vertices.length];
-    allPoints.push([p1.x, p1.y]);
-    if (p1.bulge) {
-      const arcPoints = segmentToPoints2(
-        [p1.x, p1.y],
-        [p2.x, p2.y],
-        p1.bulge,
-        arcSegments
-      );
-      allPoints.push(...arcPoints);
-    }
-  }
-  return allPoints;
-}
-function processCopperPoursForManifold(Manifold, CrossSection, circuitJson, pcbThickness, manifoldInstancesForCleanup, boardMaterial, holeUnion, boardClipVolume) {
-  const copperPourGeoms = [];
-  const copperPours = circuitJson.filter(
-    (e) => e.type === "pcb_copper_pour"
-  );
-  for (const pour of copperPours) {
-    const pourThickness = DEFAULT_SMT_PAD_THICKNESS;
-    const layerSign = pour.layer === "bottom" ? -1 : 1;
-    const zPos = layerSign * (pcbThickness / 2 + pourThickness / 2 + MANIFOLD_Z_OFFSET);
-    let pourOp;
-    if (pour.shape === "rect") {
-      pourOp = Manifold.cube([pour.width, pour.height, pourThickness], true);
-      manifoldInstancesForCleanup.push(pourOp);
-      if (pour.rotation) {
-        const rotatedOp = pourOp.rotate([0, 0, pour.rotation]);
-        manifoldInstancesForCleanup.push(rotatedOp);
-        pourOp = rotatedOp;
-      }
-      pourOp = pourOp.translate([pour.center.x, pour.center.y, zPos]);
-      manifoldInstancesForCleanup.push(pourOp);
-    } else if (pour.shape === "polygon") {
-      if (pour.points.length < 3) continue;
-      let pointsVec2 = pour.points.map((p) => [
-        p.x,
-        p.y
-      ]);
-      if (arePointsClockwise4(pointsVec2)) {
-        pointsVec2 = pointsVec2.reverse();
-      }
-      const crossSection = CrossSection.ofPolygons([pointsVec2]);
-      manifoldInstancesForCleanup.push(crossSection);
-      pourOp = Manifold.extrude(
-        crossSection,
-        pourThickness,
-        0,
-        // nDivisions
-        0,
-        // twistDegrees
-        [1, 1],
-        // scaleTop
-        true
-        // center extrusion
-      ).translate([0, 0, zPos]);
-      manifoldInstancesForCleanup.push(pourOp);
-    } else if (pour.shape === "brep") {
-      const brepShape = pour.brep_shape;
-      if (!brepShape || !brepShape.outer_ring) continue;
-      let outerRingPoints = ringToPoints2(
-        brepShape.outer_ring,
-        SMOOTH_CIRCLE_SEGMENTS
-      );
-      if (arePointsClockwise4(outerRingPoints)) {
-        outerRingPoints = outerRingPoints.reverse();
-      }
-      const polygons = [outerRingPoints];
-      if (brepShape.inner_rings) {
-        const innerRingsPoints = brepShape.inner_rings.map((ring2) => {
-          let points = ringToPoints2(ring2, SMOOTH_CIRCLE_SEGMENTS);
-          if (!arePointsClockwise4(points)) {
-            points = points.reverse();
-          }
-          return points;
-        });
-        polygons.push(...innerRingsPoints);
-      }
-      const crossSection = CrossSection.ofPolygons(polygons);
-      manifoldInstancesForCleanup.push(crossSection);
-      pourOp = Manifold.extrude(
-        crossSection,
-        pourThickness,
-        0,
-        // nDivisions
-        0,
-        // twistDegrees
-        [1, 1],
-        // scaleTop
-        true
-        // center extrusion
-      ).translate([0, 0, zPos]);
-      manifoldInstancesForCleanup.push(pourOp);
-    }
-    if (pourOp) {
-      if (holeUnion) {
-        const withHoles = pourOp.subtract(holeUnion);
-        manifoldInstancesForCleanup.push(withHoles);
-        pourOp = withHoles;
-      }
-      if (boardClipVolume) {
-        const clipped = Manifold.intersection([pourOp, boardClipVolume]);
-        manifoldInstancesForCleanup.push(clipped);
-        pourOp = clipped;
-      }
-      const covered = pour.covered_with_solder_mask !== false;
-      const pourColorArr = covered ? tracesMaterialColors[boardMaterial] ?? colors.fr4TracesWithoutMaskTan : colors.copper;
-      const pourColor = new THREE25.Color(...pourColorArr);
-      const threeGeom = manifoldMeshToThreeGeometry(pourOp.getMesh());
-      copperPourGeoms.push({
-        key: `coppour-${pour.pcb_copper_pour_id}`,
-        geometry: threeGeom,
-        color: pourColor
-      });
-    }
-  }
-  return { copperPourGeoms };
-}
 // src/utils/manifold/process-cutouts.ts
 import { su as su13 } from "@tscircuit/circuit-json-util";
@@ -35008,7 +34890,7 @@ function createPadManifoldOp({
 }
 // src/utils/manifold/process-cutouts.ts
-var arePointsClockwise5 = (points) => {
+var arePointsClockwise4 = (points) => {
   let area = 0;
   for (let i = 0; i < points.length; i++) {
     const j = (i + 1) % points.length;
@@ -35084,7 +34966,7 @@ function processCutoutsForManifold(Manifold, CrossSection, circuitJson, pcbThick
           p.x,
           p.y
         ]);
-        if (arePointsClockwise5(pointsVec2)) {
+        if (arePointsClockwise4(pointsVec2)) {
           pointsVec2 = pointsVec2.reverse();
         }
         const crossSection = CrossSection.ofPolygons([pointsVec2]);
@@ -35219,8 +35101,31 @@ function processNonPlatedHolesForManifold(Manifold, circuitJson, pcbThickness, m
 // src/utils/manifold/process-plated-holes.ts
 import { su as su15 } from "@tscircuit/circuit-json-util";
-import * as THREE26 from "three";
-var arePointsClockwise6 = (points) => {
+import * as THREE25 from "three";
+// src/utils/manifold-mesh-to-three-geometry.ts
+import * as THREE24 from "three";
+function manifoldMeshToThreeGeometry(manifoldMesh) {
+  const geometry = new THREE24.BufferGeometry();
+  geometry.setAttribute(
+    "position",
+    new THREE24.Float32BufferAttribute(manifoldMesh.vertProperties, 3)
+  );
+  geometry.setIndex(new THREE24.Uint32BufferAttribute(manifoldMesh.triVerts, 1));
+  if (manifoldMesh.runIndex && manifoldMesh.runIndex.length > 1 && manifoldMesh.runOriginalID) {
+    for (let i = 0; i < manifoldMesh.runIndex.length - 1; i++) {
+      const start = manifoldMesh.runIndex[i];
+      const count3 = manifoldMesh.runIndex[i + 1] - start;
+      geometry.addGroup(start, count3, 0);
+    }
+  } else {
+    geometry.addGroup(0, manifoldMesh.triVerts.length, 0);
+  }
+  return geometry;
+}
+// src/utils/manifold/process-plated-holes.ts
+var arePointsClockwise5 = (points) => {
   let area = 0;
   for (let i = 0; i < points.length; i++) {
     const j = (i + 1) % points.length;
@@ -35240,7 +35145,7 @@ var createEllipsePoints = (width10, height10, segments) => {
   }
   return points;
 };
-var COPPER_COLOR = new THREE26.Color(...colors.copper);
+var COPPER_COLOR = new THREE25.Color(...colors.copper);
 var PLATED_HOLE_LIP_HEIGHT = 0.05;
 function processPlatedHolesForManifold(Manifold, CrossSection, circuitJson, pcbThickness, manifoldInstancesForCleanup, boardClipVolume) {
   const platedHoleBoardDrills = [];
@@ -35267,7 +35172,7 @@ function processPlatedHolesForManifold(Manifold, CrossSection, circuitJson, pcbT
       point2.x,
       point2.y
     ]);
-    if (arePointsClockwise6(points)) {
+    if (arePointsClockwise5(points)) {
       points = points.reverse();
     }
     const crossSection = CrossSection.ofPolygons([points]);
@@ -35312,7 +35217,7 @@ function processPlatedHolesForManifold(Manifold, CrossSection, circuitJson, pcbT
       const height10 = Math.max(baseHeight + sizeDelta, M);
       if (holeShape === "oval") {
         let points = createEllipsePoints(width10, height10, SMOOTH_CIRCLE_SEGMENTS);
-        if (arePointsClockwise6(points)) {
+        if (arePointsClockwise5(points)) {
           points = points.reverse();
         }
         const crossSection = CrossSection.ofPolygons([points]);
@@ -35627,7 +35532,7 @@ function processPlatedHolesForManifold(Manifold, CrossSection, circuitJson, pcbT
         drillH,
         SMOOTH_CIRCLE_SEGMENTS
       );
-      if (arePointsClockwise6(boardDrillPoints)) {
+      if (arePointsClockwise5(boardDrillPoints)) {
         boardDrillPoints = boardDrillPoints.reverse();
       }
       const boardDrillCrossSection = CrossSection.ofPolygons([boardDrillPoints]);
@@ -35655,7 +35560,7 @@ function processPlatedHolesForManifold(Manifold, CrossSection, circuitJson, pcbT
         outerH,
         SMOOTH_CIRCLE_SEGMENTS
       );
-      if (arePointsClockwise6(outerPoints)) {
+      if (arePointsClockwise5(outerPoints)) {
         outerPoints = outerPoints.reverse();
       }
       const outerCrossSection = CrossSection.ofPolygons([outerPoints]);
@@ -35674,7 +35579,7 @@ function processPlatedHolesForManifold(Manifold, CrossSection, circuitJson, pcbT
         holeH,
         SMOOTH_CIRCLE_SEGMENTS
       );
-      if (arePointsClockwise6(innerPoints)) {
+      if (arePointsClockwise5(innerPoints)) {
         innerPoints = innerPoints.reverse();
       }
       const innerCrossSection = CrossSection.ofPolygons([innerPoints]);
@@ -35814,8 +35719,8 @@ function processPlatedHolesForManifold(Manifold, CrossSection, circuitJson, pcbT
 // src/utils/manifold/process-smt-pads.ts
 import { su as su16 } from "@tscircuit/circuit-json-util";
-import * as THREE27 from "three";
-var COPPER_COLOR2 = new THREE27.Color(...colors.copper);
+import * as THREE26 from "three";
+var COPPER_COLOR2 = new THREE26.Color(...colors.copper);
 function processSmtPadsForManifold(Manifold, circuitJson, pcbThickness, manifoldInstancesForCleanup, holeUnion, boardClipVolume) {
   const smtPadGeoms = [];
   const smtPads = su16(circuitJson).pcb_smtpad.list();
@@ -35854,7 +35759,7 @@ function processSmtPadsForManifold(Manifold, circuitJson, pcbThickness, manifold
 // src/utils/manifold/process-vias.ts
 import { su as su17 } from "@tscircuit/circuit-json-util";
-import * as THREE28 from "three";
+import * as THREE27 from "three";
 // src/utils/via-geoms.ts
 function createViaCopper2({
@@ -35907,7 +35812,7 @@ function createViaCopper2({
 }
 // src/utils/manifold/process-vias.ts
-var COPPER_COLOR3 = new THREE28.Color(...colors.copper);
+var COPPER_COLOR3 = new THREE27.Color(...colors.copper);
 function processViasForManifold(Manifold, circuitJson, pcbThickness, manifoldInstancesForCleanup, boardClipVolume) {
   const viaBoardDrills = [];
   const pcbVias = su17(circuitJson).pcb_via.list();
@@ -35958,6 +35863,397 @@ function processViasForManifold(Manifold, circuitJson, pcbThickness, manifoldIns
   return { viaBoardDrills, viaCopperGeoms };
 }
+// src/textures/create-copper-pour-texture-for-layer.ts
+import * as THREE28 from "three";
+import { CircuitToCanvasDrawer } from "circuit-to-canvas";
+function drawPolygon({
+  ctx,
+  points,
+  canvasXFromPcb,
+  canvasYFromPcb
+}) {
+  if (points.length < 3) return;
+  ctx.beginPath();
+  points.forEach((point2, index2) => {
+    const canvasX = canvasXFromPcb(point2[0]);
+    const canvasY = canvasYFromPcb(point2[1]);
+    if (index2 === 0) {
+      ctx.moveTo(canvasX, canvasY);
+    } else {
+      ctx.lineTo(canvasX, canvasY);
+    }
+  });
+  ctx.closePath();
+  ctx.fill();
+}
+function drawBrepShape({
+  ctx,
+  pour,
+  canvasXFromPcb,
+  canvasYFromPcb
+}) {
+  const brepShape = pour.brep_shape;
+  if (!brepShape || !brepShape.outer_ring) return;
+  const outerRingPoints = ringToPoints(brepShape.outer_ring, 32);
+  if (outerRingPoints.length >= 3) {
+    drawPolygon({
+      ctx,
+      points: outerRingPoints,
+      canvasXFromPcb,
+      canvasYFromPcb
+    });
+  }
+  if (brepShape.inner_rings && brepShape.inner_rings.length > 0) {
+    ctx.globalCompositeOperation = "destination-out";
+    for (const innerRing of brepShape.inner_rings) {
+      const innerRingPoints = ringToPoints(innerRing, 32);
+      if (innerRingPoints.length >= 3) {
+        drawPolygon({
+          ctx,
+          points: innerRingPoints,
+          canvasXFromPcb,
+          canvasYFromPcb
+        });
+      }
+    }
+    ctx.globalCompositeOperation = "source-over";
+  }
+}
+function createCopperPourTextureForLayer({
+  layer,
+  circuitJson,
+  boardData,
+  traceTextureResolution = TRACE_TEXTURE_RESOLUTION
+}) {
+  const copperPours = circuitJson.filter(
+    (e) => e.type === "pcb_copper_pour"
+  );
+  const poursOnLayer = copperPours.filter((p) => p.layer === layer);
+  if (poursOnLayer.length === 0) return null;
+  const boardOutlineBounds = calculateOutlineBounds(boardData);
+  const canvas = document.createElement("canvas");
+  const canvasWidth = Math.floor(
+    boardOutlineBounds.width * traceTextureResolution
+  );
+  const canvasHeight = Math.floor(
+    boardOutlineBounds.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);
+  }
+  const canvasXFromPcb = (pcbX) => (pcbX - boardOutlineBounds.minX) * traceTextureResolution;
+  const canvasYFromPcb = (pcbY) => (boardOutlineBounds.maxY - pcbY) * traceTextureResolution;
+  const rectAndPolygonPours = poursOnLayer.filter(
+    (pour) => pour.shape === "rect" || pour.shape === "polygon"
+  );
+  const brepPours = poursOnLayer.filter((pour) => pour.shape === "brep");
+  if (rectAndPolygonPours.length > 0) {
+    const drawer = new CircuitToCanvasDrawer(ctx);
+    drawer.setCameraBounds({
+      minX: boardOutlineBounds.minX,
+      maxX: boardOutlineBounds.maxX,
+      minY: boardOutlineBounds.minY,
+      maxY: boardOutlineBounds.maxY
+    });
+    const coveredPours = rectAndPolygonPours.filter(
+      (p) => p.covered_with_solder_mask !== false
+    );
+    const uncoveredPours = rectAndPolygonPours.filter(
+      (p) => p.covered_with_solder_mask === false
+    );
+    const coveredColor = `rgb(${colors.fr4TracesWithMaskGreen.map((c) => c * 255).join(",")})`;
+    const uncoveredColor = `rgb(${colors.copper.map((c) => c * 255).join(",")})`;
+    if (coveredPours.length > 0) {
+      drawer.configure({
+        colorOverrides: {
+          copper: {
+            top: coveredColor,
+            bottom: coveredColor,
+            inner1: coveredColor,
+            inner2: coveredColor,
+            inner3: coveredColor,
+            inner4: coveredColor,
+            inner5: coveredColor,
+            inner6: coveredColor
+          }
+        }
+      });
+      drawer.drawElements(coveredPours, { layers: [layer] });
+    }
+    if (uncoveredPours.length > 0) {
+      drawer.configure({
+        colorOverrides: {
+          copper: {
+            top: uncoveredColor,
+            bottom: uncoveredColor,
+            inner1: uncoveredColor,
+            inner2: uncoveredColor,
+            inner3: uncoveredColor,
+            inner4: uncoveredColor,
+            inner5: uncoveredColor,
+            inner6: uncoveredColor
+          }
+        }
+      });
+      drawer.drawElements(uncoveredPours, { layers: [layer] });
+    }
+  }
+  for (const pour of brepPours) {
+    const covered = pour.covered_with_solder_mask !== false;
+    const colorArr = covered ? colors.fr4TracesWithMaskGreen : colors.copper;
+    const copperColor = `rgb(${colorArr[0] * 255}, ${colorArr[1] * 255}, ${colorArr[2] * 255})`;
+    ctx.fillStyle = copperColor;
+    drawBrepShape({ ctx, pour, canvasXFromPcb, canvasYFromPcb });
+  }
+  const texture = new THREE28.CanvasTexture(canvas);
+  texture.generateMipmaps = true;
+  texture.minFilter = THREE28.LinearMipmapLinearFilter;
+  texture.magFilter = THREE28.LinearFilter;
+  texture.anisotropy = 16;
+  texture.needsUpdate = true;
+  return texture;
+}
+// src/textures/create-three-texture-meshes.ts
+import * as THREE29 from "three";
+function createTexturePlane(config, boardData) {
+  const {
+    texture,
+    yOffset,
+    isBottomLayer,
+    textureType,
+    usePolygonOffset = false,
+    renderOrder = 0
+  } = config;
+  if (!texture) return null;
+  const boardOutlineBounds = calculateOutlineBounds(boardData);
+  const planeGeom = new THREE29.PlaneGeometry(
+    boardOutlineBounds.width,
+    boardOutlineBounds.height
+  );
+  const material = new THREE29.MeshBasicMaterial({
+    map: texture,
+    transparent: true,
+    side: THREE29.DoubleSide,
+    depthWrite: textureType === "panel-outlines",
+    polygonOffset: usePolygonOffset,
+    polygonOffsetFactor: usePolygonOffset ? -4 : 0,
+    // Increased for better z-fighting prevention
+    polygonOffsetUnits: usePolygonOffset ? -4 : 0
+  });
+  const mesh = new THREE29.Mesh(planeGeom, material);
+  mesh.position.set(
+    boardOutlineBounds.centerX,
+    boardOutlineBounds.centerY,
+    yOffset
+  );
+  if (isBottomLayer) {
+    mesh.rotation.set(Math.PI, 0, 0);
+  }
+  mesh.name = `${isBottomLayer ? "bottom" : "top"}-${textureType}-texture-plane`;
+  mesh.renderOrder = renderOrder;
+  return mesh;
+}
+function createTextureMeshes(textures, boardData, pcbThickness) {
+  const meshes = [];
+  if (!textures || !boardData || pcbThickness === null) return meshes;
+  const topTraceMesh = createTexturePlane(
+    {
+      texture: textures.topTrace,
+      yOffset: pcbThickness / 2 + BOARD_SURFACE_OFFSET.traces,
+      // Use consistent copper offset
+      isBottomLayer: false,
+      textureType: "trace",
+      usePolygonOffset: false,
+      renderOrder: 2
+      // Render after soldermask
+    },
+    boardData
+  );
+  if (topTraceMesh) meshes.push(topTraceMesh);
+  const topTraceWithMaskMesh = createTexturePlane(
+    {
+      texture: textures.topTraceWithMask,
+      yOffset: pcbThickness / 2 + BOARD_SURFACE_OFFSET.traces,
+      isBottomLayer: false,
+      textureType: "trace-with-mask",
+      usePolygonOffset: false,
+      renderOrder: 2
+      // Render after soldermask
+    },
+    boardData
+  );
+  if (topTraceWithMaskMesh) meshes.push(topTraceWithMaskMesh);
+  const topSilkscreenMesh = createTexturePlane(
+    {
+      texture: textures.topSilkscreen,
+      yOffset: pcbThickness / 2 + 3e-3,
+      // Slightly above soldermask
+      isBottomLayer: false,
+      textureType: "silkscreen",
+      usePolygonOffset: false,
+      renderOrder: 3
+      // Render after traces
+    },
+    boardData
+  );
+  if (topSilkscreenMesh) meshes.push(topSilkscreenMesh);
+  const bottomTraceMesh = createTexturePlane(
+    {
+      texture: textures.bottomTrace,
+      yOffset: -pcbThickness / 2 - BOARD_SURFACE_OFFSET.traces,
+      // Use consistent copper offset
+      isBottomLayer: true,
+      textureType: "trace",
+      usePolygonOffset: false,
+      renderOrder: 2
+      // Render after soldermask
+    },
+    boardData
+  );
+  if (bottomTraceMesh) meshes.push(bottomTraceMesh);
+  const bottomTraceWithMaskMesh = createTexturePlane(
+    {
+      texture: textures.bottomTraceWithMask,
+      yOffset: -pcbThickness / 2 - BOARD_SURFACE_OFFSET.traces,
+      isBottomLayer: true,
+      textureType: "trace-with-mask",
+      usePolygonOffset: false,
+      renderOrder: 2
+      // Render after soldermask
+    },
+    boardData
+  );
+  if (bottomTraceWithMaskMesh) meshes.push(bottomTraceWithMaskMesh);
+  const bottomSilkscreenMesh = createTexturePlane(
+    {
+      texture: textures.bottomSilkscreen,
+      yOffset: -pcbThickness / 2 - 3e-3,
+      isBottomLayer: true,
+      textureType: "silkscreen",
+      usePolygonOffset: false,
+      renderOrder: 3
+      // Render after traces
+    },
+    boardData
+  );
+  if (bottomSilkscreenMesh) meshes.push(bottomSilkscreenMesh);
+  const topSoldermaskMesh = createTexturePlane(
+    {
+      texture: textures.topSoldermask,
+      yOffset: pcbThickness / 2 + 1e-3,
+      // Just above board surface
+      isBottomLayer: false,
+      textureType: "soldermask",
+      usePolygonOffset: true,
+      // Enable polygon offset
+      renderOrder: 1
+      // Render after board (renderOrder)
+    },
+    boardData
+  );
+  if (topSoldermaskMesh) meshes.push(topSoldermaskMesh);
+  const bottomSoldermaskMesh = createTexturePlane(
+    {
+      texture: textures.bottomSoldermask,
+      yOffset: -pcbThickness / 2 - 1e-3,
+      // Just below board surface (bottom side)
+      isBottomLayer: true,
+      textureType: "soldermask",
+      usePolygonOffset: true,
+      // Enable polygon offset
+      renderOrder: 1
+      // Render after board (renderOrder)
+    },
+    boardData
+  );
+  if (bottomSoldermaskMesh) meshes.push(bottomSoldermaskMesh);
+  const topCopperTextMesh = createTexturePlane(
+    {
+      texture: textures.topCopperText,
+      yOffset: pcbThickness / 2 + BOARD_SURFACE_OFFSET.copper,
+      isBottomLayer: false,
+      textureType: "copper-text",
+      usePolygonOffset: false,
+      renderOrder: 2
+      // Render after soldermask
+    },
+    boardData
+  );
+  if (topCopperTextMesh) meshes.push(topCopperTextMesh);
+  const bottomCopperTextMesh = createTexturePlane(
+    {
+      texture: textures.bottomCopperText,
+      yOffset: -pcbThickness / 2 - BOARD_SURFACE_OFFSET.copper,
+      isBottomLayer: true,
+      textureType: "copper-text",
+      usePolygonOffset: false,
+      renderOrder: 2
+      // Render after soldermask
+    },
+    boardData
+  );
+  if (bottomCopperTextMesh) meshes.push(bottomCopperTextMesh);
+  const topCopperMesh = createTexturePlane(
+    {
+      texture: textures.topCopper,
+      yOffset: pcbThickness / 2 + BOARD_SURFACE_OFFSET.copper,
+      isBottomLayer: false,
+      textureType: "copper",
+      usePolygonOffset: false,
+      renderOrder: 2
+      // Render after soldermask
+    },
+    boardData
+  );
+  if (topCopperMesh) meshes.push(topCopperMesh);
+  const bottomCopperMesh = createTexturePlane(
+    {
+      texture: textures.bottomCopper,
+      yOffset: -pcbThickness / 2 - BOARD_SURFACE_OFFSET.copper,
+      isBottomLayer: true,
+      textureType: "copper",
+      usePolygonOffset: false,
+      renderOrder: 2
+      // Render after soldermask
+    },
+    boardData
+  );
+  if (bottomCopperMesh) meshes.push(bottomCopperMesh);
+  const topPanelOutlinesMesh = createTexturePlane(
+    {
+      texture: textures.topPanelOutlines,
+      yOffset: pcbThickness / 2 + 4e-3,
+      // Above silkscreen
+      isBottomLayer: false,
+      textureType: "panel-outlines",
+      usePolygonOffset: false,
+      renderOrder: 4
+    },
+    boardData
+  );
+  if (topPanelOutlinesMesh) meshes.push(topPanelOutlinesMesh);
+  const bottomPanelOutlinesMesh = createTexturePlane(
+    {
+      texture: textures.bottomPanelOutlines,
+      yOffset: -pcbThickness / 2 - 4e-3,
+      // Below bottom silkscreen
+      isBottomLayer: true,
+      textureType: "panel-outlines",
+      usePolygonOffset: false,
+      renderOrder: 4
+    },
+    boardData
+  );
+  if (bottomPanelOutlinesMesh) meshes.push(bottomPanelOutlinesMesh);
+  return meshes;
+}
 // src/hooks/useManifoldBoardBuilder.ts
 var useManifoldBoardBuilder = (manifoldJSModule, circuitJson) => {
   const [geoms, setGeoms] = useState14(null);
@@ -36027,7 +36323,7 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson) => {
     manifoldInstancesForCleanup.current = [];
     let boardManifold = null;
     const currentGeoms = {};
-    const currentTextures = {};
+    const layerTextureMap = {};
     try {
       const currentPcbThickness = boardData.thickness || 1.6;
       setPcbThickness(currentPcbThickness);
@@ -36126,7 +36422,7 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson) => {
             {
               key: "plated-holes-union",
               geometry: cutPlatedGeom,
-              color: new THREE29.Color(
+              color: new THREE30.Color(
                 colors.copper[0],
                 colors.copper[1],
                 colors.copper[2]
@@ -36156,7 +36452,7 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson) => {
         const matColorArray = boardMaterialColors[boardData.material] ?? colors.fr4Tan;
         currentGeoms.board = {
           geometry: finalBoardGeom,
-          color: new THREE29.Color(
+          color: new THREE30.Color(
             matColorArray[0],
             matColorArray[1],
             matColorArray[2]
@@ -36174,28 +36470,17 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson) => {
         boardClipVolume
       );
       currentGeoms.smtPads = smtPadGeoms;
-      const { copperPourGeoms } = processCopperPoursForManifold(
-        Manifold,
-        CrossSection,
-        circuitJson,
-        currentPcbThickness,
-        manifoldInstancesForCleanup.current,
-        boardData.material,
-        holeUnion,
-        boardClipVolume
-      );
-      currentGeoms.copperPours = copperPourGeoms;
       setGeoms(currentGeoms);
       const traceColorWithoutMaskArr = colors.fr4TracesWithoutMaskTan;
       const traceColorWithoutMask = `rgb(${Math.round(traceColorWithoutMaskArr[0] * 255)}, ${Math.round(traceColorWithoutMaskArr[1] * 255)}, ${Math.round(traceColorWithoutMaskArr[2] * 255)})`;
-      currentTextures.topTrace = createTraceTextureForLayer({
+      layerTextureMap.topTrace = createTraceTextureForLayer({
         layer: "top",
         circuitJson,
         boardData,
         traceColor: traceColorWithoutMask,
         traceTextureResolution: TRACE_TEXTURE_RESOLUTION
       });
-      currentTextures.bottomTrace = createTraceTextureForLayer({
+      layerTextureMap.bottomTrace = createTraceTextureForLayer({
         layer: "bottom",
         circuitJson,
         boardData,
@@ -36204,14 +36489,14 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson) => {
       });
       const traceColorWithMaskArr = colors.fr4TracesWithMaskGreen;
       const traceColorWithMask = `rgb(${Math.round(traceColorWithMaskArr[0] * 255)}, ${Math.round(traceColorWithMaskArr[1] * 255)}, ${Math.round(traceColorWithMaskArr[2] * 255)})`;
-      currentTextures.topTraceWithMask = createTraceTextureForLayer({
+      layerTextureMap.topTraceWithMask = createTraceTextureForLayer({
         layer: "top",
         circuitJson,
         boardData,
         traceColor: traceColorWithMask,
         traceTextureResolution: TRACE_TEXTURE_RESOLUTION
       });
-      currentTextures.bottomTraceWithMask = createTraceTextureForLayer({
+      layerTextureMap.bottomTraceWithMask = createTraceTextureForLayer({
         layer: "bottom",
         circuitJson,
         boardData,
@@ -36219,14 +36504,14 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson) => {
         traceTextureResolution: TRACE_TEXTURE_RESOLUTION
       });
       const silkscreenColor = "rgb(255,255,255)";
-      currentTextures.topSilkscreen = createSilkscreenTextureForLayer({
+      layerTextureMap.topSilkscreen = createSilkscreenTextureForLayer({
         layer: "top",
         circuitJson,
         boardData,
         silkscreenColor,
         traceTextureResolution: TRACE_TEXTURE_RESOLUTION
       });
-      currentTextures.bottomSilkscreen = createSilkscreenTextureForLayer({
+      layerTextureMap.bottomSilkscreen = createSilkscreenTextureForLayer({
         layer: "bottom",
         circuitJson,
         boardData,
@@ -36235,14 +36520,14 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson) => {
       });
       const soldermaskColorArr = soldermaskColors[boardData.material] ?? colors.fr4SolderMaskGreen;
       const soldermaskColor = `rgb(${Math.round(soldermaskColorArr[0] * 255)}, ${Math.round(soldermaskColorArr[1] * 255)}, ${Math.round(soldermaskColorArr[2] * 255)})`;
-      currentTextures.topSoldermask = createSoldermaskTextureForLayer({
+      layerTextureMap.topSoldermask = createSoldermaskTextureForLayer({
         layer: "top",
         circuitJson,
         boardData,
         soldermaskColor,
         traceTextureResolution: TRACE_TEXTURE_RESOLUTION
       });
-      currentTextures.bottomSoldermask = createSoldermaskTextureForLayer({
+      layerTextureMap.bottomSoldermask = createSoldermaskTextureForLayer({
         layer: "bottom",
         circuitJson,
         boardData,
@@ -36251,33 +36536,45 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson) => {
       });
       const copperColorArr = colors.copper;
       const copperColor = `rgb(${Math.round(copperColorArr[0] * 255)}, ${Math.round(copperColorArr[1] * 255)}, ${Math.round(copperColorArr[2] * 255)})`;
-      currentTextures.topCopperText = createCopperTextTextureForLayer({
+      layerTextureMap.topCopperText = createCopperTextTextureForLayer({
         layer: "top",
         circuitJson,
         boardData,
         copperColor,
         traceTextureResolution: TRACE_TEXTURE_RESOLUTION
       });
-      currentTextures.bottomCopperText = createCopperTextTextureForLayer({
+      layerTextureMap.bottomCopperText = createCopperTextTextureForLayer({
         layer: "bottom",
         circuitJson,
         boardData,
         copperColor,
         traceTextureResolution: TRACE_TEXTURE_RESOLUTION
       });
-      currentTextures.topPanelOutlines = createPanelOutlineTextureForLayer({
+      layerTextureMap.topPanelOutlines = createPanelOutlineTextureForLayer({
         layer: "top",
         circuitJson,
         panelData: boardData,
         traceTextureResolution: TRACE_TEXTURE_RESOLUTION
       });
-      currentTextures.bottomPanelOutlines = createPanelOutlineTextureForLayer({
+      layerTextureMap.bottomPanelOutlines = createPanelOutlineTextureForLayer({
         layer: "bottom",
         circuitJson,
         panelData: boardData,
         traceTextureResolution: TRACE_TEXTURE_RESOLUTION
       });
-      setTextures(currentTextures);
+      layerTextureMap.topCopper = createCopperPourTextureForLayer({
+        layer: "top",
+        circuitJson,
+        boardData,
+        traceTextureResolution: TRACE_TEXTURE_RESOLUTION
+      });
+      layerTextureMap.bottomCopper = createCopperPourTextureForLayer({
+        layer: "bottom",
+        circuitJson,
+        boardData,
+        traceTextureResolution: TRACE_TEXTURE_RESOLUTION
+      });
+      setTextures(layerTextureMap);
     } catch (e) {
       console.error("Error processing geometry with Manifold in hook:", e);
       setError(
@@ -36305,11 +36602,11 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson) => {
 };
 // src/utils/manifold/create-three-geometry-meshes.ts
-import * as THREE31 from "three";
+import * as THREE32 from "three";
 // src/utils/create-board-material.ts
-import * as THREE30 from "three";
-var DEFAULT_SIDE = THREE30.DoubleSide;
+import * as THREE31 from "three";
+var DEFAULT_SIDE = THREE31.DoubleSide;
 var createBoardMaterial = ({
   material,
   color,
@@ -36317,7 +36614,7 @@ var createBoardMaterial = ({
   isFaux = false
 }) => {
   if (material === "fr4") {
-    return new THREE30.MeshPhysicalMaterial({
+    return new THREE31.MeshPhysicalMaterial({
       color,
       side,
       metalness: 0,
@@ -36331,7 +36628,7 @@ var createBoardMaterial = ({
       flatShading: true
     });
   }
-  return new THREE30.MeshStandardMaterial({
+  return new THREE31.MeshStandardMaterial({
     color,
     side,
     flatShading: true,
@@ -36347,12 +36644,12 @@ function createGeometryMeshes(geoms) {
   const meshes = [];
   if (!geoms) return meshes;
   if (geoms.board && geoms.board.geometry) {
-    const mesh = new THREE31.Mesh(
+    const mesh = new THREE32.Mesh(
       geoms.board.geometry,
       createBoardMaterial({
         material: geoms.board.material,
         color: geoms.board.color,
-        side: THREE31.DoubleSide,
+        side: THREE32.DoubleSide,
         isFaux: geoms.board.isFaux
       })
     );
@@ -36362,11 +36659,11 @@ function createGeometryMeshes(geoms) {
   const createMeshesFromArray = (geomArray) => {
     if (geomArray) {
       geomArray.forEach((comp) => {
-        const mesh = new THREE31.Mesh(
+        const mesh = new THREE32.Mesh(
           comp.geometry,
-          new THREE31.MeshStandardMaterial({
+          new THREE32.MeshStandardMaterial({
             color: comp.color,
-            side: THREE31.DoubleSide,
+            side: THREE32.DoubleSide,
             flatShading: true,
             // Consistent with board
             polygonOffset: true,
@@ -36382,164 +36679,6 @@ function createGeometryMeshes(geoms) {
   createMeshesFromArray(geoms.platedHoles);
   createMeshesFromArray(geoms.smtPads);
   createMeshesFromArray(geoms.vias);
-  createMeshesFromArray(geoms.copperPours);
-  return meshes;
-}
-// src/utils/manifold/create-three-texture-meshes.ts
-import * as THREE32 from "three";
-function createTextureMeshes(textures, boardData, pcbThickness) {
-  const meshes = [];
-  if (!textures || !boardData || pcbThickness === null) return meshes;
-  const createTexturePlane = (texture, yOffset, isBottomLayer, keySuffix, usePolygonOffset = false, renderOrder = 0) => {
-    if (!texture) return null;
-    const planeGeom = new THREE32.PlaneGeometry(boardData.width, boardData.height);
-    const material = new THREE32.MeshBasicMaterial({
-      map: texture,
-      transparent: true,
-      side: THREE32.DoubleSide,
-      depthWrite: keySuffix === "panel-outlines",
-      polygonOffset: usePolygonOffset,
-      polygonOffsetFactor: usePolygonOffset ? -4 : 0,
-      // Increased for better z-fighting prevention
-      polygonOffsetUnits: usePolygonOffset ? -4 : 0
-    });
-    const mesh = new THREE32.Mesh(planeGeom, material);
-    mesh.position.set(boardData.center.x, boardData.center.y, yOffset);
-    if (isBottomLayer) {
-      mesh.rotation.set(Math.PI, 0, 0);
-    }
-    mesh.name = `${isBottomLayer ? "bottom" : "top"}-${keySuffix}-texture-plane`;
-    mesh.renderOrder = renderOrder;
-    return mesh;
-  };
-  const topTraceMesh = createTexturePlane(
-    textures.topTrace,
-    pcbThickness / 2 + BOARD_SURFACE_OFFSET.traces,
-    // Use consistent copper offset
-    false,
-    "trace",
-    false,
-    2
-    // Render after soldermask
-  );
-  if (topTraceMesh) meshes.push(topTraceMesh);
-  const topTraceWithMaskMesh = createTexturePlane(
-    textures.topTraceWithMask,
-    pcbThickness / 2 + BOARD_SURFACE_OFFSET.traces,
-    false,
-    "trace-with-mask",
-    false,
-    2
-    // Render after soldermask
-  );
-  if (topTraceWithMaskMesh) meshes.push(topTraceWithMaskMesh);
-  const topSilkscreenMesh = createTexturePlane(
-    textures.topSilkscreen,
-    pcbThickness / 2 + 3e-3,
-    // Slightly above soldermask
-    false,
-    "silkscreen",
-    false,
-    3
-    // Render after traces
-  );
-  if (topSilkscreenMesh) meshes.push(topSilkscreenMesh);
-  const bottomTraceMesh = createTexturePlane(
-    textures.bottomTrace,
-    -pcbThickness / 2 - BOARD_SURFACE_OFFSET.traces,
-    // Use consistent copper offset
-    true,
-    "trace",
-    false,
-    2
-    // Render after soldermask
-  );
-  if (bottomTraceMesh) meshes.push(bottomTraceMesh);
-  const bottomTraceWithMaskMesh = createTexturePlane(
-    textures.bottomTraceWithMask,
-    -pcbThickness / 2 - BOARD_SURFACE_OFFSET.traces,
-    true,
-    "trace-with-mask",
-    false,
-    2
-    // Render after soldermask
-  );
-  if (bottomTraceWithMaskMesh) meshes.push(bottomTraceWithMaskMesh);
-  const bottomSilkscreenMesh = createTexturePlane(
-    textures.bottomSilkscreen,
-    -pcbThickness / 2 - 3e-3,
-    true,
-    "silkscreen",
-    false,
-    3
-    // Render after traces
-  );
-  if (bottomSilkscreenMesh) meshes.push(bottomSilkscreenMesh);
-  const topSoldermaskMesh = createTexturePlane(
-    textures.topSoldermask,
-    pcbThickness / 2 + 1e-3,
-    // Just above board surface
-    false,
-    "soldermask",
-    true,
-    // Enable polygon offset
-    1
-    // Render after board (renderOrder)
-  );
-  if (topSoldermaskMesh) meshes.push(topSoldermaskMesh);
-  const bottomSoldermaskMesh = createTexturePlane(
-    textures.bottomSoldermask,
-    -pcbThickness / 2 - 1e-3,
-    // Just below board surface (bottom side)
-    true,
-    "soldermask",
-    true,
-    // Enable polygon offset
-    1
-    // Render after board (renderOrder)
-  );
-  if (bottomSoldermaskMesh) meshes.push(bottomSoldermaskMesh);
-  const topCopperTextMesh = createTexturePlane(
-    textures.topCopperText,
-    pcbThickness / 2 + BOARD_SURFACE_OFFSET.copper,
-    false,
-    "copper-text",
-    false,
-    2
-    // Render after soldermask
-  );
-  if (topCopperTextMesh) meshes.push(topCopperTextMesh);
-  const bottomCopperTextMesh = createTexturePlane(
-    textures.bottomCopperText,
-    -pcbThickness / 2 - BOARD_SURFACE_OFFSET.copper,
-    true,
-    "copper-text",
-    false,
-    2
-    // Render after soldermask
-  );
-  if (bottomCopperTextMesh) meshes.push(bottomCopperTextMesh);
-  const topPanelOutlinesMesh = createTexturePlane(
-    textures.topPanelOutlines,
-    pcbThickness / 2 + 4e-3,
-    // Above silkscreen
-    false,
-    "panel-outlines",
-    false,
-    4
-  );
-  if (topPanelOutlinesMesh) meshes.push(topPanelOutlinesMesh);
-  const bottomPanelOutlinesMesh = createTexturePlane(
-    textures.bottomPanelOutlines,
-    -pcbThickness / 2 - 4e-3,
-    // Below bottom silkscreen
-    true,
-    "panel-outlines",
-    false,
-    4
-  );
-  if (bottomPanelOutlinesMesh) meshes.push(bottomPanelOutlinesMesh);
   return meshes;
 }
@@ -36567,8 +36706,6 @@ var BoardMeshes = ({
         }
       } else if (mesh.name.includes("plated_hole") || mesh.name.includes("via")) {
         shouldShow = visibility.topCopper || visibility.bottomCopper;
-      } else if (mesh.name.includes("copper_pour")) {
-        shouldShow = visibility.topCopper || visibility.bottomCopper;
       }
       if (shouldShow) {
         rootObject.add(mesh);
@@ -36596,6 +36733,10 @@ var BoardMeshes = ({
         shouldShow = visibility.topCopper;
       } else if (mesh.name.includes("bottom-copper-text")) {
         shouldShow = visibility.bottomCopper;
+      } else if (mesh.name.includes("top-copper")) {
+        shouldShow = visibility.topCopper;
+      } else if (mesh.name.includes("bottom-copper")) {
+        shouldShow = visibility.bottomCopper;
       } else if (mesh.name.includes("panel-outlines")) {
         shouldShow = visibility.boardBody;
       }
@@ -38108,7 +38249,7 @@ var oppositeAlignmentMap = {
   start: "end",
   end: "start"
 };
-function clamp(start, value, end) {
+function clamp2(start, value, end) {
   return max(start, min(value, end));
 }
 function evaluate(value, param) {
@@ -38461,7 +38602,7 @@ var arrow = (options) => ({
     const min$1 = minPadding;
     const max2 = clientSize - arrowDimensions[length2] - maxPadding;
     const center = clientSize / 2 - arrowDimensions[length2] / 2 + centerToReference;
-    const offset4 = clamp(min$1, center, max2);
+    const offset4 = clamp2(min$1, center, max2);
     const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset4 && rects.reference[length2] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length2] / 2 < 0;
     const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max2 : 0;
     return {
@@ -38758,14 +38899,14 @@ var shift = function(options) {
         const maxSide = mainAxis === "y" ? "bottom" : "right";
         const min2 = mainAxisCoord + overflow[minSide];
         const max2 = mainAxisCoord - overflow[maxSide];
-        mainAxisCoord = clamp(min2, mainAxisCoord, max2);
+        mainAxisCoord = clamp2(min2, mainAxisCoord, max2);
       }
       if (checkCrossAxis) {
         const minSide = crossAxis === "y" ? "top" : "left";
         const maxSide = crossAxis === "y" ? "bottom" : "right";
         const min2 = crossAxisCoord + overflow[minSide];
         const max2 = crossAxisCoord - overflow[maxSide];
-        crossAxisCoord = clamp(min2, crossAxisCoord, max2);
+        crossAxisCoord = clamp2(min2, crossAxisCoord, max2);
       }
       const limitedCoords = limiter.fn({
         ...state,
@@ -40470,7 +40611,7 @@ RovingFocusGroup.displayName = GROUP_NAME;
 var RovingFocusGroupImpl = React34.forwardRef((props, forwardedRef) => {
   const {
     __scopeRovingFocusGroup,
-    orientation,
+    orientation: orientation2,
     loop = false,
     dir,
     currentTabStopId: currentTabStopIdProp,
@@ -40505,7 +40646,7 @@ var RovingFocusGroupImpl = React34.forwardRef((props, forwardedRef) => {
     RovingFocusProvider,
     {
       scope: __scopeRovingFocusGroup,
-      orientation,
+      orientation: orientation2,
       dir: direction,
       loop,
       currentTabStopId,
@@ -40526,7 +40667,7 @@ var RovingFocusGroupImpl = React34.forwardRef((props, forwardedRef) => {
         Primitive.div,
         {
           tabIndex: isTabbingBackOut || focusableItemsCount === 0 ? -1 : 0,
-          "data-orientation": orientation,
+          "data-orientation": orientation2,
           ...groupProps,
           ref: composedRefs,
           style: { outline: "none", ...props.style },
@@ -40642,10 +40783,10 @@ function getDirectionAwareKey(key, dir) {
   if (dir !== "rtl") return key;
   return key === "ArrowLeft" ? "ArrowRight" : key === "ArrowRight" ? "ArrowLeft" : key;
 }
-function getFocusIntent(event, orientation, dir) {
+function getFocusIntent(event, orientation2, dir) {
   const key = getDirectionAwareKey(event.key, dir);
-  if (orientation === "vertical" && ["ArrowLeft", "ArrowRight"].includes(key)) return void 0;
-  if (orientation === "horizontal" && ["ArrowUp", "ArrowDown"].includes(key)) return void 0;
+  if (orientation2 === "vertical" && ["ArrowLeft", "ArrowRight"].includes(key)) return void 0;
+  if (orientation2 === "horizontal" && ["ArrowUp", "ArrowDown"].includes(key)) return void 0;
   return MAP_KEY_TO_FOCUS_INTENT[key];
 }
 function focusFirst2(candidates, preventScroll = false) {