@tscircuit/copper-pour-solver 0.0.26 → 0.0.28

package/dist/index.d.ts

@@ -54,6 +54,8 @@ declare class CopperPourPipelineSolver extends BasePipelineSolver<InputProblem>
     getOutput(): PipelineOutput;
 }
 
+declare const initializeManifoldGeometry: () => Promise<void>;
+
 declare const convertCircuitJsonToInputProblem: (circuitJson: AnyCircuitElement[], options: {
     layer: LayerRef;
     pour_connectivity_key: string;
@@ -64,4 +66,4 @@ declare const convertCircuitJsonToInputProblem: (circuitJson: AnyCircuitElement[
     outline?: Point$1[];
 }) => InputProblem;
 
-export { type BaseInputPad, CopperPourPipelineSolver, type InputCircularPad, type InputPad, type InputPolygonPad, type InputPourRegion, type InputProblem, type InputRectPad, type InputTracePad, type PipelineOutput, convertCircuitJsonToInputProblem };
+export { type BaseInputPad, CopperPourPipelineSolver, type InputCircularPad, type InputPad, type InputPolygonPad, type InputPourRegion, type InputProblem, type InputRectPad, type InputTracePad, type PipelineOutput, convertCircuitJsonToInputProblem, initializeManifoldGeometry };

package/dist/index.js

@@ -1,18 +1,127 @@
 // lib/solvers/CopperPourPipelineSolver.ts
 import { BasePipelineSolver } from "@tscircuit/solver-utils";
 
+// lib/solvers/copper-pour/polygon-ring.ts
+var MANIFOLD_GEOMETRY_SCALE = 1e6;
+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 describeScaledPolygons = (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 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(signedArea(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 = signedArea(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);
+
+// lib/solvers/copper-pour/generate-brep.ts
+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/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,38 +131,194 @@ 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/manifold-runtime.ts
+import {
+  getManifoldModule,
+  getManifoldModuleSync
+} from "manifold-3d/lib/wasm.js";
+var manifoldModulePromise = null;
+var initializeManifoldGeometry = async () => {
+  if (getManifoldModuleSync()) return;
+  manifoldModulePromise ??= getManifoldModule().catch((error) => {
+    manifoldModulePromise = null;
+    throw error;
+  });
+  await manifoldModulePromise;
+};
+var isManifoldGeometryInitialized = () => Boolean(getManifoldModuleSync());
+var getCrossSection = () => {
+  const manifold = getManifoldModuleSync();
+  if (!manifold) {
+    throw new Error(
+      "Manifold geometry has not been initialized. Call initializeManifoldGeometry() before solving copper pours."
+    );
+  }
+  return manifold.CrossSection;
+};
+var runManifoldOperation = (operation, polygons, callback) => {
+  try {
+    return callback();
+  } catch (error) {
+    const details = describeScaledPolygons(polygons);
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `${operation} failed: ${message}; details=${JSON.stringify(details)}`
+    );
+  }
+};
 
-// lib/solvers/copper-pour/process-obstacles.ts
-import Flatten3 from "@flatten-js/core";
+// lib/solvers/copper-pour/manifold-geometry-adapter.ts
+var DEFAULT_MIN_ISLAND_AREA = 1e-8;
+var crossSectionFromPolygon = (polygon, fillRule = "Positive") => {
+  const scaledPolygons = toScaledManifoldPolygons(
+    [polygon],
+    "crossSectionFromPolygon"
+  );
+  const CrossSection = getCrossSection();
+  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"
+  );
+  const CrossSection = getCrossSection();
+  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());
+  const CrossSection = getCrossSection();
+  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 CrossSection = getCrossSection();
+  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(signedArea(ring)) > Math.abs(signedArea(largest)) ? ring : largest
+    );
+    const innerRings = rings.filter((ring) => ring !== outerRing);
+    islands.push({
+      outerRing,
+      innerRings
+    });
+  }
+  return islands;
+};
 
-// lib/solvers/copper-pour/circle-to-polygon.ts
-import Flatten2 from "@flatten-js/core";
-var circleToPolygon = (circle, numSegments = 32) => {
+// lib/solvers/copper-pour/polygon-primitives.ts
+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;
+};
+var boxToPolygon = (minX, minY, maxX, maxY) => [
+  { x: minX, y: minY },
+  { x: maxX, y: minY },
+  { x: maxX, y: maxY },
+  { x: minX, y: maxY }
+];
+var segmentToPolygon = (start, end, width) => {
+  const segmentLength = Math.hypot(start.x - end.x, start.y - end.y);
+  if (segmentLength === 0) return [];
+  const centerX = (start.x + end.x) / 2;
+  const centerY = (start.y + end.y) / 2;
+  const angle = Math.atan2(end.y - start.y, end.x - start.x);
+  const cosAngle = Math.cos(angle);
+  const sinAngle = Math.sin(angle);
+  const halfLength = segmentLength / 2;
+  const halfWidth = width / 2;
+  return [
+    { x: -halfLength, y: -halfWidth },
+    { x: halfLength, y: -halfWidth },
+    { x: halfLength, y: halfWidth },
+    { x: -halfLength, y: halfWidth }
+  ].map((point) => ({
+    x: centerX + point.x * cosAngle - point.y * sinAngle,
+    y: centerY + point.x * sinAngle + point.y * cosAngle
+  }));
 };
 
 // lib/solvers/copper-pour/process-obstacles.ts
