@tscircuit/copper-pour-solver 0.0.24 → 0.0.25

package/dist/index.js

@@ -1,18 +1,255 @@
 // lib/solvers/CopperPourPipelineSolver.ts
 import { BasePipelineSolver } from "@tscircuit/solver-utils";
 
+// lib/solvers/copper-pour/generate-brep.ts
+var signedArea = (ring) => {
+  let area = 0;
+  for (let i = 0; i < ring.length; i++) {
+    const current = ring[i];
+    const next = ring[(i + 1) % ring.length];
+    area += current.x * next.y - next.x * current.y;
+  }
+  return area / 2;
+};
+var ensureAreaSign = (ring, desiredSign) => {
+  const area = signedArea(ring);
+  const shouldReverse = desiredSign === "positive" && area < 0 || desiredSign === "negative" && area > 0;
+  return shouldReverse ? [...ring].reverse() : ring;
+};
+var ringToVertices = (ring) => ring.map((point) => ({
+  x: point.x,
+  y: point.y
+}));
+var generateBRep = (pourIslands) => {
+  const brep_shapes = [];
+  for (const island of pourIslands) {
+    if (island.outerRing.length < 3) continue;
+    const outerRing = ensureAreaSign(island.outerRing, "negative");
+    const innerRings = island.innerRings.filter((ring) => ring.length >= 3).map((ring) => ensureAreaSign(ring, "positive"));
+    brep_shapes.push({
+      outer_ring: { vertices: ringToVertices(outerRing) },
+      inner_rings: innerRings.map((ring) => ({
+        vertices: ringToVertices(ring)
+      }))
+    });
+  }
+  return brep_shapes;
+};
+
+// lib/solvers/copper-pour/manifold-geometry-adapter.ts
+var manifoldModule = await import("manifold-3d");
+var manifoldFactory = manifoldModule.default;
+var manifold = await manifoldFactory();
+manifold.setup();
+var { CrossSection } = manifold;
+var MANIFOLD_GEOMETRY_SCALE = 1e6;
+var DEFAULT_MIN_ISLAND_AREA = 1e-8;
+var describePolygons = (polygons) => {
+  let pointCount = 0;
+  const bbox = {
+    minX: Number.POSITIVE_INFINITY,
+    minY: Number.POSITIVE_INFINITY,
+    maxX: Number.NEGATIVE_INFINITY,
+    maxY: Number.NEGATIVE_INFINITY
+  };
+  for (const polygon of polygons) {
+    pointCount += polygon.length;
+    for (const [x, y] of polygon) {
+      bbox.minX = Math.min(bbox.minX, x);
+      bbox.minY = Math.min(bbox.minY, y);
+      bbox.maxX = Math.max(bbox.maxX, x);
+      bbox.maxY = Math.max(bbox.maxY, y);
+    }
+  }
+  return {
+    polygonCount: polygons.length,
+    pointCount,
+    bbox: pointCount > 0 ? bbox : null,
+    scale: MANIFOLD_GEOMETRY_SCALE
+  };
+};
+var assertFinitePoint = (point, operation) => {
+  if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) {
+    throw new Error(
+      `${operation} received non-finite point (${point.x}, ${point.y})`
+    );
+  }
+};
+var pointsEqual = (a, b) => a.x === b.x && a.y === b.y;
+var signedArea2 = (ring) => {
+  let area = 0;
+  for (let i = 0; i < ring.length; i++) {
+    const current = ring[i];
+    const next = ring[(i + 1) % ring.length];
+    area += current.x * next.y - next.x * current.y;
+  }
+  return area / 2;
+};
+var normalizeRing = (ring, operation = "normalizeRing") => {
+  const normalized = [];
+  for (const point of ring) {
+    assertFinitePoint(point, operation);
+    const roundedPoint = {
+      x: Math.round(point.x * MANIFOLD_GEOMETRY_SCALE) / MANIFOLD_GEOMETRY_SCALE,
+      y: Math.round(point.y * MANIFOLD_GEOMETRY_SCALE) / MANIFOLD_GEOMETRY_SCALE
+    };
+    const previous = normalized[normalized.length - 1];
+    if (!previous || !pointsEqual(previous, roundedPoint)) {
+      normalized.push(roundedPoint);
+    }
+  }
+  if (normalized.length > 1 && pointsEqual(normalized[0], normalized[normalized.length - 1])) {
+    normalized.pop();
+  }
+  const uniquePoints = new Set(normalized.map((p) => `${p.x},${p.y}`));
+  if (uniquePoints.size < 3 || Math.abs(signedArea2(normalized)) < 1e-18) {
+    return [];
+  }
+  return normalized;
+};
+var toScaledManifoldPolygons = (polygons, operation = "toScaledManifoldPolygons") => {
+  const scaledPolygons = [];
+  for (const polygon of polygons) {
+    const normalized = normalizeRing(polygon, operation);
+    if (normalized.length < 3) continue;
+    const positiveRing = signedArea2(normalized) < 0 ? [...normalized].reverse() : normalized;
+    scaledPolygons.push(
+      positiveRing.map((p) => [
+        Math.round(p.x * MANIFOLD_GEOMETRY_SCALE),
+        Math.round(p.y * MANIFOLD_GEOMETRY_SCALE)
+      ])
+    );
+  }
+  return scaledPolygons;
+};
+var fromScaledManifoldPolygons = (polygons) => polygons.map(
+  (polygon) => normalizeRing(
+    polygon.map(([x, y]) => ({
+      x: x / MANIFOLD_GEOMETRY_SCALE,
+      y: y / MANIFOLD_GEOMETRY_SCALE
+    })),
+    "fromScaledManifoldPolygons"
+  )
+).filter((polygon) => polygon.length >= 3);
+var runManifoldOperation = (operation, polygons, callback) => {
+  try {
+    return callback();
+  } catch (error) {
+    const details = describePolygons(polygons);
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `${operation} failed: ${message}; details=${JSON.stringify(details)}`
+    );
+  }
+};
+var crossSectionFromPolygon = (polygon, fillRule = "Positive") => {
+  const scaledPolygons = toScaledManifoldPolygons(
+    [polygon],
+    "crossSectionFromPolygon"
+  );
+  if (scaledPolygons.length === 0) {
+    return CrossSection.ofPolygons([]);
+  }
+  return runManifoldOperation(
+    "crossSectionFromPolygon",
+    scaledPolygons,
+    () => CrossSection.ofPolygons(scaledPolygons, fillRule)
+  );
+};
+var crossSectionFromPolygons = (polygons, fillRule = "Positive") => {
+  const scaledPolygons = toScaledManifoldPolygons(
+    polygons,
+    "crossSectionFromPolygons"
+  );
+  if (scaledPolygons.length === 0) {
+    return CrossSection.ofPolygons([]);
+  }
+  return runManifoldOperation(
+    "crossSectionFromPolygons",
+    scaledPolygons,
+    () => CrossSection.ofPolygons(scaledPolygons, fillRule)
+  );
+};
+var composeCrossSections = (sections) => {
+  const nonEmptySections = sections.filter((section) => !section.isEmpty());
+  if (nonEmptySections.length === 0) {
+    return CrossSection.ofPolygons([]);
+  }
+  return runManifoldOperation(
+    "composeCrossSections",
+    [],
+    () => CrossSection.compose(nonEmptySections)
+  );
+};
+var offsetPolygon = (polygon, margin, joinType = "Miter") => {
+  const scaledPolygons = toScaledManifoldPolygons([polygon], "offsetPolygon");
+  if (scaledPolygons.length === 0 || margin <= 0) {
+    return scaledPolygons.length === 0 ? [] : [normalizeRing(polygon)];
+  }
+  const scaledMargin = margin * MANIFOLD_GEOMETRY_SCALE;
+  const section = runManifoldOperation(
+    "offsetPolygon.input",
+    scaledPolygons,
+    () => CrossSection.ofPolygons(scaledPolygons, "Positive")
+  );
+  const offset = runManifoldOperation(
+    "offsetPolygon.offset",
+    scaledPolygons,
+    () => section.offset(scaledMargin, joinType, 2, 32)
+  );
+  return fromScaledManifoldPolygons(offset.toPolygons());
+};
+var subtractBlockersFromPour = (pourPolygon, blockerPolygons) => {
+  const pourSection = crossSectionFromPolygon(pourPolygon);
+  const blockerSection = crossSectionFromPolygons(blockerPolygons);
+  if (pourSection.isEmpty() || blockerSection.isEmpty()) {
+    return pourSection;
+  }
+  const operationPolygons = [
+    ...toScaledManifoldPolygons([pourPolygon], "subtractBlockersFromPour.pour"),
+    ...toScaledManifoldPolygons(
+      blockerPolygons,
+      "subtractBlockersFromPour.blockers"
+    )
+  ];
+  return runManifoldOperation(
+    "subtractBlockersFromPour",
+    operationPolygons,
+    () => pourSection.subtract(blockerSection)
+  );
+};
+var removeTinyIslands = (section, minArea = DEFAULT_MIN_ISLAND_AREA) => {
+  if (section.isEmpty()) return section;
+  const minScaledArea = minArea * MANIFOLD_GEOMETRY_SCALE * MANIFOLD_GEOMETRY_SCALE;
+  const islands = section.decompose().filter((island) => Math.abs(island.area()) >= minScaledArea);
+  return composeCrossSections(islands);
+};
+var crossSectionToCopperPourIslands = (section) => {
+  const islands = [];
+  for (const island of section.decompose()) {
+    const rings = fromScaledManifoldPolygons(island.toPolygons());
+    if (rings.length === 0) continue;
+    const outerRing = rings.reduce(
+      (largest, ring) => Math.abs(signedArea2(ring)) > Math.abs(signedArea2(largest)) ? ring : largest
+    );
+    const innerRings = rings.filter((ring) => ring !== outerRing);
+    islands.push({
+      outerRing,
+      innerRings
+    });
+  }
+  return islands;
+};
+var geometryDebugSummary = (label, polygons) => ({
+  label,
+  ...describePolygons(toScaledManifoldPolygons(polygons, label))
+});
+
 // lib/solvers/copper-pour/get-board-polygon.ts
