calculate-packing 0.0.59 → 0.0.61

package/README.md

@@ -22,6 +22,9 @@ Internally the algorithm:
 4. evaluates the four orthogonal rotations of the candidate component and
    chooses the cheapest non-overlapping one
 
+<img width="4652" height="3508" alt="image" src="https://github.com/user-attachments/assets/a1c7f129-6e87-42d2-aa3e-3a0f39719469" />
+
+
 ## Installation
 
 ```bash

package/dist/index.d.ts

@@ -142,19 +142,32 @@ declare class LargestRectOutsideOutlineFromPointSolver extends BaseSolver$1 {
     origin: Point$1;
     globalBounds: Bounds;
     largestRect: Rect | null;
+    /**
+     * Mode for finding rectangles:
+     * - "outside": Find rect outside the polygon (for CCW obstacle boundaries)
+     * - "inside": Find rect inside the polygon (for CW free space pockets)
+     */
+    mode: "outside" | "inside";
     constructor(params: {
         ccwFullOutline: Point$1[];
         origin: Point$1;
         globalBounds: Bounds;
+        /**
+         * Mode for finding rectangles:
+         * - "outside" (default): Find rect outside the polygon (for CCW obstacle boundaries)
+         * - "inside": Find rect inside the polygon (for CW free space pockets)
+         */
+        mode?: "outside" | "inside";
     });
     getConstructorParams(): {
         ccwFullOutline: Point$1[];
         origin: Point$1;
         globalBounds: Bounds;
+        mode: "outside" | "inside";
     };
     _setup(): void;
     _step(): void;
-    private computeLargestRectOutside;
+    private computeLargestRect;
     private almostEqual;
     private makeEdges;
     private isVertical;
@@ -383,6 +396,9 @@ declare class OutlineSegmentCandidatePointSolver extends BaseSolver$1 {
     optimalPosition?: Point$2;
     irlsSolver?: MultiOffsetIrlsSolver;
     twoPhaseIrlsSolver?: TwoPhaseIrlsSolver;
+    largestRectBounds?: Bounds;
+    largestRectMidPoint?: Point$2;
+    largestRectOrigin?: Point$2;
     constructor(params: {
         outlineSegment: [Point$2, Point$2];
         ccwFullOutline: [Point$2, Point$2][];

package/dist/index.js

@@ -59,6 +59,53 @@ function sortComponentQueue({
 // lib/constructOutlinesFromPackedComponents.ts
 import Flatten from "@flatten-js/core";
 
+// lib/geometry/combineBounds.ts
+var combineBounds = (bounds) => {
+  const minX = Math.min(...bounds.map((b) => b.minX));
+  const minY = Math.min(...bounds.map((b) => b.minY));
+  const maxX = Math.max(...bounds.map((b) => b.maxX));
+  const maxY = Math.max(...bounds.map((b) => b.maxY));
+  return { minX, minY, maxX, maxY };
+};
+
+// lib/geometry/getComponentBounds.ts
+var getComponentBounds = (component, minGap = 0) => {
+  const bounds = {
+    minX: Infinity,
+    maxX: -Infinity,
+    minY: Infinity,
+    maxY: -Infinity
+  };
+  component.pads.forEach((pad) => {
+    const hw = pad.size.x / 2;
+    const hh = pad.size.y / 2;
+    const localCorners = [
+      { x: pad.offset.x - hw, y: pad.offset.y - hh },
+      { x: pad.offset.x + hw, y: pad.offset.y - hh },
+      { x: pad.offset.x + hw, y: pad.offset.y + hh },
+      { x: pad.offset.x - hw, y: pad.offset.y + hh }
+    ];
+    localCorners.forEach((corner) => {
+      const world = rotatePoint(
+        corner,
+        component.ccwRotationOffset * Math.PI / 180
+      );
+      const x = world.x + component.center.x;
+      const y = world.y + component.center.y;
+      bounds.minX = Math.min(bounds.minX, x);
+      bounds.maxX = Math.max(bounds.maxX, x);
+      bounds.minY = Math.min(bounds.minY, y);
+      bounds.maxY = Math.max(bounds.maxY, y);
+    });
+  });
+  return {
+    minX: bounds.minX - minGap,
+    maxX: bounds.maxX + minGap,
+    minY: bounds.minY - minGap,
+    maxY: bounds.maxY + minGap
+  };
+};
+
 // lib/math/cross.ts
 var cross = (O, A, B) => (A.x - O.x) * (B.y - O.y) - (A.y - O.y) * (B.x - O.x);
 
@@ -73,7 +120,7 @@ function simplifyCollinearSegments(outline, tolerance = 1e-10) {
   for (let i = 1; i < outline.length; i++) {
     const nextSegment = outline[i];
     const [nextStart, nextEnd] = nextSegment;
-    const connectionTolerance = 1e-10;
+    const connectionTolerance = 1e-9;
     const isConnected = Math.abs(currentSegmentEnd.x - nextStart.x) < connectionTolerance && Math.abs(currentSegmentEnd.y - nextStart.y) < connectionTolerance;
     if (!isConnected) {
       simplified.push([currentSegmentStart, currentSegmentEnd]);
@@ -82,7 +129,16 @@ function simplifyCollinearSegments(outline, tolerance = 1e-10) {
       continue;
     }
     const crossProduct = cross(currentSegmentStart, currentSegmentEnd, nextEnd);
-    if (Math.abs(crossProduct) < tolerance) {
+    const segLen1 = Math.hypot(
+      currentSegmentEnd.x - currentSegmentStart.x,
+      currentSegmentEnd.y - currentSegmentStart.y
+    );
+    const segLen2 = Math.hypot(
+      nextEnd.x - currentSegmentEnd.x,
+      nextEnd.y - currentSegmentEnd.y
+    );
+    const scaledTolerance = Math.max(tolerance, tolerance * segLen1 * segLen2);
+    if (Math.abs(crossProduct) < scaledTolerance) {
       currentSegmentEnd = nextEnd;
     } else {
       simplified.push([currentSegmentStart, currentSegmentEnd]);
@@ -97,7 +153,7 @@ function simplifyCollinearSegments(outline, tolerance = 1e-10) {
       currentSegmentEnd
     ];
     if (firstSegment && simplified.length > 0) {
-      const connectionTolerance = 1e-10;
+      const connectionTolerance = 1e-9;
       const isLastConnectedToFirst = Math.abs(currentSegmentEnd.x - firstSegment[0].x) < connectionTolerance && Math.abs(currentSegmentEnd.y - firstSegment[0].y) < connectionTolerance;
       if (isLastConnectedToFirst) {
         const crossProduct = cross(
@@ -105,7 +161,19 @@ function simplifyCollinearSegments(outline, tolerance = 1e-10) {
           currentSegmentEnd,
           firstSegment[1]
         );
-        if (Math.abs(crossProduct) < tolerance) {
+        const segLen1 = Math.hypot(
+          currentSegmentEnd.x - currentSegmentStart.x,
+          currentSegmentEnd.y - currentSegmentStart.y
+        );
+        const segLen2 = Math.hypot(
+          firstSegment[1].x - currentSegmentEnd.x,
+          firstSegment[1].y - currentSegmentEnd.y
+        );
+        const scaledTolerance = Math.max(
+          tolerance,
+          tolerance * segLen1 * segLen2
+        );
+        if (Math.abs(crossProduct) < scaledTolerance) {
           simplified[0] = [currentSegmentStart, firstSegment[1]];
         } else {
           simplified.push(lastSegmentCandidate);
@@ -122,52 +190,65 @@ function simplifyCollinearSegments(outline, tolerance = 1e-10) {
   return simplified;
 }
 
-// lib/geometry/getComponentBounds.ts
-var getComponentBounds = (component, minGap = 0) => {
-  const bounds = {
-    minX: Infinity,
-    maxX: -Infinity,
-    minY: Infinity,
-    maxY: -Infinity
+// lib/parseFlattenPolygonLoops.ts
+function signedArea(points) {
+  let area = 0;
+  for (let i = 0; i < points.length; i++) {
+    const j = (i + 1) % points.length;
+    const pi = points[i];
+    const pj = points[j];
+    area += pi.x * pj.y;
+    area -= pj.x * pi.y;
+  }
+  return area / 2;
+}
+function extractFacePoints(face) {
+  const points = [];
+  let edge = face.first;
+  if (!edge) return points;
+  do {
+    const shp = edge.shape;
+    const ps = shp.start ?? shp.ps;
+    points.push({ x: ps.x, y: ps.y });
+    edge = edge.next;
+  } while (edge !== face.first);
+  return points;
+}
+function parseFlattenPolygonLoops(polygon) {
+  const obstacleFreeLoops = [];
+  const obstacleContainingLoops = [];
+  const faces = Array.from(polygon.faces);
+  for (const face of faces) {
+    const points = extractFacePoints(face);
+    if (points.length < 3) continue;
+    const area = signedArea(points);
+    if (area > 0) {
+      obstacleFreeLoops.push(points);
+    } else if (area < 0) {
+      obstacleContainingLoops.push(points);
+    }
+  }
+  return {
+    obstacleFreeLoops,
+    obstacleContainingLoops
   };
-  component.pads.forEach((pad) => {
-    const hw = pad.size.x / 2;
-    const hh = pad.size.y / 2;
-    const localCorners = [
-      { x: pad.offset.x - hw, y: pad.offset.y - hh },
-      { x: pad.offset.x + hw, y: pad.offset.y - hh },
-      { x: pad.offset.x + hw, y: pad.offset.y + hh },
-      { x: pad.offset.x - hw, y: pad.offset.y + hh }
-    ];
-    localCorners.forEach((corner) => {
-      const world = rotatePoint(
-        corner,
-        component.ccwRotationOffset * Math.PI / 180
-      );
-      const x = world.x + component.center.x;
-      const y = world.y + component.center.y;
-      bounds.minX = Math.min(bounds.minX, x);
-      bounds.maxX = Math.max(bounds.maxX, x);
-      bounds.minY = Math.min(bounds.minY, y);
-      bounds.maxY = Math.max(bounds.maxY, y);
-    });
-  });
+}
+function pointsToSegments(points) {
+  const segments = [];
+  for (let i = 0; i < points.length; i++) {
+    const p1 = points[i];
+    const p2 = points[(i + 1) % points.length];
+    segments.push([p1, p2]);
+  }
+  return segments;
+}
+function parseFlattenPolygonSegments(polygon) {
+  const loops = parseFlattenPolygonLoops(polygon);
   return {
-    minX: bounds.minX - minGap,
-    maxX: bounds.maxX + minGap,
-    minY: bounds.minY - minGap,
-    maxY: bounds.maxY + minGap
+    obstacleFreeLoops: loops.obstacleFreeLoops.map(pointsToSegments),
+    obstacleContainingLoops: loops.obstacleContainingLoops.map(pointsToSegments)
   };
-};
-
-// lib/geometry/combineBounds.ts
-var combineBounds = (bounds) => {
-  const minX = Math.min(...bounds.map((b) => b.minX));
-  const minY = Math.min(...bounds.map((b) => b.minY));
-  const maxX = Math.max(...bounds.map((b) => b.maxX));
-  const maxY = Math.max(...bounds.map((b) => b.maxY));
-  return { minX, minY, maxX, maxY };
-};
+}
 
 // lib/constructOutlinesFromPackedComponents.ts
 var createPadPolygons = (component, minGap) => {
@@ -247,40 +328,22 @@ var constructOutlinesFromPackedComponents = (components, opts = {}) => {
   const obstacleShapes = createObstaclePolygons(obstacles, minGap);
   allPadShapes.push(...obstacleShapes);
   if (allPadShapes.length === 0) return [];
-  const areaOfBox = (b) => Math.max(0, b.maxX - b.minX) * Math.max(0, b.maxY - b.minY);
-  const containsBox = (outer, inner, eps = 1e-9) => outer.minX - eps <= inner.minX && outer.minY - eps <= inner.minY && outer.maxX + eps >= inner.maxX && outer.maxY + eps >= inner.maxY;
-  const sortedByAreaDesc = [...allPadShapes].sort(
-    (a, b) => areaOfBox(b.bbox) - areaOfBox(a.bbox)
-  );
-  const filteredPadShapes = [];
-  for (const shape of sortedByAreaDesc) {
-    const w = shape.bbox.maxX - shape.bbox.minX;
-    const h = shape.bbox.maxY - shape.bbox.minY;
-    if (!(w > 1e-12 && h > 1e-12)) continue;
-    let contained = false;
-    for (const kept of filteredPadShapes) {
-      if (containsBox(kept.bbox, shape.bbox)) {
-        contained = true;
-        break;
-      }
-    }
-    if (!contained) filteredPadShapes.push(shape);
-  }
+  const filteredPadShapes = filterPadShapes(allPadShapes);
   const keptPadPolys = filteredPadShapes.map((s) => s.poly);
   let A = new Flatten.Polygon(
     new Flatten.Box(bounds.minX, bounds.minY, bounds.maxX, bounds.maxY)
   );
   const B = A.clone();
-  for (let i = 0; i < keptPadPolys.length; i++) {
+  for (const poly of keptPadPolys) {
     try {
-      A = Flatten.BooleanOperations.subtract(A, keptPadPolys[i]);
-    } catch (e) {
+      A = Flatten.BooleanOperations.subtract(A, poly);
+    } catch {
     }
   }
   let union = null;
   try {
     union = Flatten.BooleanOperations.subtract(B, A);
-  } catch (e) {
+  } catch {
     try {
       if (keptPadPolys.length > 0) {
         let U = keptPadPolys[0];
@@ -296,27 +359,36 @@ var constructOutlinesFromPackedComponents = (components, opts = {}) => {
       union = null;
     }
   }
-  const outlines = [];
-  for (const face of union.faces) {
-    if (face.isHole) continue;
-    const outline = [];
-    let edge = face.first;
-    if (!edge) continue;
-    do {
-      const shp = edge.shape;
-      const ps = shp.start ?? shp.ps;
-      const pe = shp.end ?? shp.pe;
-      outline.push([
-        { x: ps.x, y: ps.y },
-        { x: pe.x, y: pe.y }
-      ]);
-      edge = edge.next;
-    } while (edge !== face.first);
-    const simplifiedOutline = simplifyCollinearSegments(outline);
-    outlines.push(simplifiedOutline);
-  }
-  return outlines;
+  if (!union) return [];
+  const parsed = parseFlattenPolygonSegments(union);
+  const allOutlines = [
+    ...parsed.obstacleFreeLoops.map(simplifyCollinearSegments),
+    ...parsed.obstacleContainingLoops.map(simplifyCollinearSegments)
+  ];
+  return allOutlines.filter((outline) => outline.length >= 3);
 };
+function filterPadShapes(allPadShapes) {
+  const areaOfBox = (b) => Math.max(0, b.maxX - b.minX) * Math.max(0, b.maxY - b.minY);
+  const containsBox = (outer, inner, eps = 1e-9) => outer.minX - eps <= inner.minX && outer.minY - eps <= inner.minY && outer.maxX + eps >= inner.maxX && outer.maxY + eps >= inner.maxY;
+  const sortedByAreaDesc = [...allPadShapes].sort(
+    (a, b) => areaOfBox(b.bbox) - areaOfBox(a.bbox)
+  );
+  const filtered = [];
+  for (const shape of sortedByAreaDesc) {
+    const w = shape.bbox.maxX - shape.bbox.minX;
+    const h = shape.bbox.maxY - shape.bbox.minY;
+    if (!(w > 1e-12 && h > 1e-12)) continue;
+    let contained = false;
+    for (const kept of filtered) {
+      if (containsBox(kept.bbox, shape.bbox)) {
+        contained = true;
+        break;
+      }
+    }
+    if (!contained) filtered.push(shape);
+  }
+  return filtered;
+}
 
 // lib/OutlineSegmentCandidatePointSolver/OutlineSegmentCandidatePointSolver.ts
 import { clamp } from "@tscircuit/math-utils";
@@ -946,73 +1018,6 @@ var getColorForString = (string, alpha = 1) => {
   return `hsl(${hash % 360}, 100%, 50%, ${alpha})`;
 };
 
-// lib/geometry/pointInOutline.ts
-var EPS = 1e-9;
-function cross2(ax, ay, bx, by) {
-  return ax * by - ay * bx;
-}
-function isLeft(a, b, p) {
-  return cross2(b.x - a.x, b.y - a.y, p.x - a.x, p.y - a.y);
-}
-function pointOnSegment(p, a, b, eps = EPS) {
-  const area2 = isLeft(a, b, p);
-  if (Math.abs(area2) > eps) return false;
-  const minx = Math.min(a.x, b.x) - eps;
-  const maxx = Math.max(a.x, b.x) + eps;
-  const miny = Math.min(a.y, b.y) - eps;
-  const maxy = Math.max(a.y, b.y) + eps;
-  return p.x >= minx && p.x <= maxx && p.y >= miny && p.y <= maxy;
-}
-function pointInOutline(p, segments, rule = "even-odd") {
-  let minx = Infinity;
-  let miny = Infinity;
-  let maxx = -Infinity;
-  let maxy = -Infinity;
-  for (const s of segments) {
-    const [a, b] = s;
-    minx = Math.min(minx, a.x, b.x);
-    miny = Math.min(miny, a.y, b.y);
-    maxx = Math.max(maxx, a.x, b.x);
-    maxy = Math.max(maxy, a.y, b.y);
-  }
-  if (p.x < minx - EPS || p.x > maxx + EPS || p.y < miny - EPS || p.y > maxy + EPS) {
-    return "outside";
-  }
-  for (const s of segments) {
-    const [a, b] = s;
-    if (pointOnSegment(p, a, b)) return "boundary";
-  }
-  if (rule === "even-odd") {
-    let crossings = 0;
-    for (const s of segments) {
-      const [a, b] = s;
-      const ay = a.y;
-      const by = b.y;
-      const ax = a.x;
-      const bx = b.x;
-      const cond = ay <= p.y && p.y < by || by <= p.y && p.y < ay;
-      if (!cond) continue;
-      const dy = by - ay;
-      if (Math.abs(dy) < EPS) continue;
-      const t = (p.y - ay) / dy;
-      const xAtY = ax + t * (bx - ax);
-      if (xAtY > p.x + EPS) crossings++;
-    }
-    return crossings % 2 === 1 ? "inside" : "outside";
-  } else {
-    let winding = 0;
-    for (const s of segments) {
-      const [a, b] = s;
-      if (a.y <= p.y) {
-        if (b.y > p.y && isLeft(a, b, p) > EPS) winding++;
-      } else {
-        if (b.y <= p.y && isLeft(a, b, p) < -EPS) winding--;
-      }
-    }
-    return winding !== 0 ? "inside" : "outside";
-  }
-}
-
 // lib/OutlineSegmentCandidatePointSolver/getOutwardNormal.ts
 function getOutwardNormal(outlineSegment, ccwFullOutline) {
   const [p1, p2] = outlineSegment;
@@ -1026,29 +1031,6 @@ function getOutwardNormal(outlineSegment, ccwFullOutline) {
   const dirY = dy / len;
   const left = { x: -dirY, y: dirX };
   const right = { x: dirY, y: -dirX };
-  const mid = {
-    x: (p1.x + p2.x) / 2,
-    y: (p1.y + p2.y) / 2
-  };
-  const bbox = getOutlineBoundsWithMargin(ccwFullOutline);
-  const scale = Math.max(bbox.maxX - bbox.minX, bbox.maxY - bbox.minY) || 1;
-  const testDistance = Math.max(1e-4, 1e-3 * scale);
-  const testLeft = {
-    x: mid.x + left.x * testDistance,
-    y: mid.y + left.y * testDistance
-  };
-  const testRight = {
-    x: mid.x + right.x * testDistance,
-    y: mid.y + right.y * testDistance
-  };
-  const locLeft = pointInOutline(testLeft, ccwFullOutline);
-  if (locLeft === "outside") {
-    return left;
-  }
-  const locRight = pointInOutline(testRight, ccwFullOutline);
-  if (locRight === "outside") {
-    return right;
-  }
   const verts = [];
   if (ccwFullOutline.length > 0) {
     verts.push(ccwFullOutline[0][0]);
@@ -1056,7 +1038,7 @@ function getOutwardNormal(outlineSegment, ccwFullOutline) {
       verts.push(seg[1]);
     }
   }
-  const signedArea = (() => {
+  const signedArea2 = (() => {
     let a = 0;
     for (let i = 0; i < verts.length; i++) {
       const v1 = verts[i];
@@ -1065,35 +1047,12 @@ function getOutwardNormal(outlineSegment, ccwFullOutline) {
     }
     return a / 2;
   })();
-  if (Math.abs(signedArea) > 1e-12) {
-    return signedArea > 0 ? right : left;
+  const geometricOutward = signedArea2 > 0 ? right : left;
+  const isCW = signedArea2 < 0;
+  if (isCW) {
+    return { x: -geometricOutward.x, y: -geometricOutward.y };
   }
-  const center = {
-    x: (bbox.minX + bbox.maxX) / 2,
-    y: (bbox.minY + bbox.maxY) / 2
-  };
-  const away = { x: mid.x - center.x, y: mid.y - center.y };
-  const dotLeft = left.x * away.x + left.y * away.y;
-  const dotRight = right.x * away.x + right.y * away.y;
-  return dotRight >= dotLeft ? right : left;
-}
-function getOutlineBoundsWithMargin(ccwFullOutline, margin = 0) {
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  for (const [p1, p2] of ccwFullOutline) {
-    minX = Math.min(minX, p1.x, p2.x);
-    minY = Math.min(minY, p1.y, p2.y);
-    maxX = Math.max(maxX, p1.x, p2.x);
-    maxY = Math.max(maxY, p1.y, p2.y);
-  }
-  return {
-    minX: minX - margin,
-    minY: minY - margin,
-    maxX: maxX + margin,
-    maxY: maxY + margin
-  };
+  return geometricOutward;
 }
 
 // lib/LargestRectOutsideOutlineFromPointSolver.ts
@@ -1103,26 +1062,34 @@ var LargestRectOutsideOutlineFromPointSolver = class extends BaseSolver2 {
   origin;
   globalBounds;
   largestRect = null;
+  /**
+   * Mode for finding rectangles:
+   * - "outside": Find rect outside the polygon (for CCW obstacle boundaries)
+   * - "inside": Find rect inside the polygon (for CW free space pockets)
+   */
+  mode;
   constructor(params) {
     super();
     this.ccwFullOutline = params.ccwFullOutline;
     this.origin = params.origin;
     this.globalBounds = params.globalBounds;
+    this.mode = params.mode ?? "outside";
   }
   getConstructorParams() {
     return {
       ccwFullOutline: this.ccwFullOutline,
       origin: this.origin,
-      globalBounds: this.globalBounds
+      globalBounds: this.globalBounds,
+      mode: this.mode
     };
   }
   _setup() {
   }
   _step() {
-    this.largestRect = this.computeLargestRectOutside();
+    this.largestRect = this.computeLargestRect();
     this.solved = true;
   }
-  computeLargestRectOutside() {
+  computeLargestRect() {
     const edges = this.makeEdges(this.ccwFullOutline);
     const bounds = {
       x: this.globalBounds.minX,
@@ -1134,7 +1101,7 @@ var LargestRectOutsideOutlineFromPointSolver = class extends BaseSolver2 {
       edges,
       this.origin,
       bounds,
-      "outside"
+      this.mode
     );
   }
   almostEqual(a, b, eps = 1e-9) {
@@ -1196,6 +1163,9 @@ var LargestRectOutsideOutlineFromPointSolver = class extends BaseSolver2 {
       bx1,
       bx2
     );
+    if (mode === "inside") {
+      return inside;
+    }
     const outs = [];
     let prev = bx1;
     for (const [L, R] of inside) {
@@ -1460,6 +1430,9 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver3 {
   optimalPosition;
   irlsSolver;
   twoPhaseIrlsSolver;
+  largestRectBounds;
+  largestRectMidPoint;
+  largestRectOrigin;
   constructor(params) {
     super();
     this.outlineSegment = params.outlineSegment;
@@ -1529,19 +1502,36 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver3 {
         componentBounds.maxY - componentBounds.minY
       ) * 2 + this.minGap * 2
     });
+    this.largestRectMidPoint = {
+      x: (p1.x + p2.x) / 2,
+      y: (p1.y + p2.y) / 2
+    };
+    this.largestRectOrigin = {
+      x: this.largestRectMidPoint.x + outwardNormal.x * 1e-4,
+      y: this.largestRectMidPoint.y + outwardNormal.y * 1e-4
+    };
+    const outlinePoints = this.ccwFullOutline.flatMap(([p]) => p);
+    let signedArea2 = 0;
+    for (let i = 0; i < outlinePoints.length; i++) {
+      const p12 = outlinePoints[i];
+      const p22 = outlinePoints[(i + 1) % outlinePoints.length];
+      signedArea2 += p12.x * p22.y - p22.x * p12.y;
+    }
+    signedArea2 /= 2;
+    const isCW = signedArea2 < 0;
+    const rectSearchMode = isCW ? "inside" : "outside";
     const largestRectSolverParams = {
-      ccwFullOutline: this.ccwFullOutline.flatMap(([p]) => p),
+      ccwFullOutline: outlinePoints,
       globalBounds: packedComponentBoundsWithMargin,
-      origin: {
-        x: (p1.x + p2.x) / 2 + outwardNormal.x * 1e-4,
-        y: (p1.y + p2.y) / 2 + outwardNormal.y * 1e-4
-      }
+      origin: this.largestRectOrigin,
+      mode: rectSearchMode
     };
     const largestRectSolver = new LargestRectOutsideOutlineFromPointSolver(
       largestRectSolverParams
     );
     largestRectSolver.solve();
     const largestRectBounds = largestRectSolver.getLargestRectBounds();
+    this.largestRectBounds = largestRectBounds;
     const segmentNormAbs = {
       x: Math.abs(
         Math.sign(this.outlineSegment[1].x - this.outlineSegment[0].x)
@@ -1860,6 +1850,31 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver3 {
         label: "Viable Bounds"
       });
     }
+    if (this.largestRectBounds) {
+      graphics.rects.push({
+        center: {
+          x: (this.largestRectBounds.minX + this.largestRectBounds.maxX) / 2,
+          y: (this.largestRectBounds.minY + this.largestRectBounds.maxY) / 2
+        },
+        width: this.largestRectBounds.maxX - this.largestRectBounds.minX,
+        height: this.largestRectBounds.maxY - this.largestRectBounds.minY,
+        fill: "rgba(255,0,255,0.4)"
+      });
+    }
+    if (this.largestRectMidPoint) {
+      graphics.points.push({
+        ...this.largestRectMidPoint,
+        label: "Largest Rect Mid Point",
+        color: "rgba(128,0,255,1)"
+      });
+    }
+    if (this.largestRectOrigin) {
+      graphics.points.push({
+        ...this.largestRectOrigin,
+        label: "Largest Rect Origin",
+        color: "rgba(255,0,128,1)"
+      });
+    }
     if (this.viableOutlineSegment) {
       const [p1, p2] = this.viableOutlineSegment;
       graphics.lines.push({
@@ -2182,6 +2197,57 @@ var SingleComponentPackSolver = class extends BaseSolver4 {
         });
       }
     }
+    if (this.boundaryOutline && this.boundaryOutline.length >= 3) {
+      const boundarySegments = [];
+      for (let i = 0; i < this.boundaryOutline.length; i++) {
+        const p1 = this.boundaryOutline[i];
+        const p2 = this.boundaryOutline[(i + 1) % this.boundaryOutline.length];
+        boundarySegments.push([p1, p2]);
+      }
+      const boundaryOutlineIndex = this.outlines.length;
+      for (let i = 0; i < boundarySegments.length; i++) {
+        const segment = boundarySegments[i];
+        this.queuedOutlineSegments.push({
+          segment,
+          availableRotations: [...availableRotations],
+          segmentIndex: boundaryOutlineIndex * 1e3 + i,
+          ccwFullOutline: boundarySegments
+        });
+      }
+    }
+    let obstacleOutlineIndex = this.outlines.length + 1;
+    for (const obstacle of this.obstacles) {
+      const hw = obstacle.width / 2 + this.minGap;
+      const hh = obstacle.height / 2 + this.minGap;
+      const cx = obstacle.absoluteCenter.x;
+      const cy = obstacle.absoluteCenter.y;
+      const obstacleCorners = [
+        { x: cx - hw, y: cy - hh },
+        { x: cx + hw, y: cy - hh },
+        { x: cx + hw, y: cy + hh },
+        { x: cx - hw, y: cy + hh }
+      ];
+      const obstacleSegments = [
+        [obstacleCorners[0], obstacleCorners[1]],
+        // bottom
+        [obstacleCorners[1], obstacleCorners[2]],
+        // right
+        [obstacleCorners[2], obstacleCorners[3]],
+        // top
+        [obstacleCorners[3], obstacleCorners[0]]
+        // left
+      ];
+      for (let i = 0; i < obstacleSegments.length; i++) {
+        const segment = obstacleSegments[i];
+        this.queuedOutlineSegments.push({
+          segment,
+          availableRotations: [...availableRotations],
+          segmentIndex: obstacleOutlineIndex * 1e3 + i,
+          ccwFullOutline: obstacleSegments
+        });
+      }
+      obstacleOutlineIndex++;
+    }
     this.currentPhase = "segment_candidate";
     this.currentSegmentIndex = 0;
     this.currentRotationIndex = 0;
@@ -2568,26 +2634,26 @@ function getPolygonCentroid(points) {
     const sumY = points.reduce((sum, p) => sum + p.y, 0);
     return { x: sumX / points.length, y: sumY / points.length };
   }
-  let signedArea = 0;
+  let signedArea2 = 0;
   let cx = 0;
   let cy = 0;
   for (let i = 0; i < points.length; i++) {
     const p1 = points[i];
     const p2 = points[(i + 1) % points.length];
     const crossProduct = p1.x * p2.y - p2.x * p1.y;
-    signedArea += crossProduct;
+    signedArea2 += crossProduct;
     cx += (p1.x + p2.x) * crossProduct;
     cy += (p1.y + p2.y) * crossProduct;
   }
-  signedArea *= 0.5;
-  const area = Math.abs(signedArea);
+  signedArea2 *= 0.5;
+  const area = Math.abs(signedArea2);
   if (area < 1e-10) {
     const sumX = points.reduce((sum, p) => sum + p.x, 0);
     const sumY = points.reduce((sum, p) => sum + p.y, 0);
     return { x: sumX / points.length, y: sumY / points.length };
   }
-  cx /= 6 * signedArea;
-  cy /= 6 * signedArea;
+  cx /= 6 * signedArea2;
+  cy /= 6 * signedArea2;
   return { x: cx, y: cy };
 }
 
@@ -2606,8 +2672,14 @@ var PackSolver2 = class extends BaseSolver5 {
   }
   _setup() {
     const { components, packOrderStrategy, packFirst = [] } = this.packInput;
+    const validComponents = components.filter((component) => {
+      if (component.pads.length === 0) return false;
+      return component.pads.every(
+        (pad) => Number.isFinite(pad.size.x) && Number.isFinite(pad.size.y) && pad.size.x > 0 && pad.size.y > 0
+      );
+    });
     this.unpackedComponentQueue = sortComponentQueue({
-      components,
+      components: validComponents,
       packOrderStrategy,
       packFirst
     });

package/package.json

@@ -2,7 +2,7 @@
   "name": "calculate-packing",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.59",
+  "version": "0.0.61",
   "description": "Calculate a packing layout with support for different strategy configurations",
   "scripts": {
     "start": "cosmos",
@@ -22,7 +22,7 @@
     "@tscircuit/circuit-json-util": "^0.0.66",
     "@tscircuit/footprinter": "^0.0.203",
     "@tscircuit/math-utils": "^0.0.25",
-    "@tscircuit/solver-utils": "^0.0.3",
+    "@tscircuit/solver-utils": "^0.0.4",
     "@types/bun": "latest",
     "@types/react": "^19.1.8",
     "@types/react-dom": "^19.1.6",
@@ -35,6 +35,7 @@
     "react-cosmos": "^7.0.0",
     "react-cosmos-plugin-vite": "^7.0.0",
     "react-dom": "^19.1.0",
+    "stack-svgs": "^0.0.1",
     "tscircuit": "^0.0.693",
     "tsup": "^8.5.0",
     "vite": "^7.1.2"