@@ -65,61 +330,38 @@ 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++) {
       const p1 = vertices[i];
       const p2 = vertices[(i + 1) % vertices.length];
       if (!p1 || !p2) continue;
-      const segmentLength = Math.hypot(p1.x - p2.x, p1.y - p2.y);
-      if (segmentLength === 0) continue;
-      const enlargedWidth = board_edge_margin * 2;
-      const centerX = (p1.x + p2.x) / 2;
-      const centerY = (p1.y + p2.y) / 2;
-      const rotationDeg = Math.atan2(p2.y - p1.y, p2.x - p1.x) * 180 / Math.PI;
-      const w2 = segmentLength / 2;
-      const h2 = enlargedWidth / 2;
-      const angleRad = rotationDeg * Math.PI / 180;
-      const cosAngle = Math.cos(angleRad);
-      const sinAngle = Math.sin(angleRad);
-      const corners = [
-        { x: -w2, y: -h2 },
-        { x: w2, y: -h2 },
-        { x: w2, y: h2 },
-        { x: -w2, y: h2 }
-      ];
-      const rotatedCorners = corners.map((p) => ({
-        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)))
-      );
+      const segmentPolygon = segmentToPolygon(p1, p2, board_edge_margin * 2);
+      if (segmentPolygon.length > 0) {
+        polygonsToSubtract.push(segmentPolygon);
+      }
     }
   }
   for (const pad of pads) {
@@ -130,23 +372,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,132 +402,39 @@ 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];
         const p2 = pad.segments[i + 1];
         if (!p1 || !p2) continue;
-        const segmentLength = Math.hypot(p1.x - p2.x, p1.y - p2.y);
-        if (segmentLength === 0) continue;
-        const enlargedWidth = pad.width + traceMargin * 2;
-        const centerX = (p1.x + p2.x) / 2;
-        const centerY = (p1.y + p2.y) / 2;
-        const rotationDeg = Math.atan2(p2.y - p1.y, p2.x - p1.x) * 180 / Math.PI;
-        const w2 = segmentLength / 2;
-        const h2 = enlargedWidth / 2;
-        const angleRad = rotationDeg * Math.PI / 180;
-        const cosAngle = Math.cos(angleRad);
-        const sinAngle = Math.sin(angleRad);
-        const corners = [
-          { x: -w2, y: -h2 },
-          { x: w2, y: -h2 },
-          { x: w2, y: h2 },
-          { x: -w2, y: h2 }
-        ];
-        const rotatedCorners = corners.map((p) => ({
-          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))
-          )
+        const segmentPolygon = segmentToPolygon(
+          p1,
+          p2,
+          pad.width + traceMargin * 2
         );
+        if (segmentPolygon.length > 0) {
+          polygonsToSubtract.push(segmentPolygon);
+        }
       }
     }
   }
   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) {
@@ -299,6 +447,11 @@ var CopperPourPipelineSolver = class extends BasePipelineSolver {
     return "CopperPourPipelineSolver";
   }
   getOutput() {
+    if (!isManifoldGeometryInitialized()) {
+      throw new Error(
+        "Manifold geometry has not been initialized. Call initializeManifoldGeometry() before solving copper pours."
+      );
+    }
     const brep_shapes = [];
     for (const region of this.input.regionsForPour) {
       const boardPolygon = getBoardPolygon(region);
@@ -316,23 +469,11 @@ 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;
-      }
-      const new_breps = generateBRep(pourPolygons);
+      const finalPour = removeTinyIslands(
+        subtractBlockersFromPour(boardPolygon, polygonsToSubtract)
+      );
+      const pourIslands = crossSectionToCopperPourIslands(finalPour);
+      const new_breps = generateBRep(pourIslands);
       brep_shapes.push(...new_breps);
     }
     return {
@@ -559,5 +700,6 @@ var convertCircuitJsonToInputProblem = (circuitJson, options) => {
 };
 export {
   CopperPourPipelineSolver,
-  convertCircuitJsonToInputProblem
+  convertCircuitJsonToInputProblem,
+  initializeManifoldGeometry
 };

package/lib/index.ts

@@ -1,3 +1,4 @@
 export * from "./solvers/CopperPourPipelineSolver"
+export { initializeManifoldGeometry } from "./solvers/copper-pour/manifold-runtime"
 export * from "./circuit-json/convert-circuit-json-to-input-problem"
 export * from "./types"