-import Flatten from "@flatten-js/core";
 var getBoardPolygon = (region) => {
   const board_edge_margin = region.board_edge_margin ?? 0;
   if (region.outline && region.outline.length > 0) {
-    const polygon = new Flatten.Polygon(
-      region.outline.map((p) => Flatten.point(p.x, p.y))
-    );
-    if (polygon.orientation() === Flatten.ORIENTATION.CW) {
-      polygon.reverse();
-    }
-    return polygon;
+    return normalizeRing(region.outline, "getBoardPolygon.outline");
   }
   const { bounds } = region;
   const newBounds = {
@@ -22,74 +259,64 @@ var getBoardPolygon = (region) => {
     maxY: bounds.maxY - board_edge_margin
   };
   if (newBounds.minX >= newBounds.maxX || newBounds.minY >= newBounds.maxY) {
-    return new Flatten.Polygon();
+    return [];
   }
-  return new Flatten.Polygon(
-    new Flatten.Box(
-      newBounds.minX,
-      newBounds.minY,
-      newBounds.maxX,
-      newBounds.maxY
-    ).toPoints()
-  );
+  return [
+    { x: newBounds.minX, y: newBounds.minY },
+    { x: newBounds.maxX, y: newBounds.minY },
+    { x: newBounds.maxX, y: newBounds.maxY },
+    { x: newBounds.minX, y: newBounds.maxY }
+  ];
 };
 
-// lib/solvers/CopperPourPipelineSolver.ts
-import Flatten5 from "@flatten-js/core";
-
 // lib/solvers/copper-pour/process-obstacles.ts
-import Flatten3 from "@flatten-js/core";
-
-// lib/solvers/copper-pour/circle-to-polygon.ts
-import Flatten2 from "@flatten-js/core";
-var circleToPolygon = (circle, numSegments = 32) => {
+var isRectPad = (pad) => pad.shape === "rect";
+var isTracePad = (pad) => pad.shape === "trace";
+var isCircularPad = (pad) => pad.shape === "circle";
+var isPolygonPad = (pad) => pad.shape === "polygon";
+var circleToPolygon = (center, radius, numSegments = 32) => {
   const points = [];
   for (let i = 0; i < numSegments; i++) {
     const angle = i / numSegments * 2 * Math.PI;
-    points.push(
-      new Flatten2.Point(
-        circle.center.x + circle.r * Math.cos(angle),
-        circle.center.y + circle.r * Math.sin(angle)
-      )
-    );
+    points.push({
+      x: center.x + radius * Math.cos(angle),
+      y: center.y + radius * Math.sin(angle)
+    });
   }
-  return new Flatten2.Polygon(points);
+  return points;
 };
-
-// lib/solvers/copper-pour/process-obstacles.ts
-var isRectPad = (pad) => pad.shape === "rect";
-var isTracePad = (pad) => pad.shape === "trace";
-var isCircularPad = (pad) => pad.shape === "circle";
-var isPolygonPad = (pad) => pad.shape === "polygon";
+var boxToPolygon = (minX, minY, maxX, maxY) => [
+  { x: minX, y: minY },
+  { x: maxX, y: minY },
+  { x: maxX, y: maxY },
+  { x: minX, y: maxY }
+];
 var processObstaclesForPour = (pads, pourConnectivityKey, margins, boardOutline) => {
   const polygonsToSubtract = [];
   const { padMargin, traceMargin, board_edge_margin, cutoutMargin } = margins;
   if (boardOutline && boardOutline.length > 0 && board_edge_margin && board_edge_margin > 0) {
-    const boardPoly = new Flatten3.Polygon(
-      boardOutline.map((p) => Flatten3.point(p.x, p.y))
+    const vertices = normalizeRing(
+      boardOutline,
+      "processObstacles.boardOutline"
     );
-    if (boardPoly.area() < 0) {
-      boardPoly.reverse();
-    }
-    const vertices = boardPoly.vertices;
     for (let i = 0; i < vertices.length; i++) {
       const p1 = vertices[i === 0 ? vertices.length - 1 : i - 1];
       const p2 = vertices[i];
       const p3 = vertices[(i + 1) % vertices.length];
       if (!p1 || !p2 || !p3) continue;
-      const v1 = new Flatten3.Vector(p1, p2);
-      const v2 = new Flatten3.Vector(p2, p3);
-      const crossProduct = v1.cross(v2);
-      const circle = new Flatten3.Circle(p2, board_edge_margin);
-      polygonsToSubtract.push(circleToPolygon(circle));
+      const v1 = { x: p2.x - p1.x, y: p2.y - p1.y };
+      const v2 = { x: p3.x - p2.x, y: p3.y - p2.y };
+      const crossProduct = v1.x * v2.y - v1.y * v2.x;
+      polygonsToSubtract.push(circleToPolygon(p2, board_edge_margin));
       if (crossProduct < 0) {
-        const box = new Flatten3.Box(
-          p2.x - board_edge_margin,
-          p2.y - board_edge_margin,
-          p2.x + board_edge_margin,
-          p2.y + board_edge_margin
+        polygonsToSubtract.push(
+          boxToPolygon(
+            p2.x - board_edge_margin,
+            p2.y - board_edge_margin,
+            p2.x + board_edge_margin,
+            p2.y + board_edge_margin
+          )
         );
-        polygonsToSubtract.push(new Flatten3.Polygon(box.toPoints()));
       }
     }
     for (let i = 0; i < vertices.length; i++) {
@@ -117,9 +344,7 @@ var processObstaclesForPour = (pads, pourConnectivityKey, margins, boardOutline)
         x: centerX + p.x * cosAngle - p.y * sinAngle,
         y: centerY + p.x * sinAngle + p.y * cosAngle
       }));
-      polygonsToSubtract.push(
-        new Flatten3.Polygon(rotatedCorners.map((p) => Flatten3.point(p.x, p.y)))
-      );
+      polygonsToSubtract.push(rotatedCorners);
     }
   }
   for (const pad of pads) {
@@ -130,23 +355,22 @@ var processObstaclesForPour = (pads, pourConnectivityKey, margins, boardOutline)
     const isHoleOrCutout = pad.connectivityKey.startsWith("hole:") || pad.connectivityKey.startsWith("cutout:");
     if (isCircularPad(pad)) {
       const margin = isHoleOrCutout ? cutoutMargin ?? 0 : padMargin;
-      const circle = new Flatten3.Circle(
-        new Flatten3.Point(pad.x, pad.y),
-        pad.radius + margin
+      polygonsToSubtract.push(
+        circleToPolygon({ x: pad.x, y: pad.y }, pad.radius + margin)
       );
-      polygonsToSubtract.push(circleToPolygon(circle));
       continue;
     }
     if (isRectPad(pad)) {
       const margin = isHoleOrCutout ? cutoutMargin ?? 0 : padMargin;
       const { bounds } = pad;
-      const b = new Flatten3.Box(
-        bounds.minX - margin,
-        bounds.minY - margin,
-        bounds.maxX + margin,
-        bounds.maxY + margin
+      polygonsToSubtract.push(
+        boxToPolygon(
+          bounds.minX - margin,
+          bounds.minY - margin,
+          bounds.maxX + margin,
+          bounds.maxY + margin
+        )
       );
-      polygonsToSubtract.push(new Flatten3.Polygon(b.toPoints()));
       continue;
     }
     if (isPolygonPad(pad)) {
@@ -161,50 +385,20 @@ var processObstaclesForPour = (pads, pourConnectivityKey, margins, boardOutline)
         return true;
       });
       if (uniquePoints.length < 3) continue;
-      const polygon = new Flatten3.Polygon(
-        uniquePoints.map((p) => Flatten3.point(p.x, p.y))
-      );
-      if (Math.abs(polygon.area()) < 1e-9) continue;
+      const polygon = normalizeRing(uniquePoints, "processObstacles.polygonPad");
+      if (polygon.length < 3) continue;
       if (margin <= 0) {
         polygonsToSubtract.push(polygon);
         continue;
       }
-      if (polygon.area() > 0) {
-        polygon.reverse();
-      }
-      const offsetLines = [];
-      const polygonVertices = polygon.vertices;
-      for (let i = 0; i < polygonVertices.length; i++) {
-        const p1 = polygonVertices[i];
-        const p2 = polygonVertices[(i + 1) % polygonVertices.length];
-        const segment = Flatten3.segment(p1, p2);
-        if (segment.length === 0) continue;
-        const line = Flatten3.line(segment.start, segment.end);
-        const norm = line.norm;
-        const offsetLine = line.translate(norm.multiply(-margin));
-        offsetLines.push(offsetLine);
-      }
-      const newPolygonPoints = [];
-      for (let i = 0; i < offsetLines.length; i++) {
-        const line1 = offsetLines[i];
-        const line2 = offsetLines[(i + 1) % offsetLines.length];
-        const ip = line1.intersect(line2);
-        if (ip.length > 0) {
-          newPolygonPoints.push(ip[0]);
-        }
-      }
-      if (newPolygonPoints.length >= 3) {
-        polygonsToSubtract.push(new Flatten3.Polygon(newPolygonPoints));
-      }
+      polygonsToSubtract.push(...offsetPolygon(polygon, margin));
       continue;
     }
     if (isTracePad(pad)) {
       for (const segment of pad.segments) {
-        const circle = new Flatten3.Circle(
-          new Flatten3.Point(segment.x, segment.y),
-          pad.width / 2 + traceMargin
+        polygonsToSubtract.push(
+          circleToPolygon(segment, pad.width / 2 + traceMargin)
         );
-        polygonsToSubtract.push(circleToPolygon(circle));
       }
       for (let i = 0; i < pad.segments.length - 1; i++) {
         const p1 = pad.segments[i];
@@ -231,62 +425,13 @@ var processObstaclesForPour = (pads, pourConnectivityKey, margins, boardOutline)
           x: centerX + p.x * cosAngle - p.y * sinAngle,
           y: centerY + p.x * sinAngle + p.y * cosAngle
         }));
-        polygonsToSubtract.push(
-          new Flatten3.Polygon(
-            rotatedCorners.map((p) => Flatten3.point(p.x, p.y))
-          )
-        );
+        polygonsToSubtract.push(rotatedCorners);
       }
     }
   }
   return { polygonsToSubtract };
 };
 
