@tscircuit/3d-viewer 0.0.477 → 0.0.478

package/dist/index.d.ts

@@ -44,6 +44,23 @@ declare function useExportGltfUrl(options?: Options): [
     error: ErrorEvent | undefined
 ];
 
+interface LayerTextures {
+    topTrace?: THREE.CanvasTexture | null;
+    bottomTrace?: THREE.CanvasTexture | null;
+    topTraceWithMask?: THREE.CanvasTexture | null;
+    bottomTraceWithMask?: THREE.CanvasTexture | null;
+    topSilkscreen?: THREE.CanvasTexture | null;
+    bottomSilkscreen?: THREE.CanvasTexture | null;
+    topSoldermask?: THREE.CanvasTexture | null;
+    bottomSoldermask?: THREE.CanvasTexture | null;
+    topCopperText?: THREE.CanvasTexture | null;
+    bottomCopperText?: THREE.CanvasTexture | null;
+    topPanelOutlines?: THREE.CanvasTexture | null;
+    bottomPanelOutlines?: THREE.CanvasTexture | null;
+    topCopper?: THREE.CanvasTexture | null;
+    bottomCopper?: THREE.CanvasTexture | null;
+}
+
 interface ManifoldGeoms {
     board?: {
         geometry: THREE.BufferGeometry;
@@ -66,29 +83,10 @@ interface ManifoldGeoms {
         geometry: THREE.BufferGeometry;
         color: THREE.Color;
     }>;
-    copperPours?: Array<{
-        key: string;
-        geometry: THREE.BufferGeometry;
-        color: THREE.Color;
-    }>;
-}
-interface ManifoldTextures {
-    topTrace?: THREE.CanvasTexture | null;
-    bottomTrace?: THREE.CanvasTexture | null;
-    topTraceWithMask?: THREE.CanvasTexture | null;
-    bottomTraceWithMask?: THREE.CanvasTexture | null;
-    topSilkscreen?: THREE.CanvasTexture | null;
-    bottomSilkscreen?: THREE.CanvasTexture | null;
-    topSoldermask?: THREE.CanvasTexture | null;
-    bottomSoldermask?: THREE.CanvasTexture | null;
-    topCopperText?: THREE.CanvasTexture | null;
-    bottomCopperText?: THREE.CanvasTexture | null;
-    topPanelOutlines?: THREE.CanvasTexture | null;
-    bottomPanelOutlines?: THREE.CanvasTexture | null;
 }
 interface UseManifoldBoardBuilderResult {
     geoms: ManifoldGeoms | null;
-    textures: ManifoldTextures | null;
+    textures: LayerTextures | null;
     pcbThickness: number | null;
     error: string | null;
     isLoading: boolean;
@@ -145,4 +143,4 @@ declare const useCameraSession: () => {
     handleControlsChange: () => void;
 };
 
-export { CadViewer, CameraAnimatorWithContext, CameraControllerProvider, type ManifoldGeoms, type ManifoldTextures, applyJsdomShim, convertCircuitJsonTo3dSvg, loadCameraFromSession, saveCameraToSession, useCameraController, useCameraSession, useExportGltfUrl, useManifoldBoardBuilder, useSaveGltfAs };
+export { CadViewer, CameraAnimatorWithContext, CameraControllerProvider, type ManifoldGeoms, applyJsdomShim, convertCircuitJsonTo3dSvg, loadCameraFromSession, saveCameraToSession, useCameraController, useCameraSession, useExportGltfUrl, useManifoldBoardBuilder, useSaveGltfAs };

package/dist/index.js

@@ -29492,7 +29492,7 @@ import * as THREE15 from "three";
 // package.json
 var package_default = {
   name: "@tscircuit/3d-viewer",
-  version: "0.0.476",
+  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",
@@ -34357,7 +34358,7 @@ 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(
@@ -34387,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,
@@ -34400,7 +34401,7 @@ function JscadBoardTextures({
       }
     }
     if (visibility.bottomMask) {
-      const bottomSoldermaskMesh = createTexturePlane(
+      const bottomSoldermaskMesh = createTexturePlane2(
         textures.bottomSoldermask,
         -pcbThickness / 2 - SURFACE_OFFSET,
         true,
@@ -34413,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,
@@ -34425,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,
@@ -34437,7 +34438,7 @@ function JscadBoardTextures({
       }
     }
     if (visibility.topSilkscreen) {
-      const topSilkscreenMesh = createTexturePlane(
+      const topSilkscreenMesh = createTexturePlane2(
         textures.topSilkscreen,
         pcbThickness / 2 + SURFACE_OFFSET + 2e-3,
         false,
@@ -34449,7 +34450,7 @@ function JscadBoardTextures({
       }
     }
     if (visibility.bottomSilkscreen) {
-      const bottomSilkscreenMesh = createTexturePlane(
+      const bottomSilkscreenMesh = createTexturePlane2(
         textures.bottomSilkscreen,
         -pcbThickness / 2 - SURFACE_OFFSET - 2e-3,
         true,
@@ -34461,7 +34462,7 @@ function JscadBoardTextures({
       }
     }
     if (visibility.topCopper) {
-      const topCopperTextMesh = createTexturePlane(
+      const topCopperTextMesh = createTexturePlane2(
         textures.topCopperText,
         pcbThickness / 2 + BOARD_SURFACE_OFFSET.copper,
         false,
@@ -34473,7 +34474,7 @@ function JscadBoardTextures({
       }
     }
     if (visibility.bottomCopper) {
-      const bottomCopperTextMesh = createTexturePlane(
+      const bottomCopperTextMesh = createTexturePlane2(
         textures.bottomCopperText,
         -pcbThickness / 2 - BOARD_SURFACE_OFFSET.copper,
         true,
@@ -34485,7 +34486,7 @@ function JscadBoardTextures({
       }
     }
     if (visibility.boardBody) {
-      const topPanelOutlinesMesh = createTexturePlane(
+      const topPanelOutlinesMesh = createTexturePlane2(
         textures.topPanelOutlines,
         pcbThickness / 2 + SURFACE_OFFSET + 3e-3,
         // Above silkscreen
@@ -34498,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
@@ -34750,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) => {
@@ -34810,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";
 
@@ -35085,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;
@@ -35161,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]);
@@ -35296,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;
@@ -35317,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 = [];
@@ -35344,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]);
@@ -35389,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]);
@@ -35704,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]);
@@ -35732,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]);
@@ -35751,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]);
@@ -35891,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();
@@ -35931,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({
@@ -35984,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();
@@ -36035,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);
@@ -36104,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);
@@ -36203,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]
@@ -36233,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]
@@ -36251,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,
@@ -36281,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,
@@ -36296,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,
@@ -36312,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,
@@ -36328,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(
@@ -36382,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,
@@ -36394,7 +36614,7 @@ var createBoardMaterial = ({
   isFaux = false
 }) => {
   if (material === "fr4") {
-    return new THREE30.MeshPhysicalMaterial({
+    return new THREE31.MeshPhysicalMaterial({
       color,
       side,
       metalness: 0,
@@ -36408,7 +36628,7 @@ var createBoardMaterial = ({
       flatShading: true
     });
   }
-  return new THREE30.MeshStandardMaterial({
+  return new THREE31.MeshStandardMaterial({
     color,
     side,
     flatShading: true,
@@ -36424,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
       })
     );
@@ -36439,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,
@@ -36459,172 +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 boardOutlineBounds = calculateOutlineBounds(boardData);
-    const planeGeom = new THREE32.PlaneGeometry(
-      boardOutlineBounds.width,
-      boardOutlineBounds.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(
-      boardOutlineBounds.centerX,
-      boardOutlineBounds.centerY,
-      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;
 }
 
@@ -36652,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);
@@ -36681,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;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/3d-viewer",
-  "version": "0.0.477",
+  "version": "0.0.478",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "type": "module",
@@ -29,6 +29,7 @@
   "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",