calculate-packing 0.0.12 → 0.0.13

package/dist/index.js

@@ -1,92 +1,124 @@
-// lib/solver-utils/BaseSolver.ts
-var BaseSolver = class {
-  MAX_ITERATIONS = 1e3;
-  solved = false;
-  failed = false;
-  iterations = 0;
-  progress = 0;
-  error = null;
-  activeSubSolver;
-  failedSubSolvers;
-  timeToSolve;
-  stats = {};
-  _setupDone = false;
-  setup() {
-    if (this._setupDone) return;
-    this._setup();
-    this._setupDone = true;
-  }
-  /** DO NOT OVERRIDE! Override _step() instead */
-  step() {
-    if (!this._setupDone) {
-      this.setup();
-    }
-    if (this.solved) return;
-    if (this.failed) return;
-    this.iterations++;
-    try {
-      this._step();
-    } catch (e) {
-      this.error = `${this.constructor.name} error: ${e}`;
-      console.error(this.error);
-      this.failed = true;
-      throw e;
-    }
-    if (!this.solved && this.iterations > this.MAX_ITERATIONS) {
-      this.tryFinalAcceptance();
-    }
-    if (!this.solved && this.iterations > this.MAX_ITERATIONS) {
-      this.error = `${this.constructor.name} ran out of iterations`;
-      console.error(this.error);
-      this.failed = true;
-    }
-    if ("computeProgress" in this) {
-      this.progress = this.computeProgress();
+// lib/PackSolver/checkOverlapWithPackedComponents.ts
+function checkOverlapWithPackedComponents({
+  component,
+  packedComponents,
+  minGap
+}) {
+  for (const componentPad of component.pads) {
+    for (const packedComponent of packedComponents) {
+      for (const packedPad of packedComponent.pads) {
+        const comp1Bounds = {
+          left: componentPad.absoluteCenter.x - componentPad.size.x / 2,
+          right: componentPad.absoluteCenter.x + componentPad.size.x / 2,
+          bottom: componentPad.absoluteCenter.y - componentPad.size.y / 2,
+          top: componentPad.absoluteCenter.y + componentPad.size.y / 2
+        };
+        const comp2Bounds = {
+          left: packedPad.absoluteCenter.x - packedPad.size.x / 2,
+          right: packedPad.absoluteCenter.x + packedPad.size.x / 2,
+          bottom: packedPad.absoluteCenter.y - packedPad.size.y / 2,
+          top: packedPad.absoluteCenter.y + packedPad.size.y / 2
+        };
+        const xOverlap = comp1Bounds.right > comp2Bounds.left && comp2Bounds.right > comp1Bounds.left;
+        const yOverlap = comp1Bounds.top > comp2Bounds.bottom && comp2Bounds.top > comp1Bounds.bottom;
+        if (xOverlap && yOverlap) {
+          return true;
+        }
+        if (!xOverlap || !yOverlap) {
+          const xGap = xOverlap ? 0 : Math.min(
+            Math.abs(comp1Bounds.left - comp2Bounds.right),
+            Math.abs(comp2Bounds.left - comp1Bounds.right)
+          );
+          const yGap = yOverlap ? 0 : Math.min(
+            Math.abs(comp1Bounds.bottom - comp2Bounds.top),
+            Math.abs(comp2Bounds.bottom - comp1Bounds.top)
+          );
+          const actualGap = Math.max(xGap, yGap);
+          if (actualGap < minGap) {
+            return true;
+          }
+        }
+      }
     }
   }
-  _setup() {
-  }
-  _step() {
-  }
-  getConstructorParams() {
-    throw new Error("getConstructorParams not implemented");
-  }
-  solve() {
-    const startTime = Date.now();
-    while (!this.solved && !this.failed) {
-      this.step();
+  return false;
+}
+
+// lib/math/computeNearestPointOnSegmentForSegmentSet.ts
+var sub = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });
+var add = (a, b) => ({ x: a.x + b.x, y: a.y + b.y });
+var mul = (a, s) => ({ x: a.x * s, y: a.y * s });
+var dot = (a, b) => a.x * b.x + a.y * b.y;
+var clamp = (v, lo = 0, hi = 1) => Math.max(lo, Math.min(hi, v));
+function closestPointOnSegAToSegB(segA, segB) {
+  const [p, q] = segA;
+  const [r, s] = segB;
+  const u = sub(q, p);
+  const v = sub(s, r);
+  const w0 = sub(p, r);
+  const a = dot(u, u);
+  const b = dot(u, v);
+  const c = dot(v, v);
+  const d = dot(u, w0);
+  const e = dot(v, w0);
+  const EPS = 1e-12;
+  const D = a * c - b * b;
+  let sN;
+  let tN;
+  let sD = D;
+  let tD = D;
+  if (D < EPS) {
+    sN = 0;
+    sD = 1;
+    tN = e;
+    tD = c;
+  } else {
+    sN = b * e - c * d;
+    tN = a * e - b * d;
+    if (sN < 0) {
+      sN = 0;
+      tN = e;
+      tD = c;
+    } else if (sN > sD) {
+      sN = sD;
+      tN = e + b;
+      tD = c;
     }
-    const endTime = Date.now();
-    this.timeToSolve = endTime - startTime;
-  }
-  visualize() {
-    return {
-      lines: [],
-      points: [],
-      rects: [],
-      circles: []
-    };
   }
-  /**
-   * Called when the solver is about to fail, but we want to see if we have an
-   * "acceptable" or "passable" solution. Mostly used for optimizers that
-   * have an aggressive early stopping criterion.
-   */
-  tryFinalAcceptance() {
+  if (tN < 0) {
+    tN = 0;
+    sN = clamp(-d, 0, a);
+    sD = a;
+  } else if (tN > tD) {
+    tN = tD;
+    sN = clamp(-d + b, 0, a);
+    sD = a;
   }
-  /**
-   * A lightweight version of the visualize method that can be used to stream
-   * progress
-   */
-  preview() {
-    return {
-      lines: [],
-      points: [],
-      rects: [],
-      circles: []
-    };
+  const sParam = sD > EPS ? sN / sD : 0;
+  const closestA = add(p, mul(u, sParam));
+  const tParam = tD > EPS ? tN / tD : 0;
+  const closestB = add(r, mul(v, tParam));
+  const diff = sub(closestA, closestB);
+  return { pointA: closestA, paramA: sParam, dist2: dot(diff, diff) };
+}
+function computeNearestPointOnSegmentForSegmentSet(segmentA, segmentSet) {
+  if (!segmentSet.length)
+    throw new Error("segmentSet must contain at least one segment");
+  let bestPoint = segmentA[0];
+  let bestDist2 = Number.POSITIVE_INFINITY;
+  for (const segB of segmentSet) {
+    const { pointA, dist2 } = closestPointOnSegAToSegB(segmentA, segB);
+    if (dist2 < bestDist2) {
+      bestDist2 = dist2;
+      bestPoint = pointA;
+      if (bestDist2 === 0) break;
+    }
   }
-};
+  return { nearestPoint: bestPoint, dist: Math.sqrt(bestDist2) };
+}
+
+// lib/constructOutlinesFromPackedComponents.ts
+import Flatten from "@flatten-js/core";
 
 // lib/math/rotatePoint.ts
 var rotatePoint = (point, angle, origin = { x: 0, y: 0 }) => {
@@ -118,7 +150,10 @@ var getComponentBounds = (component, minGap = 0) => {
       { x: pad.offset.x - hw, y: pad.offset.y + hh }
     ];
     localCorners.forEach((corner) => {
-      const world = rotatePoint(corner, component.ccwRotationOffset);
+      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);
@@ -136,7 +171,6 @@ var getComponentBounds = (component, minGap = 0) => {
 };
 
 // lib/constructOutlinesFromPackedComponents.ts
-import Flatten from "@flatten-js/core";
 var constructOutlinesFromPackedComponents = (components, opts = {}) => {
   const { minGap = 0 } = opts;
   if (components.length === 0) return [];
@@ -175,6 +209,107 @@ var constructOutlinesFromPackedComponents = (components, opts = {}) => {
   return outlines;
 };
 
+// lib/PackSolver/computeSumDistanceForPosition.ts
+function computeSumDistanceForPosition({
+  component,
+  position,
+  targetNetworkId,
+  packedComponents,
+  useSquaredDistance = false
+}) {
+  const componentPadsOnNetwork = component.pads.filter(
+    (pad) => pad.networkId === targetNetworkId
+  );
+  if (componentPadsOnNetwork.length === 0) return 0;
+  const packedPadsOnNetwork = packedComponents.flatMap(
+    (component2) => component2.pads.filter((pad) => pad.networkId === targetNetworkId)
+  );
+  if (packedPadsOnNetwork.length === 0) return 0;
+  let sumDistance = 0;
+  for (const componentPad of componentPadsOnNetwork) {
+    const padPosition = {
+      x: position.x + componentPad.offset.x,
+      y: position.y + componentPad.offset.y
+    };
+    let minDistance = Number.POSITIVE_INFINITY;
+    for (const packedPad of packedPadsOnNetwork) {
+      const dx = padPosition.x - packedPad.absoluteCenter.x;
+      const dy = padPosition.y - packedPad.absoluteCenter.y;
+      const distance = useSquaredDistance ? dx * dx + dy * dy : Math.hypot(dx, dy);
+      if (distance < minDistance) {
+        minDistance = distance;
+      }
+    }
+    sumDistance += minDistance === Number.POSITIVE_INFINITY ? 0 : minDistance;
+  }
+  return sumDistance;
+}
+
+// lib/PackSolver/findOptimalPointOnSegment.ts
+function findOptimalPointOnSegment({
+  p1,
+  p2,
+  component,
+  networkId,
+  packedComponents,
+  useSquaredDistance = false
+}) {
+  const candidatePoints = [];
+  const tolerance = 1e-6;
+  let left = 0;
+  let right = 1;
+  const interpolatePoint = (t) => ({
+    x: p1.x + t * (p2.x - p1.x),
+    y: p1.y + t * (p2.y - p1.y)
+  });
+  const evaluateDistance = (t) => {
+    const point = interpolatePoint(t);
+    const distance = computeSumDistanceForPosition({
+      component,
+      position: point,
+      targetNetworkId: networkId,
+      packedComponents,
+      useSquaredDistance
+    });
+    candidatePoints.push({
+      ...point,
+      networkId,
+      distance
+    });
+    return distance;
+  };
+  while (right - left > tolerance) {
+    const leftThird = left + (right - left) / 3;
+    const rightThird = right - (right - left) / 3;
+    const leftDistance = evaluateDistance(leftThird);
+    const rightDistance = evaluateDistance(rightThird);
+    if (leftDistance > rightDistance) {
+      left = leftThird;
+    } else {
+      right = rightThird;
+    }
+  }
+  const optimalT = (left + right) / 2;
+  const optimalPoint = interpolatePoint(optimalT);
+  const optimalDistance = computeSumDistanceForPosition({
+    component,
+    position: optimalPoint,
+    targetNetworkId: networkId,
+    packedComponents,
+    useSquaredDistance
+  });
+  candidatePoints.push({
+    ...optimalPoint,
+    networkId,
+    distance: optimalDistance
+  });
+  return {
+    point: optimalPoint,
+    distance: optimalDistance,
+    candidatePoints
+  };
+}
+
 // lib/testing/createColorMapFromStrings.ts
 var createColorMapFromStrings = (strings) => {
   const colorMap = {};
@@ -205,7 +340,7 @@ var getGraphicsFromPackOutput = (packOutput) => {
       fill: "rgba(0,0,0,0.25)",
       label: [
         component.componentId,
-        `ccwRotationOffset: ${(component.ccwRotationOffset / Math.PI * 180).toFixed(1)}`
+        `ccwRotationOffset: ${component.ccwRotationOffset.toFixed(1)}\xB0`
       ].join("\n")
     };
     rects.push(rect);
@@ -241,20 +376,6 @@ var getGraphicsFromPackOutput = (packOutput) => {
   };
 };
 
-// lib/PackSolver/setPackedComponentPadCenters.ts
-var setPackedComponentPadCenters = (packedComponent) => {
-  packedComponent.pads = packedComponent.pads.map((pad) => ({
-    ...pad,
-    absoluteCenter: (() => {
-      const rotated = rotatePoint(pad.offset, packedComponent.ccwRotationOffset);
-      return {
-        x: packedComponent.center.x + rotated.x,
-        y: packedComponent.center.y + rotated.y
-      };
-    })()
-  }));
-};
-
 // lib/PackSolver/getSegmentsFromPad.ts
 var getSegmentsFromPad = (pad, { padding = 0 } = {}) => {
   const segments = [];
@@ -279,408 +400,494 @@ var getSegmentsFromPad = (pad, { padding = 0 } = {}) => {
   return segments;
 };
 
-// lib/math/computeNearestPointOnSegmentForSegmentSet.ts
-var sub = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });
-var add = (a, b) => ({ x: a.x + b.x, y: a.y + b.y });
-var mul = (a, s) => ({ x: a.x * s, y: a.y * s });
-var dot = (a, b) => a.x * b.x + a.y * b.y;
-var clamp = (v, lo = 0, hi = 1) => Math.max(lo, Math.min(hi, v));
-function closestPointOnSegAToSegB(segA, segB) {
-  const [p, q] = segA;
-  const [r, s] = segB;
-  const u = sub(q, p);
-  const v = sub(s, r);
-  const w0 = sub(p, r);
-  const a = dot(u, u);
-  const b = dot(u, v);
-  const c = dot(v, v);
-  const d = dot(u, w0);
-  const e = dot(v, w0);
-  const EPS = 1e-12;
-  const D = a * c - b * b;
-  let sN;
-  let tN;
-  let sD = D;
-  let tD = D;
-  if (D < EPS) {
-    sN = 0;
-    sD = 1;
-    tN = e;
-    tD = c;
-  } else {
-    sN = b * e - c * d;
-    tN = a * e - b * d;
-    if (sN < 0) {
-      sN = 0;
-      tN = e;
-      tD = c;
-    } else if (sN > sD) {
-      sN = sD;
-      tN = e + b;
-      tD = c;
-    }
+// lib/PackSolver/computeGlobalCenter.ts
+function computeGlobalCenter(packedComponents) {
+  if (!packedComponents.length) return { x: 0, y: 0 };
+  const sum = packedComponents.reduce(
+    (acc, component) => ({
+      x: acc.x + component.center.x,
+      y: acc.y + component.center.y
+    }),
+    { x: 0, y: 0 }
+  );
+  return {
+    x: sum.x / packedComponents.length,
+    y: sum.y / packedComponents.length
+  };
+}
+
+// lib/PackSolver/findBestPointForDisconnected.ts
+function findBestPointForDisconnected({
+  outlines,
+  direction,
+  packedComponents
+}) {
+  const points = outlines.flatMap(
+    (outline) => outline.map(([p1, p2]) => ({
+      x: (p1.x + p2.x) / 2,
+      y: (p1.y + p2.y) / 2
+    }))
+  );
+  if (!points.length) return { x: 0, y: 0 };
+  if (direction !== "nearest_to_center") {
+    const extreme = direction === "left" || direction === "down" ? Math.min : Math.max;
+    const key = direction === "left" || direction === "right" ? "x" : "y";
+    const target = extreme(...points.map((p) => p[key]));
+    return points.find((p) => p[key] === target);
   }
-  if (tN < 0) {
-    tN = 0;
-    sN = clamp(-d, 0, a);
-    sD = a;
-  } else if (tN > tD) {
-    tN = tD;
-    sN = clamp(-d + b, 0, a);
-    sD = a;
-  }
-  const sParam = sD > EPS ? sN / sD : 0;
-  const closestA = add(p, mul(u, sParam));
-  const tParam = tD > EPS ? tN / tD : 0;
-  const closestB = add(r, mul(v, tParam));
-  const diff = sub(closestA, closestB);
-  return { pointA: closestA, paramA: sParam, dist2: dot(diff, diff) };
-}
-function computeNearestPointOnSegmentForSegmentSet(segmentA, segmentSet) {
-  if (!segmentSet.length)
-    throw new Error("segmentSet must contain at least one segment");
-  let bestPoint = segmentA[0];
-  let bestDist2 = Number.POSITIVE_INFINITY;
-  for (const segB of segmentSet) {
-    const { pointA, dist2 } = closestPointOnSegAToSegB(segmentA, segB);
-    if (dist2 < bestDist2) {
-      bestDist2 = dist2;
-      bestPoint = pointA;
-      if (bestDist2 === 0) break;
-    }
-  }
-  return { nearestPoint: bestPoint, dist: Math.sqrt(bestDist2) };
+  const center = computeGlobalCenter(packedComponents);
+  return points.reduce(
+    (best, point) => Math.hypot(point.x - center.x, point.y - center.y) < Math.hypot(best.x - center.x, best.y - center.y) ? point : best
+  );
 }
 
-// lib/PackSolver/PackSolver.ts
-import { computeDistanceBetweenBoxes } from "@tscircuit/math-utils";
-
-// lib/PackSolver/translationOptimizer.ts
-function computeTranslationBounds(component, initialCenter, packedComponents, minGap) {
-  const componentBounds = getComponentBounds(component, 0);
-  const componentWidth = componentBounds.maxX - componentBounds.minX;
-  const componentHeight = componentBounds.maxY - componentBounds.minY;
-  let minX = Number.NEGATIVE_INFINITY;
-  let maxX = Number.POSITIVE_INFINITY;
-  let minY = Number.NEGATIVE_INFINITY;
-  let maxY = Number.POSITIVE_INFINITY;
-  for (const packedComp of packedComponents) {
-    const packedBounds = getComponentBounds(packedComp, 0);
-    const packedWidth = packedBounds.maxX - packedBounds.minX;
-    const packedHeight = packedBounds.maxY - packedBounds.minY;
-    const minCenterDistanceX = minGap + (componentWidth + packedWidth) / 2;
-    const minCenterDistanceY = minGap + (componentHeight + packedHeight) / 2;
-    const packedCenterX = packedComp.center.x;
-    const packedCenterY = packedComp.center.y;
-    const leftBound = packedCenterX - minCenterDistanceX;
-    const rightBound = packedCenterX + minCenterDistanceX;
-    const bottomBound = packedCenterY - minCenterDistanceY;
-    const topBound = packedCenterY + minCenterDistanceY;
-    if (Math.abs(packedCenterX - initialCenter.x) > Math.abs(packedCenterY - initialCenter.y)) {
-      if (packedCenterX < initialCenter.x) {
-        minX = Math.max(minX, rightBound);
-      } else {
-        maxX = Math.min(maxX, leftBound);
-      }
-    } else {
-      if (packedCenterY < initialCenter.y) {
-        minY = Math.max(minY, topBound);
-      } else {
-        maxY = Math.min(maxY, bottomBound);
+// lib/PackSolver/setPackedComponentPadCenters.ts
+var setPackedComponentPadCenters = (packedComponent) => {
+  packedComponent.pads = packedComponent.pads.map((pad) => {
+    const rotated = rotatePoint(
+      pad.offset,
+      packedComponent.ccwRotationOffset * Math.PI / 180
+    );
+    const normalizedRotation = (packedComponent.ccwRotationOffset % 360 + 360) % 360;
+    const shouldSwapDimensions = normalizedRotation === 90 || normalizedRotation === 270;
+    return {
+      ...pad,
+      size: shouldSwapDimensions ? { x: pad.size.y, y: pad.size.x } : pad.size,
+      // Keep original dimensions for 0°/180° rotations
+      absoluteCenter: {
+        x: packedComponent.center.x + rotated.x,
+        y: packedComponent.center.y + rotated.y
       }
+    };
+  });
+};
+
+// lib/PackSolver/placeComponentAtPoint.ts
+function placeComponentAtPoint({
+  component,
+  point,
+  candidateAngles,
+  checkOverlap
+}) {
+  const evaluatedPositionShadows = [];
+  for (const angle of candidateAngles) {
+    const pads = component.pads.map((pad) => {
+      const rotatedOffset = rotatePoint(pad.offset, angle * Math.PI / 180);
+      const normalizedRotation = (angle % 360 + 360) % 360;
+      const shouldSwapDimensions = normalizedRotation === 90 || normalizedRotation === 270;
+      return {
+        ...pad,
+        size: shouldSwapDimensions ? { x: pad.size.y, y: pad.size.x } : pad.size,
+        absoluteCenter: {
+          x: point.x + rotatedOffset.x,
+          y: point.y + rotatedOffset.y
+        }
+      };
+    });
+    const candidate = {
+      ...component,
+      center: point,
+      ccwRotationOffset: angle,
+      pads
+    };
+    evaluatedPositionShadows.push(candidate);
+    if (!checkOverlap(candidate)) {
+      Object.assign(component, candidate);
+      setPackedComponentPadCenters(component);
+      return evaluatedPositionShadows;
     }
   }
-  const maxTranslation = 5;
-  minX = Math.max(minX, initialCenter.x - maxTranslation);
-  maxX = Math.min(maxX, initialCenter.x + maxTranslation);
-  minY = Math.max(minY, initialCenter.y - maxTranslation);
-  maxY = Math.min(maxY, initialCenter.y + maxTranslation);
-  return { minX, maxX, minY, maxY };
+  component.center = point;
+  component.ccwRotationOffset = 0;
+  setPackedComponentPadCenters(component);
+  return evaluatedPositionShadows;
 }
-function calculateSumDistance(component, candidateCenter, packedComponents) {
-  const packedPads = packedComponents.flatMap((c) => c.pads);
-  const connectedPads = component.pads.filter(
-    (pad) => packedPads.some((pp) => pp.networkId === pad.networkId)
-  );
-  if (connectedPads.length === 0) return 0;
-  let sumDistance = 0;
-  for (const pad of connectedPads) {
-    const padAbsolutePos = {
-      x: candidateCenter.x + pad.offset.x,
-      y: candidateCenter.y + pad.offset.y
-    };
-    const sameNetPads = packedPads.filter(
-      (pp) => pp.networkId === pad.networkId
-    );
-    let minDistance = Number.POSITIVE_INFINITY;
-    for (const packedPad of sameNetPads) {
-      const distance = Math.hypot(
-        padAbsolutePos.x - packedPad.absoluteCenter.x,
-        padAbsolutePos.y - packedPad.absoluteCenter.y
+
+// lib/PackSolver/placeComponentDisconnected.ts
+function placeComponentDisconnected({
+  component,
+  outlines,
+  direction,
+  packedComponents,
+  candidateAngles,
+  checkOverlap
+}) {
+  const targetPoint = findBestPointForDisconnected({
+    outlines,
+    direction,
+    packedComponents
+  });
+  return placeComponentAtPoint({
+    component,
+    point: targetPoint,
+    candidateAngles,
+    checkOverlap
+  });
+}
+
+// lib/PackSolver/RotationSelector.ts
+function selectOptimalRotation(options) {
+  const {
+    component,
+    candidatePoints,
+    packedComponents,
+    minGap,
+    useSquaredDistance,
+    checkOverlap
+  } = options;
+  const candidateAngles = getCandidateAngles(component);
+  let globalBestCandidate = null;
+  for (const angle of candidateAngles) {
+    let bestForThisRotation = null;
+    const packedPads = packedComponents.flatMap((c) => c.pads);
+    for (const candidatePoint of candidatePoints) {
+      const networkId = candidatePoint.networkId;
+      const componentPadsOnNetwork = component.pads.filter(
+        (p) => p.networkId === networkId
       );
-      if (distance < minDistance) {
-        minDistance = distance;
+      if (componentPadsOnNetwork.length > 0) {
+        const firstPad = componentPadsOnNetwork[0];
+        const rotatedPadOffset = rotatePoint(
+          firstPad.offset,
+          angle * Math.PI / 180
+        );
+        const initialCenter = {
+          x: candidatePoint.x - rotatedPadOffset.x,
+          y: candidatePoint.y - rotatedPadOffset.y
+        };
+        const tempComponent = {
+          ...component,
+          center: initialCenter,
+          ccwRotationOffset: (angle % 360 + 360) % 360,
+          pads: component.pads.map((p) => ({
+            ...p,
+            absoluteCenter: { x: 0, y: 0 }
+            // Will be set by setPackedComponentPadCenters
+          }))
+        };
+        const transformedPads = tempComponent.pads.map((p) => {
+          const rotatedOffset = rotatePoint(p.offset, angle * Math.PI / 180);
+          const normalizedRotation = (angle % 360 + 360) % 360;
+          const shouldSwapDimensions = normalizedRotation === 90 || normalizedRotation === 270;
+          return {
+            ...p,
+            size: shouldSwapDimensions ? { x: p.size.y, y: p.size.x } : p.size,
+            absoluteCenter: {
+              x: initialCenter.x + rotatedOffset.x,
+              y: initialCenter.y + rotatedOffset.y
+            }
+          };
+        });
+        tempComponent.pads = transformedPads;
+        if (!checkOverlap(tempComponent)) {
+          let cost = 0;
+          for (const tp of transformedPads) {
+            const sameNetPads = packedPads.filter(
+              (pp) => pp.networkId === tp.networkId
+            );
+            if (!sameNetPads.length) continue;
+            let bestD = Infinity;
+            for (const pp of sameNetPads) {
+              const dx = tp.absoluteCenter.x - pp.absoluteCenter.x;
+              const dy = tp.absoluteCenter.y - pp.absoluteCenter.y;
+              const d = useSquaredDistance ? dx * dx + dy * dy : Math.hypot(dx, dy);
+              if (d < bestD) bestD = d;
+            }
+            cost += bestD === Infinity ? 0 : bestD;
+          }
+          if (!bestForThisRotation || cost < bestForThisRotation.cost) {
+            bestForThisRotation = {
+              center: initialCenter,
+              angle: (angle % 360 + 360) % 360,
+              cost,
+              pads: component.pads.map((p) => ({
+                ...p,
+                absoluteCenter: { x: 0, y: 0 }
+              }))
+              // Return original pads structure
+            };
+          }
+        }
+      }
+      const centerTrial = {
+        ...component,
+        center: { x: candidatePoint.x, y: candidatePoint.y },
+        ccwRotationOffset: (angle % 360 + 360) % 360,
+        pads: component.pads.map((p) => {
+          const rotatedOffset = rotatePoint(p.offset, angle * Math.PI / 180);
+          const normalizedRotation = (angle % 360 + 360) % 360;
+          const shouldSwapDimensions = normalizedRotation === 90 || normalizedRotation === 270;
+          return {
+            ...p,
+            size: shouldSwapDimensions ? { x: p.size.y, y: p.size.x } : p.size,
+            absoluteCenter: {
+              x: candidatePoint.x + rotatedOffset.x,
+              y: candidatePoint.y + rotatedOffset.y
+            }
+          };
+        })
+      };
+      if (!checkOverlap(centerTrial)) {
+        let centerCost = 0;
+        for (const tp of centerTrial.pads) {
+          const sameNetPads = packedPads.filter(
+            (pp) => pp.networkId === tp.networkId
+          );
+          if (!sameNetPads.length) continue;
+          let bestD = Infinity;
+          for (const pp of sameNetPads) {
+            const dx = tp.absoluteCenter.x - pp.absoluteCenter.x;
+            const dy = tp.absoluteCenter.y - pp.absoluteCenter.y;
+            const d = useSquaredDistance ? dx * dx + dy * dy : Math.hypot(dx, dy);
+            if (d < bestD) bestD = d;
+          }
+          centerCost += bestD === Infinity ? 0 : bestD;
+        }
+        if (!bestForThisRotation || centerCost < bestForThisRotation.cost) {
+          bestForThisRotation = {
+            center: centerTrial.center,
+            angle: (angle % 360 + 360) % 360,
+            cost: centerCost,
+            pads: component.pads.map((p) => ({
+              ...p,
+              absoluteCenter: { x: 0, y: 0 }
+            }))
+            // Return original pads structure
+          };
+        }
       }
     }
-    sumDistance += minDistance === Number.POSITIVE_INFINITY ? 0 : minDistance;
-  }
-  return sumDistance;
-}
-function checkOverlap(component, candidateCenter, packedComponents, minGap) {
-  const tempComponent = {
-    ...component,
-    center: candidateCenter,
-    pads: component.pads.map((p) => ({
-      ...p,
-      absoluteCenter: {
-        x: candidateCenter.x + p.offset.x,
-        y: candidateCenter.y + p.offset.y
+    if (bestForThisRotation && (!globalBestCandidate || bestForThisRotation.cost < globalBestCandidate.cost)) {
+      if (component.componentId === "C6") {
+        console.log(
+          `C6 rotation ${angle}\xB0: best cost=${bestForThisRotation.cost.toFixed(3)} ${!globalBestCandidate ? "[FIRST ROTATION]" : "[NEW BEST ROTATION]"}`
+        );
       }
-    }))
-  };
-  const componentBounds = getComponentBounds(tempComponent, 0);
-  const componentBox = {
-    center: {
-      x: (componentBounds.minX + componentBounds.maxX) / 2,
-      y: (componentBounds.minY + componentBounds.maxY) / 2
-    },
-    width: componentBounds.maxX - componentBounds.minX,
-    height: componentBounds.maxY - componentBounds.minY
-  };
-  for (const packedComp of packedComponents) {
-    const packedBounds = getComponentBounds(packedComp, 0);
-    const packedBox = {
-      center: {
-        x: (packedBounds.minX + packedBounds.maxX) / 2,
-        y: (packedBounds.minY + packedBounds.maxY) / 2
-      },
-      width: packedBounds.maxX - packedBounds.minX,
-      height: packedBounds.maxY - packedBounds.minY
-    };
-    const centerDistance = Math.hypot(
-      componentBox.center.x - packedBox.center.x,
-      componentBox.center.y - packedBox.center.y
-    );
-    const minRequiredDistance = minGap + (componentBox.width + packedBox.width) / 2;
-    if (centerDistance < minRequiredDistance) {
-      return true;
+      globalBestCandidate = bestForThisRotation;
+    } else if (bestForThisRotation && component.componentId === "C6") {
+      console.log(
+        `C6 rotation ${angle}\xB0: cost=${bestForThisRotation.cost.toFixed(3)} [WORSE THAN ${globalBestCandidate?.cost.toFixed(3)}]`
+      );
     }
   }
-  return false;
-}
-function clampToBounds(p, b) {
-  return {
-    x: Math.min(Math.max(p.x, b.minX), b.maxX),
-    y: Math.min(Math.max(p.y, b.minY), b.maxY)
-  };
+  return globalBestCandidate;
 }
-function dist(a, b) {
-  const dx = a.x - b.x;
-  const dy = a.y - b.y;
-  return Math.hypot(dx, dy);
+function getCandidateAngles(c) {
+  return (c.availableRotationDegrees ?? [0, 90, 180, 270]).map((d) => d % 360);
 }
-function backtrackToFeasible(from, to, isFeasible, maxTrials = 20) {
-  let lo = 0;
-  let hi = 1;
-  let best = null;
-  for (let i = 0; i < maxTrials; i++) {
-    const t = (lo + hi) / 2;
-    const cand = {
-      x: from.x + (to.x - from.x) * t,
-      y: from.y + (to.y - from.y) * t
-    };
-    if (isFeasible(cand)) {
-      best = cand;
-      lo = t;
-    } else {
-      hi = t;
+
+// lib/PackSolver/sortComponentQueue.ts
+function sortComponentQueue({
+  components,
+  packOrderStrategy,
+  packFirst = []
+}) {
+  const packFirstMap = /* @__PURE__ */ new Map();
+  packFirst.forEach((componentId, index) => {
+    packFirstMap.set(componentId, index);
+  });
+  return [...components].sort((a, b) => {
+    const aPackFirstIndex = packFirstMap.get(a.componentId);
+    const bPackFirstIndex = packFirstMap.get(b.componentId);
+    if (aPackFirstIndex !== void 0 && bPackFirstIndex !== void 0) {
+      return aPackFirstIndex - bPackFirstIndex;
     }
-  }
-  return best ?? from;
+    if (aPackFirstIndex !== void 0) return -1;
+    if (bPackFirstIndex !== void 0) return 1;
+    if (packOrderStrategy === "largest_to_smallest") {
+      return b.pads.length - a.pads.length;
+    }
+    return a.pads.length - b.pads.length;
+  });
 }
-function geometricMedianConstrained(targets, start, bounds, maxIter = 100, tol = 1e-4) {
-  let c = clampToBounds(start, bounds);
-  const eps = 1e-9;
-  for (let k = 0; k < maxIter; k++) {
-    for (const p of targets) {
-      if (dist(c, p) <= eps) return clampToBounds(p, bounds);
+
+// lib/solver-utils/BaseSolver.ts
+var BaseSolver = class {
+  MAX_ITERATIONS = 1e3;
+  solved = false;
+  failed = false;
+  iterations = 0;
+  progress = 0;
+  error = null;
+  activeSubSolver;
+  failedSubSolvers;
+  timeToSolve;
+  stats = {};
+  _setupDone = false;
+  setup() {
+    if (this._setupDone) return;
+    this._setup();
+    this._setupDone = true;
+  }
+  /** DO NOT OVERRIDE! Override _step() instead */
+  step() {
+    if (!this._setupDone) {
+      this.setup();
+    }
+    if (this.solved) return;
+    if (this.failed) return;
+    this.iterations++;
+    try {
+      this._step();
+    } catch (e) {
+      this.error = `${this.constructor.name} error: ${e}`;
+      console.error(this.error);
+      this.failed = true;
+      throw e;
+    }
+    if (!this.solved && this.iterations > this.MAX_ITERATIONS) {
+      this.tryFinalAcceptance();
+    }
+    if (!this.solved && this.iterations > this.MAX_ITERATIONS) {
+      this.error = `${this.constructor.name} ran out of iterations`;
+      console.error(this.error);
+      this.failed = true;
     }
-    let numX = 0;
-    let numY = 0;
-    let den = 0;
-    for (const p of targets) {
-      const d = dist(c, p);
-      const w = 1 / Math.max(d, eps);
-      numX += p.x * w;
-      numY += p.y * w;
-      den += w;
+    if ("computeProgress" in this) {
+      this.progress = this.computeProgress();
     }
-    if (den === 0) break;
-    const next = clampToBounds({ x: numX / den, y: numY / den }, bounds);
-    if (dist(next, c) < tol) return next;
-    c = next;
   }
-  return c;
-}
-function optimizeTranslationForMinimumSum(context) {
-  const { component, initialCenter, packedComponents, minGap } = context;
-  const bounds = computeTranslationBounds(
-    component,
-    initialCenter,
-    packedComponents,
-    minGap
-  );
-  if (bounds.minX >= bounds.maxX || bounds.minY >= bounds.maxY) {
-    return initialCenter;
+  _setup() {
   }
-  const packedPads = packedComponents.flatMap((c) => c.pads);
-  const connectedPads = component.pads.filter(
-    (pad) => packedPads.some((pp) => pp.networkId === pad.networkId)
-  );
-  if (connectedPads.length === 0) return initialCenter;
-  const assignTargets = (center2) => {
-    const results = [];
-    for (const pad of connectedPads) {
-      const padAbs = { x: center2.x + pad.offset.x, y: center2.y + pad.offset.y };
-      let best = null;
-      for (let j = 0; j < packedPads.length; j++) {
-        const pp = packedPads[j];
-        if (!pp || pp.networkId !== pad.networkId) continue;
-        const d = Math.hypot(
-          padAbs.x - pp.absoluteCenter.x,
-          padAbs.y - pp.absoluteCenter.y
-        );
-        if (!best || d < dist(padAbs, best.p)) {
-          best = {
-            p: {
-              x: pp.absoluteCenter.x - pad.offset.x,
-              y: pp.absoluteCenter.y - pad.offset.y
-            },
-            key: `${pad.networkId}:${j}`
-          };
-        }
-      }
-      if (best) results.push({ targets: best.p, key: best.key });
+  _step() {
+  }
+  getConstructorParams() {
+    throw new Error("getConstructorParams not implemented");
+  }
+  solve() {
+    const startTime = Date.now();
+    while (!this.solved && !this.failed) {
+      this.step();
     }
-    return results;
-  };
-  let center = clampToBounds(initialCenter, bounds);
-  let prevAssignSignature = "";
-  const maxOuterIters = 30;
-  const tolMove = 1e-3;
-  if (checkOverlap(component, center, packedComponents, minGap)) {
-    const mid = {
-      x: (bounds.minX + bounds.maxX) / 2,
-      y: (bounds.minY + bounds.maxY) / 2
+    const endTime = Date.now();
+    this.timeToSolve = endTime - startTime;
+  }
+  visualize() {
+    return {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: []
     };
-    center = backtrackToFeasible(
-      center,
-      mid,
-      (p) => !checkOverlap(component, p, packedComponents, minGap)
-    );
   }
-  for (let iter = 0; iter < maxOuterIters; iter++) {
-    const assignments = assignTargets(center);
-    if (assignments.length === 0) return initialCenter;
-    const signature = assignments.map((a) => a.key).join("|");
-    const targets = assignments.map((a) => a.targets);
-    const proposed = geometricMedianConstrained(
-      targets,
-      center,
-      bounds,
-      100,
-      1e-4
-    );
-    let next = proposed;
-    if (checkOverlap(component, next, packedComponents, minGap)) {
-      next = backtrackToFeasible(
-        center,
-        proposed,
-        (p) => !checkOverlap(component, p, packedComponents, minGap)
-      );
-    }
-    if (signature === prevAssignSignature && dist(next, center) < tolMove) {
-      center = next;
-      break;
-    }
-    prevAssignSignature = signature;
-    center = next;
+  /**
+   * Called when the solver is about to fail, but we want to see if we have an
+   * "acceptable" or "passable" solution. Mostly used for optimizers that
+   * have an aggressive early stopping criterion.
+   */
+  tryFinalAcceptance() {
   }
-  const initCost = calculateSumDistance(
-    component,
-    initialCenter,
-    packedComponents
-  );
-  const finalCost = calculateSumDistance(component, center, packedComponents);
-  if (finalCost > initCost && !checkOverlap(component, initialCenter, packedComponents, minGap)) {
-    return initialCenter;
+  /**
+   * A lightweight version of the visualize method that can be used to stream
+   * progress
+   */
+  preview() {
+    return {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: []
+    };
   }
-  return center;
-}
+};
 
-// lib/PackSolver/PackSolver.ts
-var PackSolver = class extends BaseSolver {
+// lib/PackSolver/PhasedPackSolver.ts
+var PhasedPackSolver = class extends BaseSolver {
   packInput;
   unpackedComponentQueue;
   packedComponents;
+  // Phase management
+  currentPhase = "idle";
+  currentComponent;
+  phaseData = {};
+  // Legacy compatibility
   lastBestPointsResult;
   lastEvaluatedPositionShadows;
+  lastCandidatePoints;
   constructor(input) {
     super();
     this.packInput = input;
   }
   _setup() {
     const { components, packOrderStrategy, packFirst = [] } = this.packInput;
-    const packFirstMap = /* @__PURE__ */ new Map();
-    packFirst.forEach((componentId, index) => {
-      packFirstMap.set(componentId, index);
-    });
-    this.unpackedComponentQueue = [...components].sort((a, b) => {
-      const aPackFirstIndex = packFirstMap.get(a.componentId);
-      const bPackFirstIndex = packFirstMap.get(b.componentId);
-      if (aPackFirstIndex !== void 0 && bPackFirstIndex !== void 0) {
-        return aPackFirstIndex - bPackFirstIndex;
-      }
-      if (aPackFirstIndex !== void 0) return -1;
-      if (bPackFirstIndex !== void 0) return 1;
-      if (packOrderStrategy === "largest_to_smallest") {
-        return b.pads.length - a.pads.length;
-      }
-      return a.pads.length - b.pads.length;
+    this.unpackedComponentQueue = sortComponentQueue({
+      components,
+      packOrderStrategy,
+      packFirst
     });
     this.packedComponents = [];
+    this.currentPhase = "idle";
+    this.phaseData = {};
   }
   _step() {
     if (this.solved) return;
+    switch (this.currentPhase) {
+      case "idle":
+        if (this.unpackedComponentQueue.length === 0) {
+          this.solved = true;
+          return;
+        }
+        this.currentComponent = this.unpackedComponentQueue.shift();
+        if (!this.currentComponent) {
+          this.solved = true;
+          return;
+        }
+        if (this.packedComponents.length === 0) {
+          this.placeFirstComponent();
+          this.currentComponent = void 0;
+          return;
+        }
+        this.currentPhase = "show_candidate_points";
+        this.computeCandidatePoints();
+        break;
+      case "show_candidate_points":
+        this.currentPhase = "show_rotations";
+        this.computeRotationTrials();
+        break;
+      case "show_rotations":
+        this.currentPhase = "show_final_placement";
+        this.selectBestRotation();
+        break;
+      case "show_final_placement":
+        this.finalizeComponentPlacement();
+        this.currentPhase = "idle";
+        this.phaseData = {};
+        break;
+    }
+  }
+  placeFirstComponent() {
+    if (!this.currentComponent) return;
+    const newPackedComponent = {
+      ...this.currentComponent,
+      center: { x: 0, y: 0 },
+      ccwRotationOffset: 0,
+      pads: this.currentComponent.pads.map((p) => ({
+        ...p,
+        absoluteCenter: { x: 0, y: 0 }
+      }))
+    };
+    const candidateAngles = this.getCandidateAngles(newPackedComponent);
+    newPackedComponent.ccwRotationOffset = ((candidateAngles[0] ?? 0) % 360 + 360) % 360;
+    setPackedComponentPadCenters(newPackedComponent);
+    this.packedComponents.push(newPackedComponent);
+    this.currentComponent = void 0;
+  }
+  computeCandidatePoints() {
+    if (!this.currentComponent) return;
     const {
       minGap = 0,
       disconnectedPackDirection = "nearest_to_center",
       packPlacementStrategy = "shortest_connection_along_outline"
     } = this.packInput;
-    if (this.unpackedComponentQueue.length === 0) {
-      this.solved = true;
-      return;
-    }
-    const next = this.unpackedComponentQueue.shift();
-    if (!next) {
-      this.solved = true;
-      return;
-    }
     const newPackedComponent = {
-      ...next,
+      ...this.currentComponent,
       center: { x: 0, y: 0 },
       ccwRotationOffset: 0,
-      pads: next.pads.map((p) => ({
+      pads: this.currentComponent.pads.map((p) => ({
         ...p,
         absoluteCenter: { x: 0, y: 0 }
       }))
     };
-    if (this.packedComponents.length === 0) {
-      newPackedComponent.center = { x: 0, y: 0 };
-      setPackedComponentPadCenters(newPackedComponent);
-      this.packedComponents.push(newPackedComponent);
-      return;
-    }
     const padMargins = newPackedComponent.pads.map(
       (p) => Math.max(p.size.x, p.size.y) / 2
     );
@@ -689,6 +896,7 @@ var PackSolver = class extends BaseSolver {
       this.packedComponents,
       { minGap: minGap + additionalGap }
     );
+    this.phaseData.outlines = outlines;
     const networkIdsInPackedComponents = new Set(
       this.packedComponents.flatMap((c) => c.pads.map((p) => p.networkId))
     );
@@ -701,55 +909,86 @@ var PackSolver = class extends BaseSolver {
       )
     );
     if (sharedNetworkIds.size === 0) {
-      this.placeComponentDisconnected(
-        newPackedComponent,
+      this.phaseData.candidatePoints = [];
+      this.phaseData.goodCandidates = [];
+      const shadows = placeComponentDisconnected({
+        component: newPackedComponent,
         outlines,
-        disconnectedPackDirection
-      );
-      this.packedComponents.push(newPackedComponent);
+        direction: disconnectedPackDirection,
+        packedComponents: this.packedComponents,
+        candidateAngles: this.getCandidateAngles(newPackedComponent),
+        checkOverlap: (comp) => this.checkOverlapWithPackedComponents(comp)
+      });
+      this.phaseData.selectedRotation = newPackedComponent;
+      this.phaseData.rotationTrials = shadows.map((s) => ({
+        ...s,
+        cost: 0,
+        anchorType: "center",
+        hasOverlap: false
+      }));
       return;
     }
+    const candidatePoints = [];
+    const goodCandidates = [];
+    let smallestDistance = Number.POSITIVE_INFINITY;
+    const segmentBestPoints = /* @__PURE__ */ new Map();
+    const getSegmentKey = (segment) => {
+      const [p1, p2] = segment;
+      return `${p1.x.toFixed(6)},${p1.y.toFixed(6)}-${p2.x.toFixed(6)},${p2.y.toFixed(6)}`;
+    };
     const networkIdToAlreadyPackedSegments = /* @__PURE__ */ new Map();
     for (const sharedNetworkId of sharedNetworkIds) {
-      networkIdToAlreadyPackedSegments.set(sharedNetworkId, []);
+      const segments = [];
       for (const packedComponent of this.packedComponents) {
         for (const pad of packedComponent.pads) {
-          if (pad.networkId !== sharedNetworkId) continue;
-          const segments = getSegmentsFromPad(pad);
-          networkIdToAlreadyPackedSegments.set(sharedNetworkId, segments);
+          if (pad.networkId === sharedNetworkId) {
+            segments.push(...getSegmentsFromPad(pad));
+          }
         }
       }
+      networkIdToAlreadyPackedSegments.set(sharedNetworkId, segments);
     }
-    let smallestDistance = Number.POSITIVE_INFINITY;
-    let bestPoints = [];
-    if (packPlacementStrategy === "minimum_sum_distance_to_network") {
+    if (packPlacementStrategy === "minimum_sum_distance_to_network" || packPlacementStrategy === "minimum_sum_squared_distance_to_network") {
       for (const outline of outlines) {
         for (const outlineSegment of outline) {
-          const samplePoints = [
-            outlineSegment[0],
-            {
-              x: (outlineSegment[0].x + outlineSegment[1].x) / 2,
-              y: (outlineSegment[0].y + outlineSegment[1].y) / 2
-            },
-            outlineSegment[1]
-          ];
-          for (const samplePoint of samplePoints) {
-            for (const sharedNetworkId of sharedNetworkIds) {
-              const sumDistance = this.computeSumDistanceForPosition(
-                newPackedComponent,
-                samplePoint,
-                sharedNetworkId
-              );
-              if (sumDistance < smallestDistance + 1e-6) {
-                if (sumDistance < smallestDistance - 1e-6) {
-                  bestPoints = [{ ...samplePoint, networkId: sharedNetworkId }];
-                  smallestDistance = sumDistance;
-                } else {
-                  bestPoints.push({
-                    ...samplePoint,
-                    networkId: sharedNetworkId
-                  });
-                }
+          const [p1, p2] = outlineSegment;
+          for (const sharedNetworkId of sharedNetworkIds) {
+            const {
+              point: optimalPoint,
+              distance: optimalDistance,
+              candidatePoints: searchPoints
+            } = findOptimalPointOnSegment({
+              p1,
+              p2,
+              component: newPackedComponent,
+              networkId: sharedNetworkId,
+              packedComponents: this.packedComponents,
+              useSquaredDistance: packPlacementStrategy === "minimum_sum_squared_distance_to_network"
+            });
+            for (const searchPoint of searchPoints) {
+              candidatePoints.push(searchPoint);
+            }
+            const segmentKey = getSegmentKey(outlineSegment);
+            const currentSegmentBest = segmentBestPoints.get(segmentKey);
+            if (!currentSegmentBest || optimalDistance < currentSegmentBest.distance) {
+              segmentBestPoints.set(segmentKey, {
+                point: { ...optimalPoint, networkId: sharedNetworkId },
+                distance: optimalDistance
+              });
+            }
+            if (optimalDistance < smallestDistance + 1e-6) {
+              if (optimalDistance < smallestDistance - 1e-6) {
+                goodCandidates.length = 0;
+                goodCandidates.push({
+                  ...optimalPoint,
+                  networkId: sharedNetworkId
+                });
+                smallestDistance = optimalDistance;
+              } else {
+                goodCandidates.push({
+                  ...optimalPoint,
+                  networkId: sharedNetworkId
+                });
               }
             }
           }
@@ -768,17 +1007,32 @@ var PackSolver = class extends BaseSolver {
               outlineSegment,
               alreadyPackedSegments
             );
+            candidatePoints.push({
+              ...nearestPointOnOutlineToAlreadyPackedSegments,
+              networkId: sharedNetworkId,
+              distance: outlineToAlreadyPackedSegmentsDist
+            });
+            const segmentKey = getSegmentKey(outlineSegment);
+            const currentSegmentBest = segmentBestPoints.get(segmentKey);
+            if (!currentSegmentBest || outlineToAlreadyPackedSegmentsDist < currentSegmentBest.distance) {
+              segmentBestPoints.set(segmentKey, {
+                point: {
+                  ...nearestPointOnOutlineToAlreadyPackedSegments,
+                  networkId: sharedNetworkId
+                },
+                distance: outlineToAlreadyPackedSegmentsDist
+              });
+            }
             if (outlineToAlreadyPackedSegmentsDist < smallestDistance + 1e-6) {
               if (outlineToAlreadyPackedSegmentsDist < smallestDistance - 1e-6) {
-                bestPoints = [
-                  {
-                    ...nearestPointOnOutlineToAlreadyPackedSegments,
-                    networkId: sharedNetworkId
-                  }
-                ];
+                goodCandidates.length = 0;
+                goodCandidates.push({
+                  ...nearestPointOnOutlineToAlreadyPackedSegments,
+                  networkId: sharedNetworkId
+                });
                 smallestDistance = outlineToAlreadyPackedSegmentsDist;
               } else {
-                bestPoints.push({
+                goodCandidates.push({
                   ...nearestPointOnOutlineToAlreadyPackedSegments,
                   networkId: sharedNetworkId
                 });
@@ -788,212 +1042,216 @@ var PackSolver = class extends BaseSolver {
         }
       }
     }
-    this.lastBestPointsResult = {
-      bestPoints,
-      distance: smallestDistance
-    };
-    this.lastEvaluatedPositionShadows = [];
-    for (const bestPoint of bestPoints) {
-      const networkId = bestPoint.networkId;
-      const newPadsConnectedToNetworkId = newPackedComponent.pads.filter(
-        (p) => p.networkId === networkId
-      );
-      const candidateAngles = this.getCandidateAngles(newPackedComponent);
-      let bestCandidate = null;
-      const packedPads = this.packedComponents.flatMap((c) => c.pads);
-      for (const angle of candidateAngles) {
-        const firstPad = newPadsConnectedToNetworkId[0];
-        if (!firstPad) continue;
-        const rotatedOffset = rotatePoint(firstPad.offset, angle);
-        const candidateCenter = {
-          x: bestPoint.x - rotatedOffset.x,
-          y: bestPoint.y - rotatedOffset.y
-        };
-        const transformedPads = newPackedComponent.pads.map((p) => {
-          const ro = rotatePoint(p.offset, angle);
-          return {
-            ...p,
-            absoluteCenter: {
-              x: candidateCenter.x + ro.x,
-              y: candidateCenter.y + ro.y
-            }
-          };
-        });
-        const tempComponent = {
-          ...newPackedComponent,
-          center: candidateCenter,
-          ccwRotationOffset: angle,
-          pads: transformedPads
-        };
-        this.lastEvaluatedPositionShadows?.push({ ...tempComponent });
-        if (this.checkOverlapWithPackedComponents(tempComponent)) continue;
-        let cost = 0;
-        if (packPlacementStrategy === "minimum_sum_distance_to_network") {
-          const optimizedCenter = optimizeTranslationForMinimumSum({
-            component: tempComponent,
-            initialCenter: candidateCenter,
-            packedComponents: this.packedComponents,
-            minGap
-          });
-          const optimizedTransformedPads = newPackedComponent.pads.map((p) => {
-            const ro = rotatePoint(p.offset, angle);
-            return {
-              ...p,
-              absoluteCenter: {
-                x: optimizedCenter.x + ro.x,
-                y: optimizedCenter.y + ro.y
-              }
+    for (const sharedNetworkId of sharedNetworkIds) {
+      for (const outline of outlines) {
+        for (const outlineSegment of outline) {
+          const [p1, p2] = outlineSegment;
+          for (let t = 0; t <= 1; t += 0.2) {
+            const sampledPoint = {
+              x: p1.x + t * (p2.x - p1.x),
+              y: p1.y + t * (p2.y - p1.y)
             };
-          });
-          tempComponent.center = optimizedCenter;
-          tempComponent.pads = optimizedTransformedPads;
-          if (optimizedCenter.x !== candidateCenter.x || optimizedCenter.y !== candidateCenter.y) {
-            this.lastEvaluatedPositionShadows?.push({ ...tempComponent });
-          }
-          if (this.checkOverlapWithPackedComponents(tempComponent)) continue;
-          for (const tp of optimizedTransformedPads) {
-            const sameNetPads = packedPads.filter(
-              (pp) => pp.networkId === tp.networkId
+            let distance = 0;
+            const componentPadsOnNetwork = newPackedComponent.pads.filter(
+              (p) => p.networkId === sharedNetworkId
             );
-            if (!sameNetPads.length) continue;
-            let bestD = Infinity;
-            for (const pp of sameNetPads) {
-              const dx = tp.absoluteCenter.x - pp.absoluteCenter.x;
-              const dy = tp.absoluteCenter.y - pp.absoluteCenter.y;
-              const d = Math.hypot(dx, dy);
-              if (d < bestD) bestD = d;
+            for (const componentPad of componentPadsOnNetwork) {
+              let minDist = Number.POSITIVE_INFINITY;
+              for (const packedComponent of this.packedComponents) {
+                for (const packedPad of packedComponent.pads) {
+                  if (packedPad.networkId === sharedNetworkId) {
+                    const dx = sampledPoint.x + componentPad.offset.x - packedPad.absoluteCenter.x;
+                    const dy = sampledPoint.y + componentPad.offset.y - packedPad.absoluteCenter.y;
+                    const dist = Math.sqrt(dx * dx + dy * dy);
+                    minDist = Math.min(minDist, dist);
+                  }
+                }
+              }
+              distance += minDist;
             }
-            cost += bestD === Infinity ? 0 : bestD;
-          }
-        } else {
-          for (const tp of transformedPads) {
-            const sameNetPads = packedPads.filter(
-              (pp) => pp.networkId === tp.networkId
-            );
-            if (!sameNetPads.length) continue;
-            let bestD = Infinity;
-            for (const pp of sameNetPads) {
-              const dx = tp.absoluteCenter.x - pp.absoluteCenter.x;
-              const dy = tp.absoluteCenter.y - pp.absoluteCenter.y;
-              const d = Math.hypot(dx, dy);
-              if (d < bestD) bestD = d;
+            const point = {
+              ...sampledPoint,
+              networkId: sharedNetworkId,
+              distance
+            };
+            candidatePoints.push(point);
+            if (distance < smallestDistance) {
+              smallestDistance = distance;
+              goodCandidates.length = 0;
+              goodCandidates.push(point);
+            } else if (distance === smallestDistance) {
+              goodCandidates.push(point);
             }
-            cost += bestD;
           }
         }
-        if (!bestCandidate || cost < bestCandidate.cost) {
-          const finalCenter = packPlacementStrategy === "minimum_sum_distance_to_network" ? tempComponent.center : candidateCenter;
-          bestCandidate = { center: finalCenter, angle, cost };
-        }
       }
-      if (bestCandidate) {
-        newPackedComponent.center = bestCandidate.center;
-        newPackedComponent.ccwRotationOffset = bestCandidate.angle;
-      } else {
-        console.log("no valid rotation found");
-        const firstPad = newPadsConnectedToNetworkId[0];
-        const candidateCenter = {
-          x: bestPoint.x - firstPad.offset.x,
-          y: bestPoint.y - firstPad.offset.y
-        };
-        newPackedComponent.center = candidateCenter;
-        newPackedComponent.ccwRotationOffset = 0;
+    }
+    for (const [, segmentBest] of segmentBestPoints) {
+      const isAlreadyIncluded = goodCandidates.some(
+        (gc) => Math.abs(gc.x - segmentBest.point.x) < 1e-6 && Math.abs(gc.y - segmentBest.point.y) < 1e-6 && gc.networkId === segmentBest.point.networkId
+      );
+      if (!isAlreadyIncluded) {
+        goodCandidates.push(segmentBest.point);
       }
-      setPackedComponentPadCenters(newPackedComponent);
     }
-    setPackedComponentPadCenters(newPackedComponent);
-    this.packedComponents.push(newPackedComponent);
-  }
-  getConstructorParams() {
-    return [this.packInput];
+    this.phaseData.candidatePoints = candidatePoints;
+    this.phaseData.goodCandidates = goodCandidates;
+    this.phaseData.bestDistance = smallestDistance;
+    this.lastCandidatePoints = candidatePoints;
+    this.lastBestPointsResult = { goodCandidates, distance: smallestDistance };
   }
-  /* ---------- small helpers ------------------------------------------------ */
-  getCandidateAngles(c) {
-    return (c.availableRotationDegrees ?? [0, 90, 180, 270]).map(
-      (d) => d % 360 * Math.PI / 180
-    );
-  }
-  checkOverlapWithPackedComponents(cand) {
-    const b = getComponentBounds(cand, 0);
-    const candBox = {
-      center: { x: (b.minX + b.maxX) / 2, y: (b.minY + b.maxY) / 2 },
-      width: b.maxX - b.minX,
-      height: b.maxY - b.minY
+  computeRotationTrials() {
+    if (!this.currentComponent || !this.phaseData.goodCandidates) return;
+    const newPackedComponent = {
+      ...this.currentComponent,
+      center: { x: 0, y: 0 },
+      ccwRotationOffset: 0,
+      pads: this.currentComponent.pads.map((p) => ({
+        ...p,
+        absoluteCenter: { x: 0, y: 0 }
+      }))
     };
-    for (const pc of this.packedComponents) {
-      for (const pad of pc.pads) {
-        if (computeDistanceBetweenBoxes(
-          {
-            center: pad.absoluteCenter,
-            width: pad.size.x,
-            height: pad.size.y
-          },
-          candBox
-        ).distance < this.packInput.minGap)
-          return true;
+    const rotationTrials = [];
+    const candidateAngles = this.getCandidateAngles(newPackedComponent);
+    const allCandidatePoints = [...this.phaseData.goodCandidates];
+    if (this.phaseData.outlines) {
+      for (const networkId of new Set(
+        this.phaseData.goodCandidates.map((p) => p.networkId)
+      )) {
+        for (const outline of this.phaseData.outlines) {
+          for (const outlineSegment of outline) {
+            const [p1, p2] = outlineSegment;
+            for (let t = 0; t <= 1; t += 0.2) {
+              allCandidatePoints.push({
+                x: p1.x + t * (p2.x - p1.x),
+                y: p1.y + t * (p2.y - p1.y),
+                networkId
+              });
+            }
+          }
+        }
       }
     }
-    return false;
-  }
-  computeGlobalCenter() {
-    if (!this.packedComponents.length) return { x: 0, y: 0 };
-    const s = this.packedComponents.reduce(
-      (a, c) => ({ x: a.x + c.center.x, y: a.y + c.center.y }),
-      { x: 0, y: 0 }
-    );
-    return {
-      x: s.x / this.packedComponents.length,
-      y: s.y / this.packedComponents.length
-    };
-  }
-  findBestPointForDisconnected(outlines, dir) {
-    const pts = outlines.flatMap(
-      (ol) => ol.map(([p1, p2]) => ({
-        x: (p1.x + p2.x) / 2,
-        y: (p1.y + p2.y) / 2
-      }))
-    );
-    if (!pts.length) return { x: 0, y: 0 };
-    if (dir !== "nearest_to_center") {
-      const extreme = dir === "left" || dir === "down" ? Math.min : Math.max;
-      const key = dir === "left" || dir === "right" ? "x" : "y";
-      const target = extreme(...pts.map((p) => p[key]));
-      return pts.find((p) => p[key] === target);
+    const useSquaredDistance = this.packInput.packPlacementStrategy === "minimum_sum_squared_distance_to_network";
+    const result = selectOptimalRotation({
+      component: newPackedComponent,
+      candidatePoints: allCandidatePoints,
+      packedComponents: this.packedComponents,
+      minGap: this.packInput.minGap ?? 0,
+      useSquaredDistance,
+      checkOverlap: (comp) => this.checkOverlapWithPackedComponents(comp)
+    });
+    for (const angle of candidateAngles) {
+      for (const point of this.phaseData.goodCandidates) {
+        const componentPadsOnNetwork = newPackedComponent.pads.filter(
+          (p) => p.networkId === point.networkId
+        );
+        if (componentPadsOnNetwork.length > 0) {
+          const firstPad = componentPadsOnNetwork[0];
+          const rotatedPadOffset = rotatePoint(
+            firstPad.offset,
+            angle * Math.PI / 180
+          );
+          const componentCenter = {
+            x: point.x - rotatedPadOffset.x,
+            y: point.y - rotatedPadOffset.y
+          };
+          const trial = { ...newPackedComponent };
+          trial.center = componentCenter;
+          trial.ccwRotationOffset = (angle % 360 + 360) % 360;
+          setPackedComponentPadCenters(trial);
+          const hasOverlap = this.checkOverlapWithPackedComponents(trial);
+          let cost = 0;
+          for (const pad of trial.pads) {
+            let minDist = Number.POSITIVE_INFINITY;
+            for (const packedComp of this.packedComponents) {
+              for (const packedPad of packedComp.pads) {
+                if (packedPad.networkId === pad.networkId) {
+                  const dx = pad.absoluteCenter.x - packedPad.absoluteCenter.x;
+                  const dy = pad.absoluteCenter.y - packedPad.absoluteCenter.y;
+                  const dist = Math.sqrt(dx * dx + dy * dy);
+                  minDist = Math.min(minDist, dist);
+                }
+              }
+            }
+            if (minDist < Number.POSITIVE_INFINITY) {
+              cost += useSquaredDistance ? minDist * minDist : minDist;
+            }
+          }
+          rotationTrials.push({
+            ...trial,
+            cost,
+            anchorType: "pad",
+            anchorPadId: firstPad.padId,
+            hasOverlap
+          });
+        }
+        const centerTrial = { ...newPackedComponent };
+        centerTrial.center = { x: point.x, y: point.y };
+        centerTrial.ccwRotationOffset = (angle % 360 + 360) % 360;
+        setPackedComponentPadCenters(centerTrial);
+        const centerHasOverlap = this.checkOverlapWithPackedComponents(centerTrial);
+        let centerCost = 0;
+        for (const pad of centerTrial.pads) {
+          let minDist = Number.POSITIVE_INFINITY;
+          for (const packedComp of this.packedComponents) {
+            for (const packedPad of packedComp.pads) {
+              if (packedPad.networkId === pad.networkId) {
+                const dx = pad.absoluteCenter.x - packedPad.absoluteCenter.x;
+                const dy = pad.absoluteCenter.y - packedPad.absoluteCenter.y;
+                const dist = Math.sqrt(dx * dx + dy * dy);
+                minDist = Math.min(minDist, dist);
+              }
+            }
+          }
+          if (minDist < Number.POSITIVE_INFINITY) {
+            centerCost += useSquaredDistance ? minDist * minDist : minDist;
+          }
+        }
+        rotationTrials.push({
+          ...centerTrial,
+          cost: centerCost,
+          anchorType: "center",
+          hasOverlap: centerHasOverlap
+        });
+      }
     }
-    const center = this.computeGlobalCenter();
-    return pts.reduce(
-      (best, p) => Math.hypot(p.x - center.x, p.y - center.y) < Math.hypot(best.x - center.x, best.y - center.y) ? p : best
-    );
+    this.phaseData.rotationTrials = rotationTrials;
+    if (result) {
+      const selectedComponent = { ...newPackedComponent };
+      selectedComponent.center = result.center;
+      selectedComponent.ccwRotationOffset = result.angle;
+      selectedComponent.pads = result.pads;
+      setPackedComponentPadCenters(selectedComponent);
+      this.phaseData.selectedRotation = selectedComponent;
+    } else {
+      this.phaseData.selectedRotation = void 0;
+    }
+    this.lastEvaluatedPositionShadows = rotationTrials;
   }
-  placeComponentAtPoint(comp, pt) {
-    this.lastEvaluatedPositionShadows = [];
-    for (const ang of this.getCandidateAngles(comp)) {
-      const pads = comp.pads.map((p) => {
-        const ro = rotatePoint(p.offset, ang);
-        return { ...p, absoluteCenter: { x: pt.x + ro.x, y: pt.y + ro.y } };
-      });
-      const cand = {
-        ...comp,
-        center: pt,
-        ccwRotationOffset: ang,
-        pads
+  selectBestRotation() {
+    if (!this.phaseData.selectedRotation && this.currentComponent) {
+      const newPackedComponent = {
+        ...this.currentComponent,
+        center: { x: 5, y: 5 },
+        ccwRotationOffset: 0,
+        pads: this.currentComponent.pads.map((p) => ({
+          ...p,
+          absoluteCenter: { x: 0, y: 0 }
+        }))
       };
-      this.lastEvaluatedPositionShadows.push(cand);
-      if (!this.checkOverlapWithPackedComponents(cand)) {
-        Object.assign(comp, cand);
-        setPackedComponentPadCenters(comp);
-        return;
-      }
+      const candidateAngles = this.getCandidateAngles(newPackedComponent);
+      newPackedComponent.ccwRotationOffset = ((candidateAngles[0] ?? 0) % 360 + 360) % 360;
+      setPackedComponentPadCenters(newPackedComponent);
+      this.phaseData.selectedRotation = newPackedComponent;
     }
-    comp.center = pt;
-    comp.ccwRotationOffset = 0;
-    setPackedComponentPadCenters(comp);
   }
-  placeComponentDisconnected(comp, outlines, dir) {
-    const target = this.findBestPointForDisconnected(outlines, dir);
-    this.placeComponentAtPoint(comp, target);
+  finalizeComponentPlacement() {
+    if (!this.phaseData.selectedRotation) return;
+    this.packedComponents.push(this.phaseData.selectedRotation);
+    this.currentComponent = void 0;
   }
-  /** Visualize the current packing state – components are omitted, only the outline is shown. */
+  /** Visualize the current packing state based on the current phase */
   visualize() {
     const graphics = getGraphicsFromPackOutput({
       components: this.packedComponents ?? [],
@@ -1004,6 +1262,15 @@ var PackSolver = class extends BaseSolver {
     });
     graphics.points ??= [];
     graphics.lines ??= [];
+    graphics.rects ??= [];
+    if (graphics.rects) {
+      for (const rect of graphics.rects) {
+        if (rect.fill === "rgba(0,0,0,0.25)") {
+          rect.fill = "rgba(100,100,100,0.5)";
+          rect.stroke = "#333333";
+        }
+      }
+    }
     const outlines = constructOutlinesFromPackedComponents(
       this.packedComponents ?? [],
       {
@@ -1020,76 +1287,161 @@ var PackSolver = class extends BaseSolver {
         )
       )
     );
-    if (!this.solved) {
-      for (const shadow of this.lastEvaluatedPositionShadows ?? []) {
-        const bounds = getComponentBounds(shadow, 0);
-        graphics.rects.push({
-          center: shadow.center,
-          width: bounds.maxX - bounds.minX,
-          height: bounds.maxY - bounds.minY,
-          fill: "rgba(0,255,255,0.2)",
-          label: (shadow.ccwRotationOffset / Math.PI * 180).toFixed(1)
+    graphics.texts ??= [];
+    graphics.texts.push({
+      text: `Phase: ${this.currentPhase}`,
+      x: 0,
+      y: 5,
+      fontSize: 0.3
+    });
+    if (this.currentComponent) {
+      graphics.texts.push({
+        text: `Packing: ${this.currentComponent.componentId}`,
+        x: 0,
+        y: 4.5,
+        fontSize: 0.25
+      });
+    }
+    switch (this.currentPhase) {
+      case "show_candidate_points":
+        this.visualizeCandidatePoints(graphics);
+        break;
+      case "show_rotations":
+        this.visualizeRotationTrials(graphics);
+        break;
+      case "show_final_placement":
+        this.visualizeFinalPlacement(graphics);
+        break;
+      case "idle":
+        break;
+    }
+    return graphics;
+  }
+  visualizeCandidatePoints(graphics) {
+    if (this.phaseData.candidatePoints) {
+      for (const candidatePoint of this.phaseData.candidatePoints) {
+        graphics.points.push({
+          x: candidatePoint.x,
+          y: candidatePoint.y,
+          label: `d=${candidatePoint.distance.toFixed(3)}`,
+          fill: "rgba(255,165,0,0.6)",
+          // Orange color for candidate points
+          radius: 0.02
         });
-        for (const shadowPad of shadow.pads) {
-          graphics.rects.push({
-            center: shadowPad.absoluteCenter,
-            width: shadowPad.size.x,
-            height: shadowPad.size.y,
-            fill: "rgba(0,0,255,0.5)"
-          });
-        }
       }
-      if (this.lastBestPointsResult) {
-        for (const bestPoint of this.lastBestPointsResult.bestPoints) {
-          graphics.points.push({
-            x: bestPoint.x,
-            y: bestPoint.y,
-            label: `bestPoint
-networkId: ${bestPoint.networkId}
-d=${this.lastBestPointsResult.distance}`
-          });
-        }
+    }
+    if (this.phaseData.goodCandidates) {
+      for (const goodCandidate of this.phaseData.goodCandidates) {
+        graphics.points.push({
+          x: goodCandidate.x,
+          y: goodCandidate.y,
+          label: `BEST (d=${this.phaseData.bestDistance?.toFixed(3)})`,
+          fill: "rgba(0,255,0,0.8)",
+          // Green color for best points
+          radius: 0.03
+        });
+        const crossSize = 0.2;
+        graphics.lines.push(
+          {
+            points: [
+              {
+                x: goodCandidate.x - crossSize,
+                y: goodCandidate.y - crossSize
+              },
+              {
+                x: goodCandidate.x + crossSize,
+                y: goodCandidate.y + crossSize
+              }
+            ],
+            stroke: "#00AA00"
+          },
+          {
+            points: [
+              {
+                x: goodCandidate.x - crossSize,
+                y: goodCandidate.y + crossSize
+              },
+              {
+                x: goodCandidate.x + crossSize,
+                y: goodCandidate.y - crossSize
+              }
+            ],
+            stroke: "#00AA00"
+          }
+        );
       }
     }
-    return graphics;
+  }
+  visualizeRotationTrials(graphics) {
+    if (!this.phaseData.rotationTrials) return;
+    for (const trial of this.phaseData.rotationTrials) {
+      const rotationOffset = 0.02 * (trial.ccwRotationOffset / 90);
+      const anchorInfo = trial.anchorType === "pad" ? `pad: ${trial.anchorPadId}` : "center";
+      const overlapText = trial.hasOverlap ? "\nOVERLAP" : "";
+      graphics.points.push({
+        x: trial.center.x + rotationOffset,
+        y: trial.center.y + rotationOffset,
+        label: `${trial.ccwRotationOffset}\xB0 (cost: ${trial.cost.toFixed(3)}, anchor: ${anchorInfo})${overlapText}`,
+        fill: "rgba(0,255,255,0.8)",
+        radius: 0.05
+      });
+      for (const pad of trial.pads) {
+        const padColor = trial.hasOverlap ? { fill: "rgba(255,165,0,0.15)", stroke: "rgba(255,165,0,0.4)" } : { fill: "rgba(0,0,255,0.15)", stroke: "rgba(0,0,255,0.4)" };
+        graphics.rects.push({
+          center: pad.absoluteCenter,
+          width: pad.size.x,
+          height: pad.size.y,
+          fill: padColor.fill,
+          stroke: padColor.stroke,
+          strokeWidth: 0.01
+        });
+      }
+    }
+  }
+  visualizeFinalPlacement(graphics) {
+    if (!this.phaseData.selectedRotation) return;
+    const component = this.phaseData.selectedRotation;
+    const bounds = getComponentBounds(component, 0);
+    graphics.rects.push({
+      center: component.center,
+      width: bounds.maxX - bounds.minX,
+      height: bounds.maxY - bounds.minY,
+      fill: "rgba(0,255,0,0.3)",
+      stroke: "#00FF00",
+      strokeWidth: 0.05,
+      label: `PLACED at ${component.ccwRotationOffset}\xB0`
+    });
+    for (const pad of component.pads) {
+      graphics.rects.push({
+        center: pad.absoluteCenter,
+        width: pad.size.x,
+        height: pad.size.y,
+        fill: "rgba(0,255,0,0.7)"
+      });
+    }
+  }
+  getConstructorParams() {
+    return [this.packInput];
   }
   getResult() {
     return this.packedComponents;
   }
-  computeSumDistanceForPosition(component, position, targetNetworkId) {
-    const componentPadsOnNetwork = component.pads.filter(
-      (p) => p.networkId === targetNetworkId
-    );
-    if (componentPadsOnNetwork.length === 0) return 0;
-    const packedPadsOnNetwork = this.packedComponents.flatMap(
-      (c) => c.pads.filter((p) => p.networkId === targetNetworkId)
-    );
-    if (packedPadsOnNetwork.length === 0) return 0;
-    let sumDistance = 0;
-    for (const componentPad of componentPadsOnNetwork) {
-      const padPosition = {
-        x: position.x + componentPad.offset.x,
-        y: position.y + componentPad.offset.y
-      };
-      let minDistance = Number.POSITIVE_INFINITY;
-      for (const packedPad of packedPadsOnNetwork) {
-        const distance = Math.hypot(
-          padPosition.x - packedPad.absoluteCenter.x,
-          padPosition.y - packedPad.absoluteCenter.y
-        );
-        if (distance < minDistance) {
-          minDistance = distance;
-        }
-      }
-      sumDistance += minDistance === Number.POSITIVE_INFINITY ? 0 : minDistance;
-    }
-    return sumDistance;
+  /* ---------- small helpers ------------------------------------------------ */
+  getCandidateAngles(c) {
+    return (c.availableRotationDegrees ?? [0, 90, 180, 270]).map((d) => d % 360);
+  }
+  checkOverlapWithPackedComponents(component) {
+    return checkOverlapWithPackedComponents({
+      component,
+      packedComponents: this.packedComponents,
+      minGap: this.packInput.minGap ?? 0
+    });
   }
 };
 
 // lib/pack.ts
 var pack = (input) => {
-  const solver = new PackSolver(input);
+  const solver = new PhasedPackSolver(input);
   solver.solve();
   return {
     ...input,
@@ -1322,6 +1674,8 @@ var convertCircuitJsonToPackOutput = (circuitJson, opts = {}) => {
 var convertPackOutputToPackInput = (packed) => {
   const strippedComponents = packed.components.map((pc) => ({
     componentId: pc.componentId,
+    availableRotationDegrees: pc.availableRotationDegrees,
+    // Preserve rotation constraints
     pads: pc.pads.map(({ absoluteCenter: _ac, ...rest }) => rest)
   }));
   return {
@@ -1331,7 +1685,7 @@ var convertPackOutputToPackInput = (packed) => {
   };
 };
 export {
-  PackSolver,
+  PhasedPackSolver,
   convertCircuitJsonToPackOutput,
   convertPackOutputToPackInput,
   getGraphicsFromPackOutput,