-// lib/solvers/copper-pour/generate-brep.ts
-import Flatten4 from "@flatten-js/core";
-var faceToVertices = (face) => face.edges.map((e) => {
-  const pt = {
-    x: e.start.x,
-    y: e.start.y
-  };
-  if (e.isArc) {
-    const bulge = Math.tan(e.shape.sweep / 4);
-    if (Math.abs(bulge) > 1e-9) {
-      pt.bulge = bulge;
-    }
-  }
-  return pt;
-});
-var generateBRep = (pourPolygons) => {
-  const brep_shapes = [];
-  const polygons = Array.isArray(pourPolygons) ? pourPolygons : [pourPolygons];
-  for (const p of polygons) {
-    const islands = p.splitToIslands();
-    for (const island of islands) {
-      if (island.isEmpty()) continue;
-      const faces = [...island.faces];
-      const outer_face_ccw = faces.find(
-        (f) => f.orientation() === Flatten4.ORIENTATION.CCW
-      );
-      const inner_faces_cw = faces.filter(
-        (f) => f.orientation() === Flatten4.ORIENTATION.CW
-      );
-      if (!outer_face_ccw) continue;
-      outer_face_ccw.reverse();
-      const outer_ring_vertices = faceToVertices(outer_face_ccw);
-      const inner_rings = inner_faces_cw.map((f) => {
-        f.reverse();
-        return { vertices: faceToVertices(f) };
-      });
-      brep_shapes.push({
-        outer_ring: { vertices: outer_ring_vertices },
-        inner_rings
-      });
-    }
-  }
-  return brep_shapes;
-};
-
 // lib/solvers/CopperPourPipelineSolver.ts
 var CopperPourPipelineSolver = class extends BasePipelineSolver {
   constructor(input) {
@@ -316,23 +461,32 @@ var CopperPourPipelineSolver = class extends BasePipelineSolver {
         },
         region.outline
       );
-      let pourPolygons = boardPolygon;
-      for (const poly of polygonsToSubtract) {
-        const currentPolys = Array.isArray(pourPolygons) ? pourPolygons : [pourPolygons];
-        const nextPolys = [];
-        for (const p of currentPolys) {
-          const result = Flatten5.BooleanOperations.subtract(p, poly);
-          if (result) {
-            if (Array.isArray(result)) {
-              nextPolys.push(...result.filter((r) => !r.isEmpty()));
-            } else {
-              if (!result.isEmpty()) nextPolys.push(result);
-            }
-          }
-        }
-        pourPolygons = nextPolys;
+      if (process.env.COPPER_POUR_DEBUG_GEOMETRY) {
+        console.info(
+          JSON.stringify([
+            geometryDebugSummary("input pour polygon", [boardPolygon]),
+            geometryDebugSummary("unioned blockers input", polygonsToSubtract)
+          ])
+        );
+      }
+      const finalPour = removeTinyIslands(
+        subtractBlockersFromPour(boardPolygon, polygonsToSubtract)
+      );
+      const pourIslands = crossSectionToCopperPourIslands(finalPour);
+      if (process.env.COPPER_POUR_DEBUG_GEOMETRY) {
+        console.info(
+          JSON.stringify(
+            geometryDebugSummary(
+              "final copper polygons",
+              pourIslands.flatMap((island) => [
+                island.outerRing,
+                ...island.innerRings
+              ])
+            )
+          )
+        );
       }
-      const new_breps = generateBRep(pourPolygons);
+      const new_breps = generateBRep(pourIslands);
       brep_shapes.push(...new_breps);
     }
     return {

package/lib/solvers/CopperPourPipelineSolver.ts

@@ -1,10 +1,15 @@
 import { BasePipelineSolver } from "@tscircuit/solver-utils"
-import { getBoardPolygon } from "./copper-pour/get-board-polygon"
-import Flatten from "@flatten-js/core"
-import { processObstaclesForPour } from "./copper-pour/process-obstacles"
-import { generateBRep } from "./copper-pour/generate-brep"
 import type { BRepShape } from "circuit-json"
 import type { InputProblem, PipelineOutput } from "lib/types"
+import { generateBRep } from "./copper-pour/generate-brep"
+import { getBoardPolygon } from "./copper-pour/get-board-polygon"
+import {
+  crossSectionToCopperPourIslands,
+  geometryDebugSummary,
+  removeTinyIslands,
+  subtractBlockersFromPour,
+} from "./copper-pour/manifold-geometry-adapter"
+import { processObstaclesForPour } from "./copper-pour/process-obstacles"
 
 export class CopperPourPipelineSolver extends BasePipelineSolver<InputProblem> {
   pipelineDef = []
@@ -38,27 +43,35 @@ export class CopperPourPipelineSolver extends BasePipelineSolver<InputProblem> {
         region.outline,
       )
 
-      let pourPolygons: Flatten.Polygon | Flatten.Polygon[] = boardPolygon
+      if (process.env.COPPER_POUR_DEBUG_GEOMETRY) {
+        console.info(
+          JSON.stringify([
+            geometryDebugSummary("input pour polygon", [boardPolygon]),
+            geometryDebugSummary("unioned blockers input", polygonsToSubtract),
+          ]),
+        )
+      }
+
+      const finalPour = removeTinyIslands(
+        subtractBlockersFromPour(boardPolygon, polygonsToSubtract),
+      )
+      const pourIslands = crossSectionToCopperPourIslands(finalPour)
 
-      for (const poly of polygonsToSubtract) {
-        const currentPolys = Array.isArray(pourPolygons)
-          ? pourPolygons
-          : [pourPolygons]
-        const nextPolys: Flatten.Polygon[] = []
-        for (const p of currentPolys) {
-          const result = Flatten.BooleanOperations.subtract(p, poly)
-          if (result) {
-            if (Array.isArray(result)) {
-              nextPolys.push(...result.filter((r) => !r.isEmpty()))
-            } else {
-              if (!result.isEmpty()) nextPolys.push(result)
-            }
-          }
-        }
-        pourPolygons = nextPolys
+      if (process.env.COPPER_POUR_DEBUG_GEOMETRY) {
+        console.info(
+          JSON.stringify(
+            geometryDebugSummary(
+              "final copper polygons",
+              pourIslands.flatMap((island) => [
+                island.outerRing,
+                ...island.innerRings,
+              ]),
+            ),
+          ),
+        )
       }
 
-      const new_breps = generateBRep(pourPolygons)
+      const new_breps = generateBRep(pourIslands)
       brep_shapes.push(...new_breps)
     }