@tscircuit/copper-pour-solver 0.0.25 → 0.0.27

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,7 +1,8 @@
 // lib/solvers/CopperPourPipelineSolver.ts
 import { BasePipelineSolver } from "@tscircuit/solver-utils";
 
-// lib/solvers/copper-pour/generate-brep.ts
+// 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++) {
@@ -11,40 +12,7 @@ var signedArea = (ring) => {
   }
   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) => {
+var describeScaledPolygons = (polygons) => {
   let pointCount = 0;
   const bbox = {
     minX: Number.POSITIVE_INFINITY,
@@ -76,15 +44,6 @@ var assertFinitePoint = (point, operation) => {
   }
 };
 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) {
@@ -102,7 +61,7 @@ var normalizeRing = (ring, operation = "normalizeRing") => {
     normalized.pop();
   }
   const uniquePoints = new Set(normalized.map((p) => `${p.x},${p.y}`));
-  if (uniquePoints.size < 3 || Math.abs(signedArea2(normalized)) < 1e-18) {
+  if (uniquePoints.size < 3 || Math.abs(signedArea(normalized)) < 1e-18) {
     return [];
   }
   return normalized;
@@ -112,7 +71,7 @@ var toScaledManifoldPolygons = (polygons, operation = "toScaledManifoldPolygons"
   for (const polygon of polygons) {
     const normalized = normalizeRing(polygon, operation);
     if (normalized.length < 3) continue;
-    const positiveRing = signedArea2(normalized) < 0 ? [...normalized].reverse() : normalized;
+    const positiveRing = signedArea(normalized) < 0 ? [...normalized].reverse() : normalized;
     scaledPolygons.push(
       positiveRing.map((p) => [
         Math.round(p.x * MANIFOLD_GEOMETRY_SCALE),
@@ -131,22 +90,101 @@ var fromScaledManifoldPolygons = (polygons) => polygons.map(
     "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
+var getBoardPolygon = (region) => {
+  const board_edge_margin = region.board_edge_margin ?? 0;
+  if (region.outline && region.outline.length > 0) {
+    return normalizeRing(region.outline, "getBoardPolygon.outline");
+  }
+  const { bounds } = region;
+  const newBounds = {
+    minX: bounds.minX + board_edge_margin,
+    minY: bounds.minY + board_edge_margin,
+    maxX: bounds.maxX - board_edge_margin,
+    maxY: bounds.maxY - board_edge_margin
+  };
+  if (newBounds.minX >= newBounds.maxX || newBounds.minY >= newBounds.maxY) {
+    return [];
+  }
+  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/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 = describePolygons(polygons);
+    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/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([]);
   }
@@ -161,6 +199,7 @@ var crossSectionFromPolygons = (polygons, fillRule = "Positive") => {
     polygons,
     "crossSectionFromPolygons"
   );
+  const CrossSection = getCrossSection();
   if (scaledPolygons.length === 0) {
     return CrossSection.ofPolygons([]);
   }
@@ -172,6 +211,7 @@ var crossSectionFromPolygons = (polygons, fillRule = "Positive") => {
 };
 var composeCrossSections = (sections) => {
   const nonEmptySections = sections.filter((section) => !section.isEmpty());
+  const CrossSection = getCrossSection();
   if (nonEmptySections.length === 0) {
     return CrossSection.ofPolygons([]);
   }
@@ -187,6 +227,7 @@ var offsetPolygon = (polygon, margin, joinType = "Miter") => {
     return scaledPolygons.length === 0 ? [] : [normalizeRing(polygon)];
   }
   const scaledMargin = margin * MANIFOLD_GEOMETRY_SCALE;
+  const CrossSection = getCrossSection();
   const section = runManifoldOperation(
     "offsetPolygon.input",
     scaledPolygons,
@@ -230,7 +271,7 @@ var crossSectionToCopperPourIslands = (section) => {
     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
+      (largest, ring) => Math.abs(signedArea(ring)) > Math.abs(signedArea(largest)) ? ring : largest
     );
     const innerRings = rings.filter((ring) => ring !== outerRing);
     islands.push({
@@ -240,40 +281,8 @@ var crossSectionToCopperPourIslands = (section) => {
   }
   return islands;
 };
-var geometryDebugSummary = (label, polygons) => ({
-  label,
-  ...describePolygons(toScaledManifoldPolygons(polygons, label))
-});
-
-// lib/solvers/copper-pour/get-board-polygon.ts
-var getBoardPolygon = (region) => {
-  const board_edge_margin = region.board_edge_margin ?? 0;
-  if (region.outline && region.outline.length > 0) {
-    return normalizeRing(region.outline, "getBoardPolygon.outline");
-  }
-  const { bounds } = region;
-  const newBounds = {
-    minX: bounds.minX + board_edge_margin,
-    minY: bounds.minY + board_edge_margin,
-    maxX: bounds.maxX - board_edge_margin,
-    maxY: bounds.maxY - board_edge_margin
-  };
-  if (newBounds.minX >= newBounds.maxX || newBounds.minY >= newBounds.maxY) {
-    return [];
-  }
-  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/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";
+// lib/solvers/copper-pour/polygon-primitives.ts
 var circleToPolygon = (center, radius, numSegments = 32) => {
   const points = [];
   for (let i = 0; i < numSegments; i++) {
@@ -291,6 +300,32 @@ var boxToPolygon = (minX, minY, maxX, maxY) => [
   { 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
+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 processObstaclesForPour = (pads, pourConnectivityKey, margins, boardOutline) => {
   const polygonsToSubtract = [];
   const { padMargin, traceMargin, board_edge_margin, cutoutMargin } = margins;
@@ -323,28 +358,10 @@ var processObstaclesForPour = (pads, pourConnectivityKey, margins, boardOutline)
       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(rotatedCorners);
+      const segmentPolygon = segmentToPolygon(p1, p2, board_edge_margin * 2);
+      if (segmentPolygon.length > 0) {
+        polygonsToSubtract.push(segmentPolygon);
+      }
     }
   }
   for (const pad of pads) {
@@ -404,28 +421,14 @@ var processObstaclesForPour = (pads, pourConnectivityKey, margins, boardOutline)
         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(rotatedCorners);
+        const segmentPolygon = segmentToPolygon(
+          p1,
+          p2,
+          pad.width + traceMargin * 2
+        );
+        if (segmentPolygon.length > 0) {
+          polygonsToSubtract.push(segmentPolygon);
+        }
       }
     }
   }
@@ -444,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);
@@ -461,31 +469,10 @@ var CopperPourPipelineSolver = class extends BasePipelineSolver {
         },
         region.outline
       );
-      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(pourIslands);
       brep_shapes.push(...new_breps);
     }
@@ -713,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"

package/lib/solvers/CopperPourPipelineSolver.ts

@@ -5,10 +5,10 @@ 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 { isManifoldGeometryInitialized } from "./copper-pour/manifold-runtime"
 import { processObstaclesForPour } from "./copper-pour/process-obstacles"
 
 export class CopperPourPipelineSolver extends BasePipelineSolver<InputProblem> {
@@ -22,6 +22,12 @@ export class CopperPourPipelineSolver extends BasePipelineSolver<InputProblem> {
   }
 
   override getOutput(): PipelineOutput {
+    if (!isManifoldGeometryInitialized()) {
+      throw new Error(
+        "Manifold geometry has not been initialized. Call initializeManifoldGeometry() before solving copper pours.",
+      )
+    }
+
     const brep_shapes: BRepShape[] = []
 
     for (const region of this.input.regionsForPour) {
@@ -43,34 +49,11 @@ export class CopperPourPipelineSolver extends BasePipelineSolver<InputProblem> {
         region.outline,
       )
 
-      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(pourIslands)
       brep_shapes.push(...new_breps)
     }

package/lib/solvers/copper-pour/generate-brep.ts

@@ -1,15 +1,6 @@
 import type { BRepShape } from "circuit-json"
-import type { CopperPourIsland, PolygonRing } from "./manifold-geometry-adapter"
-
-const signedArea = (ring: PolygonRing) => {
-  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
-}
+import type { CopperPourIsland } from "./manifold-geometry-adapter"
+import { signedArea, type PolygonRing } from "./polygon-ring"
 
 const ensureAreaSign = (
   ring: PolygonRing,

package/lib/solvers/copper-pour/get-board-polygon.ts

@@ -1,6 +1,5 @@
 import type { InputPourRegion } from "lib/types"
-import type { PolygonRing } from "./manifold-geometry-adapter"
-import { normalizeRing } from "./manifold-geometry-adapter"
+import { normalizeRing, type PolygonRing } from "./polygon-ring"
 
 export const getBoardPolygon = (region: InputPourRegion): PolygonRing => {
   const board_edge_margin = region.board_edge_margin ?? 0

package/lib/solvers/copper-pour/manifold-geometry-adapter.ts

@@ -1,176 +1,34 @@
-import type { Point } from "@tscircuit/math-utils"
-import type {
-  CrossSection as CrossSectionType,
-  FillRule,
-  SimplePolygon,
-} from "manifold-3d"
+import type { FillRule } from "manifold-3d"
+import {
+  getCrossSection,
+  runManifoldOperation,
+  type CrossSection,
+} from "./manifold-runtime"
+import {
+  fromScaledManifoldPolygons,
+  MANIFOLD_GEOMETRY_SCALE,
+  normalizeRing,
+  signedArea,
+  toScaledManifoldPolygons,
+  type PolygonRing,
+} from "./polygon-ring"
 
-const manifoldModule = await import("manifold-3d")
-const manifoldFactory = manifoldModule.default as unknown as () => Promise<{
-  CrossSection: typeof CrossSectionType
-  setup: () => void
-}>
-const manifold = await manifoldFactory()
-manifold.setup()
-
-const { CrossSection } = manifold
-
-export const MANIFOLD_GEOMETRY_SCALE = 1_000_000
 export const DEFAULT_MIN_ISLAND_AREA = 1e-8
 
-export type PolygonRing = Point[]
-type ScaledPolygons = SimplePolygon[]
 export type CopperPourIsland = {
   outerRing: PolygonRing
   innerRings: PolygonRing[]
 }
 
-const describePolygons = (polygons: ScaledPolygons) => {
-  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,
-  }
-}
-
-const assertFinitePoint = (point: Point, operation: string) => {
-  if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) {
-    throw new Error(
-      `${operation} received non-finite point (${point.x}, ${point.y})`,
-    )
-  }
-}
-
-const pointsEqual = (a: Point, b: Point) => a.x === b.x && a.y === b.y
-
-const signedArea = (ring: PolygonRing) => {
-  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
-}
-
-export const normalizeRing = (
-  ring: PolygonRing,
-  operation = "normalizeRing",
-): PolygonRing => {
-  const normalized: PolygonRing = []
-
-  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
-}
-
-// Manifold owns all robust 2D clipping/offsetting for copper-pour geometry.
-// This adapter keeps scaling, ring normalization, errors, and output grouping
-// out of the solver so the rest of the repo stays independent of WASM details.
-export const toScaledManifoldPolygons = (
-  polygons: PolygonRing[],
-  operation = "toScaledManifoldPolygons",
-): ScaledPolygons => {
-  const scaledPolygons: 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
-}
-
-export const fromScaledManifoldPolygons = (
-  polygons: SimplePolygon[],
-): PolygonRing[] =>
-  polygons
-    .map((polygon) =>
-      normalizeRing(
-        polygon.map(([x, y]) => ({
-          x: x / MANIFOLD_GEOMETRY_SCALE,
-          y: y / MANIFOLD_GEOMETRY_SCALE,
-        })),
-        "fromScaledManifoldPolygons",
-      ),
-    )
-    .filter((polygon) => polygon.length >= 3)
-
-const runManifoldOperation = <T>(
-  operation: string,
-  polygons: ScaledPolygons,
-  callback: () => T,
-): T => {
-  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)}`,
-    )
-  }
-}
-
 export const crossSectionFromPolygon = (
   polygon: PolygonRing,
   fillRule: FillRule = "Positive",
-): CrossSectionType => {
+): CrossSection => {
   const scaledPolygons = toScaledManifoldPolygons(
     [polygon],
     "crossSectionFromPolygon",
   )
+  const CrossSection = getCrossSection()
   if (scaledPolygons.length === 0) {
     return CrossSection.ofPolygons([])
   }
@@ -182,11 +40,12 @@ export const crossSectionFromPolygon = (
 export const crossSectionFromPolygons = (
   polygons: PolygonRing[],
   fillRule: FillRule = "Positive",
-): CrossSectionType => {
+): CrossSection => {
   const scaledPolygons = toScaledManifoldPolygons(
     polygons,
     "crossSectionFromPolygons",
   )
+  const CrossSection = getCrossSection()
   if (scaledPolygons.length === 0) {
     return CrossSection.ofPolygons([])
   }
@@ -196,9 +55,10 @@ export const crossSectionFromPolygons = (
 }
 
 export const composeCrossSections = (
-  sections: CrossSectionType[],
-): CrossSectionType => {
+  sections: CrossSection[],
+): CrossSection => {
   const nonEmptySections = sections.filter((section) => !section.isEmpty())
+  const CrossSection = getCrossSection()
   if (nonEmptySections.length === 0) {
     return CrossSection.ofPolygons([])
   }
@@ -218,6 +78,7 @@ export const offsetPolygon = (
   }
 
   const scaledMargin = margin * MANIFOLD_GEOMETRY_SCALE
+  const CrossSection = getCrossSection()
   const section = runManifoldOperation(
     "offsetPolygon.input",
     scaledPolygons,
@@ -234,7 +95,7 @@ export const offsetPolygon = (
 export const subtractBlockersFromPour = (
   pourPolygon: PolygonRing,
   blockerPolygons: PolygonRing[],
-): CrossSectionType => {
+): CrossSection => {
   const pourSection = crossSectionFromPolygon(pourPolygon)
   const blockerSection = crossSectionFromPolygons(blockerPolygons)
 
@@ -258,9 +119,9 @@ export const subtractBlockersFromPour = (
 }
 
 export const removeTinyIslands = (
-  section: CrossSectionType,
+  section: CrossSection,
   minArea = DEFAULT_MIN_ISLAND_AREA,
-): CrossSectionType => {
+): CrossSection => {
   if (section.isEmpty()) return section
 
   const minScaledArea =
@@ -273,7 +134,7 @@ export const removeTinyIslands = (
 }
 
 export const crossSectionToCopperPourIslands = (
-  section: CrossSectionType,
+  section: CrossSection,
 ): CopperPourIsland[] => {
   const islands: CopperPourIsland[] = []
 
@@ -296,11 +157,3 @@ export const crossSectionToCopperPourIslands = (
 
   return islands
 }
-
-export const geometryDebugSummary = (
-  label: string,
-  polygons: PolygonRing[],
-) => ({
-  label,
-  ...describePolygons(toScaledManifoldPolygons(polygons, label)),
-})

package/lib/solvers/copper-pour/manifold-runtime.ts

@@ -0,0 +1,51 @@
+import type {
+  CrossSection as CrossSectionType,
+  ManifoldToplevel,
+} from "manifold-3d"
+import {
+  getManifoldModule,
+  getManifoldModuleSync,
+} from "manifold-3d/lib/wasm.js"
+import { describeScaledPolygons, type ScaledPolygons } from "./polygon-ring"
+
+let manifoldModulePromise: Promise<ManifoldToplevel> | null = null
+
+export const initializeManifoldGeometry = async () => {
+  if (getManifoldModuleSync()) return
+  manifoldModulePromise ??= getManifoldModule().catch((error) => {
+    manifoldModulePromise = null
+    throw error
+  })
+  await manifoldModulePromise
+}
+
+export const isManifoldGeometryInitialized = () =>
+  Boolean(getManifoldModuleSync())
+
+export const getCrossSection = () => {
+  const manifold = getManifoldModuleSync()
+  if (!manifold) {
+    throw new Error(
+      "Manifold geometry has not been initialized. Call initializeManifoldGeometry() before solving copper pours.",
+    )
+  }
+  return manifold.CrossSection
+}
+
+export const runManifoldOperation = <T>(
+  operation: string,
+  polygons: ScaledPolygons,
+  callback: () => T,
+): T => {
+  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)}`,
+    )
+  }
+}
+
+export type CrossSection = CrossSectionType

package/lib/solvers/copper-pour/polygon-primitives.ts

@@ -0,0 +1,57 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { PolygonRing } from "./polygon-ring"
+
+export const circleToPolygon = (
+  center: Point,
+  radius: number,
+  numSegments = 32,
+): PolygonRing => {
+  const points: PolygonRing = []
+  for (let i = 0; i < numSegments; i++) {
+    const angle = (i / numSegments) * 2 * Math.PI
+    points.push({
+      x: center.x + radius * Math.cos(angle),
+      y: center.y + radius * Math.sin(angle),
+    })
+  }
+  return points
+}
+
+export const boxToPolygon = (
+  minX: number,
+  minY: number,
+  maxX: number,
+  maxY: number,
+): PolygonRing => [
+  { x: minX, y: minY },
+  { x: maxX, y: minY },
+  { x: maxX, y: maxY },
+  { x: minX, y: maxY },
+]
+
+export const segmentToPolygon = (
+  start: Point,
+  end: Point,
+  width: number,
+): PolygonRing => {
+  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,
+  }))
+}

package/lib/solvers/copper-pour/polygon-ring.ts

@@ -0,0 +1,126 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { SimplePolygon } from "manifold-3d"
+
+export const MANIFOLD_GEOMETRY_SCALE = 1_000_000
+
+export type PolygonRing = Point[]
+export type ScaledPolygons = SimplePolygon[]
+
+export const signedArea = (ring: PolygonRing) => {
+  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
+}
+
+export const describeScaledPolygons = (polygons: ScaledPolygons) => {
+  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,
+  }
+}
+
+const assertFinitePoint = (point: Point, operation: string) => {
+  if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) {
+    throw new Error(
+      `${operation} received non-finite point (${point.x}, ${point.y})`,
+    )
+  }
+}
+
+const pointsEqual = (a: Point, b: Point) => a.x === b.x && a.y === b.y
+
+export const normalizeRing = (
+  ring: PolygonRing,
+  operation = "normalizeRing",
+): PolygonRing => {
+  const normalized: PolygonRing = []
+
+  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
+}
+
+export const toScaledManifoldPolygons = (
+  polygons: PolygonRing[],
+  operation = "toScaledManifoldPolygons",
+): ScaledPolygons => {
+  const scaledPolygons: 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
+}
+
+export const fromScaledManifoldPolygons = (
+  polygons: SimplePolygon[],
+): PolygonRing[] =>
+  polygons
+    .map((polygon) =>
+      normalizeRing(
+        polygon.map(([x, y]) => ({
+          x: x / MANIFOLD_GEOMETRY_SCALE,
+          y: y / MANIFOLD_GEOMETRY_SCALE,
+        })),
+        "fromScaledManifoldPolygons",
+      ),
+    )
+    .filter((polygon) => polygon.length >= 3)

package/lib/solvers/copper-pour/process-obstacles.ts

@@ -6,11 +6,13 @@ import type {
   InputRectPad,
   InputTracePad,
 } from "lib/types"
+import { offsetPolygon } from "./manifold-geometry-adapter"
 import {
-  normalizeRing,
-  offsetPolygon,
-  type PolygonRing,
-} from "./manifold-geometry-adapter"
+  boxToPolygon,
+  circleToPolygon,
+  segmentToPolygon,
+} from "./polygon-primitives"
+import { normalizeRing, type PolygonRing } from "./polygon-ring"
 
 interface ProcessedObstacles {
   polygonsToSubtract: PolygonRing[]
@@ -24,34 +26,6 @@ const isCircularPad = (pad: InputPad): pad is InputCircularPad =>
 const isPolygonPad = (pad: InputPad): pad is InputPolygonPad =>
   pad.shape === "polygon"
 
-const circleToPolygon = (
-  center: Point,
-  radius: number,
-  numSegments = 32,
-): PolygonRing => {
-  const points: PolygonRing = []
-  for (let i = 0; i < numSegments; i++) {
-    const angle = (i / numSegments) * 2 * Math.PI
-    points.push({
-      x: center.x + radius * Math.cos(angle),
-      y: center.y + radius * Math.sin(angle),
-    })
-  }
-  return points
-}
-
-const boxToPolygon = (
-  minX: number,
-  minY: number,
-  maxX: number,
-  maxY: number,
-): PolygonRing => [
-  { x: minX, y: minY },
-  { x: maxX, y: minY },
-  { x: maxX, y: maxY },
-  { x: minX, y: maxY },
-]
-
 export const processObstaclesForPour = (
   pads: InputPad[],
   pourConnectivityKey: string,
@@ -111,35 +85,10 @@ export const processObstaclesForPour = (
 
       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(rotatedCorners)
+      const segmentPolygon = segmentToPolygon(p1, p2, board_edge_margin * 2)
+      if (segmentPolygon.length > 0) {
+        polygonsToSubtract.push(segmentPolygon)
+      }
     }
   }
 
@@ -218,36 +167,14 @@ export const processObstaclesForPour = (
 
         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(rotatedCorners)
+        const segmentPolygon = segmentToPolygon(
+          p1,
+          p2,
+          pad.width + traceMargin * 2,
+        )
+        if (segmentPolygon.length > 0) {
+          polygonsToSubtract.push(segmentPolygon)
+        }
       }
     }
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/copper-pour-solver",
   "main": "dist/index.js",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "scripts": {
     "format": "biome format . --write",
     "format:check": "biome format .",

package/tests/fixtures/preload.ts

@@ -1 +1,4 @@
 import "bun-match-svg"
+import { initializeManifoldGeometry } from "lib/index"
+
+await initializeManifoldGeometry()

package/tests/stm32f746g-disco.test.ts

@@ -11,7 +11,7 @@ test("stm32f746g-disco top layer full board repro", () => {
     trace_margin: 0.2,
   })
 
- expect(svg).toMatchSvgSnapshot(import.meta.path+"top")
+  expect(svg).toMatchSvgSnapshot(import.meta.path + "top")
 })
 
 test("stm32f746g-disco bottom layer full board repro", () => {
@@ -22,5 +22,5 @@ test("stm32f746g-disco bottom layer full board repro", () => {
     trace_margin: 0.2,
   })
 
- expect(svg).toMatchSvgSnapshot(import.meta.path+"bottom")
+  expect(svg).toMatchSvgSnapshot(import.meta.path + "bottom")
 })