@tscircuit/schematic-trace-solver 0.0.98 → 0.0.99

package/dist/index.js

@@ -76,80 +76,39 @@ var BaseSolver = class {
 };
 
 // lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts
-import "connectivity-map";
+import { distance } from "@tscircuit/math-utils";
 
-// lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem.ts
-import { ConnectivityMap } from "connectivity-map";
-var getConnectivityMapsFromInputProblem = (inputProblem) => {
-  const directConnMap = new ConnectivityMap({});
-  for (const directConn of inputProblem.directConnections) {
-    directConnMap.addConnections([
-      directConn.netId ? [directConn.netId, ...directConn.pinIds] : directConn.pinIds
-    ]);
-  }
-  const netConnMap = new ConnectivityMap(directConnMap.netMap);
-  for (const netConn of inputProblem.netConnections) {
-    netConnMap.addConnections([[netConn.netId, ...netConn.pinIds]]);
-  }
-  return { directConnMap, netConnMap };
+// lib/utils/getColorFromString.ts
+var getColorFromString = (string, alpha = 1) => {
+  const hash = string.split("").reduce((acc, char) => {
+    return acc * 31 + char.charCodeAt(0);
+  }, 0);
+  return `hsl(${hash % 360}, 100%, 50%, ${alpha})`;
 };
 
-// lib/solvers/MspConnectionPairSolver/getMspConnectionPairsFromPins.ts
-function getOrthogonalMinimumSpanningTree(pins, opts = {}) {
-  const n = pins.length;
-  const maxDistance = opts?.maxDistance ?? Number.POSITIVE_INFINITY;
-  if (n <= 1) return [];
-  {
-    const seen = /* @__PURE__ */ new Set();
-    for (const p of pins) {
-      if (seen.has(p.pinId)) {
-        throw new Error(`Duplicate pinId detected: "${p.pinId}"`);
-      }
-      seen.add(p.pinId);
-    }
-  }
-  const manhattan = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-  const inTree = new Array(n).fill(false);
-  const bestDist = new Array(n).fill(Number.POSITIVE_INFINITY);
-  const parent = new Array(n).fill(-1);
-  let startIndex = 0;
-  for (let i = 1; i < n; i++) {
-    if (pins[i].pinId < pins[startIndex].pinId) startIndex = i;
+// lib/utils/arePinsInDifferentSchematicSections.ts
+var getSectionNameForPin = (sectionByChipId, sectionByPinId, pin) => {
+  if (pin.chipId) {
+    const chipSection = sectionByChipId.get(pin.chipId);
+    if (chipSection) return chipSection;
   }
-  bestDist[startIndex] = 0;
-  const edges = [];
-  for (let iter = 0; iter < n; iter++) {
-    let u = -1;
-    let best = Number.POSITIVE_INFINITY;
-    let bestId = "";
-    for (let i = 0; i < n; i++) {
-      if (!inTree[i]) {
-        const d = bestDist[i];
-        if (d < best || d === best && (bestId === "" || pins[i].pinId < bestId)) {
-          best = d;
-          bestId = pins[i].pinId;
-          u = i;
-        }
-      }
-    }
-    inTree[u] = true;
-    if (parent[u] !== -1) {
-      edges.push([pins[u].pinId, pins[parent[u]].pinId]);
-    }
-    for (let v = 0; v < n; v++) {
-      if (!inTree[v]) {
-        const d0 = manhattan(pins[u], pins[v]);
-        const isForbidden = opts?.forbidEdge?.(pins[u], pins[v]) ?? false;
-        const d = d0 > maxDistance || isForbidden ? Number.POSITIVE_INFINITY : d0;
-        if (d < bestDist[v] || d === bestDist[v] && pins[u].pinId < pins[parent[v]]?.pinId) {
-          bestDist[v] = d;
-          parent[v] = u;
-        }
-      }
+  return sectionByPinId.get(pin.pinId);
+};
+var arePinsInDifferentSchematicSections = (inputProblem, p1, p2) => {
+  const sectionByChipId = /* @__PURE__ */ new Map();
+  const sectionByPinId = /* @__PURE__ */ new Map();
+  for (const chip of inputProblem.chips) {
+    if (!chip.sectionId) continue;
+    sectionByChipId.set(chip.chipId, chip.sectionId);
+    for (const pin of chip.pins) {
+      sectionByPinId.set(pin.pinId, chip.sectionId);
     }
   }
-  return edges;
-}
+  if (sectionByChipId.size === 0) return false;
+  const s1 = getSectionNameForPin(sectionByChipId, sectionByPinId, p1);
+  const s2 = getSectionNameForPin(sectionByChipId, sectionByPinId, p2);
+  return s1 !== s2;
+};
 
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection.ts
 var getPinDirection = (pin, chip) => {
@@ -181,6 +140,101 @@ var getPinDirection = (pin, chip) => {
   return "x-";
 };
 
+// lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem.ts
+var visualizeInputProblem = (inputProblem, opts = {}) => {
+  const {
+    connectionAlpha = 0.8,
+    chipAlpha = 0.8,
+    hideRatsNet = inputProblem._hideRatsNet ?? false
+  } = opts;
+  const graphics = {
+    lines: [],
+    points: [],
+    rects: []
+  };
+  const pinIdMap = /* @__PURE__ */ new Map();
+  for (const chip of inputProblem.chips) {
+    for (const pin of chip.pins) {
+      pinIdMap.set(pin.pinId, pin);
+    }
+  }
+  for (const chip of inputProblem.chips) {
+    graphics.rects.push({
+      label: chip.chipId,
+      center: chip.center,
+      width: chip.width,
+      height: chip.height,
+      fill: getColorFromString(chip.chipId, chipAlpha)
+    });
+    for (const pin of chip.pins) {
+      graphics.points.push({
+        label: `${pin.pinId}
+${pin._facingDirection ?? getPinDirection(pin, chip)}`,
+        x: pin.x,
+        y: pin.y,
+        color: getColorFromString(pin.pinId, 0.8)
+      });
+    }
+  }
+  for (const textBox of inputProblem.textBoxes ?? []) {
+    graphics.rects.push({
+      label: textBox.text ?? "schematic_text",
+      center: textBox.center,
+      width: textBox.width,
+      height: textBox.height,
+      fill: "rgba(160, 0, 220, 0.14)",
+      strokeColor: "rgba(160, 0, 220, 0.9)"
+    });
+  }
+  if (!hideRatsNet) {
+    for (const directConn of inputProblem.directConnections) {
+      const [pinId1, pinId2] = directConn.pinIds;
+      const pin1 = pinIdMap.get(pinId1);
+      const pin2 = pinIdMap.get(pinId2);
+      if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
+        continue;
+      }
+      graphics.lines.push({
+        points: [
+          {
+            x: pin1.x,
+            y: pin1.y
+          },
+          {
+            x: pin2.x,
+            y: pin2.y
+          }
+        ],
+        strokeColor: getColorFromString(
+          directConn.netId ?? `${pinId1}-${pinId2}`,
+          connectionAlpha
+        )
+      });
+    }
+    for (const netConn of inputProblem.netConnections) {
+      const pins = netConn.pinIds.map((pinId) => pinIdMap.get(pinId));
+      for (let i = 0; i < pins.length - 1; i++) {
+        for (let j = i + 1; j < pins.length; j++) {
+          const pin1 = pins[i];
+          const pin2 = pins[j];
+          if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
+            continue;
+          }
+          graphics.lines.push({
+            points: [
+              { x: pin1.x, y: pin1.y },
+              { x: pin2.x, y: pin2.y }
+            ],
+            strokeColor: getColorFromString(netConn.netId, connectionAlpha),
+            strokeDash: "4 2"
+          });
+        }
+      }
+    }
+  }
+  return graphics;
+};
+
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getRestrictedCenterLines.ts
 var getRestrictedCenterLines = (params) => {
   const { pins, inputProblem, pinIdMap, chipMap } = params;
@@ -293,134 +347,81 @@ var doesPairCrossRestrictedCenterLines = (params) => {
   return hvCrosses && vhCrosses;
 };
 
-// lib/utils/getColorFromString.ts
-var getColorFromString = (string, alpha = 1) => {
-  const hash = string.split("").reduce((acc, char) => {
-    return acc * 31 + char.charCodeAt(0);
-  }, 0);
-  return `hsl(${hash % 360}, 100%, 50%, ${alpha})`;
-};
-
-// lib/utils/arePinsInDifferentSchematicSections.ts
-var getSectionNameForPin = (sectionByChipId, sectionByPinId, pin) => {
-  if (pin.chipId) {
-    const chipSection = sectionByChipId.get(pin.chipId);
-    if (chipSection) return chipSection;
+// lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem.ts
+import { ConnectivityMap } from "connectivity-map";
+var getConnectivityMapsFromInputProblem = (inputProblem) => {
+  const directConnMap = new ConnectivityMap({});
+  for (const directConn of inputProblem.directConnections) {
+    directConnMap.addConnections([
+      directConn.netId ? [directConn.netId, ...directConn.pinIds] : directConn.pinIds
+    ]);
   }
-  return sectionByPinId.get(pin.pinId);
-};
-var arePinsInDifferentSchematicSections = (inputProblem, p1, p2) => {
-  const sectionByChipId = /* @__PURE__ */ new Map();
-  const sectionByPinId = /* @__PURE__ */ new Map();
-  for (const chip of inputProblem.chips) {
-    if (!chip.sectionId) continue;
-    sectionByChipId.set(chip.chipId, chip.sectionId);
-    for (const pin of chip.pins) {
-      sectionByPinId.set(pin.pinId, chip.sectionId);
-    }
+  const netConnMap = new ConnectivityMap(directConnMap.netMap);
+  for (const netConn of inputProblem.netConnections) {
+    netConnMap.addConnections([[netConn.netId, ...netConn.pinIds]]);
   }
-  if (sectionByChipId.size === 0) return false;
-  const s1 = getSectionNameForPin(sectionByChipId, sectionByPinId, p1);
-  const s2 = getSectionNameForPin(sectionByChipId, sectionByPinId, p2);
-  return s1 !== s2;
+  return { directConnMap, netConnMap };
 };
 
-// lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem.ts
-var visualizeInputProblem = (inputProblem, opts = {}) => {
-  const {
-    connectionAlpha = 0.8,
-    chipAlpha = 0.8,
-    hideRatsNet = inputProblem._hideRatsNet ?? false
-  } = opts;
-  const graphics = {
-    lines: [],
-    points: [],
-    rects: []
-  };
-  const pinIdMap = /* @__PURE__ */ new Map();
-  for (const chip of inputProblem.chips) {
-    for (const pin of chip.pins) {
-      pinIdMap.set(pin.pinId, pin);
-    }
-  }
-  for (const chip of inputProblem.chips) {
-    graphics.rects.push({
-      label: chip.chipId,
-      center: chip.center,
-      width: chip.width,
-      height: chip.height,
-      fill: getColorFromString(chip.chipId, chipAlpha)
-    });
-    for (const pin of chip.pins) {
-      graphics.points.push({
-        label: `${pin.pinId}
-${pin._facingDirection ?? getPinDirection(pin, chip)}`,
-        x: pin.x,
-        y: pin.y,
-        color: getColorFromString(pin.pinId, 0.8)
-      });
+// lib/solvers/MspConnectionPairSolver/getMspConnectionPairsFromPins.ts
+function getOrthogonalMinimumSpanningTree(pins, opts = {}) {
+  const n = pins.length;
+  const maxDistance = opts?.maxDistance ?? Number.POSITIVE_INFINITY;
+  if (n <= 1) return [];
+  {
+    const seen = /* @__PURE__ */ new Set();
+    for (const p of pins) {
+      if (seen.has(p.pinId)) {
+        throw new Error(`Duplicate pinId detected: "${p.pinId}"`);
+      }
+      seen.add(p.pinId);
     }
   }
-  for (const textBox of inputProblem.textBoxes ?? []) {
-    graphics.rects.push({
-      label: textBox.text ?? "schematic_text",
-      center: textBox.center,
-      width: textBox.width,
-      height: textBox.height,
-      fill: "rgba(160, 0, 220, 0.14)",
-      strokeColor: "rgba(160, 0, 220, 0.9)"
-    });
+  const manhattan = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+  const inTree = new Array(n).fill(false);
+  const bestDist = new Array(n).fill(Number.POSITIVE_INFINITY);
+  const parent = new Array(n).fill(-1);
+  let startIndex = 0;
+  for (let i = 1; i < n; i++) {
+    if (pins[i].pinId < pins[startIndex].pinId) startIndex = i;
   }
-  if (!hideRatsNet) {
-    for (const directConn of inputProblem.directConnections) {
-      const [pinId1, pinId2] = directConn.pinIds;
-      const pin1 = pinIdMap.get(pinId1);
-      const pin2 = pinIdMap.get(pinId2);
-      if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
-        continue;
+  bestDist[startIndex] = 0;
+  const edges = [];
+  for (let iter = 0; iter < n; iter++) {
+    let u = -1;
+    let best = Number.POSITIVE_INFINITY;
+    let bestId = "";
+    for (let i = 0; i < n; i++) {
+      if (!inTree[i]) {
+        const d = bestDist[i];
+        if (d < best || d === best && (bestId === "" || pins[i].pinId < bestId)) {
+          best = d;
+          bestId = pins[i].pinId;
+          u = i;
+        }
       }
-      graphics.lines.push({
-        points: [
-          {
-            x: pin1.x,
-            y: pin1.y
-          },
-          {
-            x: pin2.x,
-            y: pin2.y
-          }
-        ],
-        strokeColor: getColorFromString(
-          directConn.netId ?? `${pinId1}-${pinId2}`,
-          connectionAlpha
-        )
-      });
     }
-    for (const netConn of inputProblem.netConnections) {
-      const pins = netConn.pinIds.map((pinId) => pinIdMap.get(pinId));
-      for (let i = 0; i < pins.length - 1; i++) {
-        for (let j = i + 1; j < pins.length; j++) {
-          const pin1 = pins[i];
-          const pin2 = pins[j];
-          if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
-            continue;
-          }
-          graphics.lines.push({
-            points: [
-              { x: pin1.x, y: pin1.y },
-              { x: pin2.x, y: pin2.y }
-            ],
-            strokeColor: getColorFromString(netConn.netId, connectionAlpha),
-            strokeDash: "4 2"
-          });
+    inTree[u] = true;
+    if (parent[u] !== -1) {
+      edges.push([pins[u].pinId, pins[parent[u]].pinId]);
+    }
+    for (let v = 0; v < n; v++) {
+      if (!inTree[v]) {
+        const d0 = manhattan(pins[u], pins[v]);
+        const isForbidden = opts?.forbidEdge?.(pins[u], pins[v]) ?? false;
+        const d = d0 > maxDistance || isForbidden ? Number.POSITIVE_INFINITY : d0;
+        if (d < bestDist[v] || d === bestDist[v] && pins[u].pinId < pins[parent[v]]?.pinId) {
+          bestDist[v] = d;
+          parent[v] = u;
         }
       }
     }
   }
-  return graphics;
-};
+  return edges;
+}
 
 // lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts
+var getPinPairKey = (pinIds) => [...pinIds].sort().join("::");
 var MspConnectionPairSolver = class extends BaseSolver {
   inputProblem;
   mspConnectionPairs = [];
@@ -431,6 +432,7 @@ var MspConnectionPairSolver = class extends BaseSolver {
   maxMspPairDistance;
   pinMap;
   userNetIdByPinId;
+  directConnectionPinPairKeys;
   constructor({ inputProblem }) {
     super();
     this.inputProblem = inputProblem;
@@ -449,7 +451,9 @@ var MspConnectionPairSolver = class extends BaseSolver {
       this.chipMap[chip.chipId] = chip;
     }
     this.userNetIdByPinId = {};
+    this.directConnectionPinPairKeys = /* @__PURE__ */ new Set();
     for (const dc of inputProblem.directConnections) {
+      this.directConnectionPinPairKeys.add(getPinPairKey(dc.pinIds));
       if (dc.netId) {
         const [a, b] = dc.pinIds;
         this.userNetIdByPinId[a] = dc.netId;
@@ -483,8 +487,9 @@ var MspConnectionPairSolver = class extends BaseSolver {
       const [pin1, pin2] = directlyConnectedPins;
       const p1 = this.pinMap[pin1];
       const p2 = this.pinMap[pin2];
-      const manhattanDist = Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y);
-      if (manhattanDist > this.maxMspPairDistance) {
+      const pinPairKey = getPinPairKey([pin1, pin2]);
+      const pairDistance = this.directConnectionPinPairKeys.has(pinPairKey) ? distance(p1, p2) : Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y);
+      if (pairDistance > this.maxMspPairDistance) {
         return;
       }
       if (arePinsInDifferentSchematicSections(this.inputProblem, p1, p2)) {
@@ -860,6 +865,68 @@ var candidateMidsFromSet = (axis, colliding, collisionRects, aabb, eps = EPS2) =
   }
 };
 
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/generateEndpointCollisionDetours.ts
+var getSegmentAxis = (start, end) => {
+  if (isVertical(start, end)) return "x";
+  if (isHorizontal(start, end)) return "y";
+  return null;
+};
+var hasOnlyNonzeroOrthogonalSegments = (path) => path.every((point, index) => {
+  const nextPoint = path[index + 1];
+  if (!nextPoint) return true;
+  if (!isHorizontal(point, nextPoint) && !isVertical(point, nextPoint)) {
+    return false;
+  }
+  return Math.abs(point.x - nextPoint.x) + Math.abs(point.y - nextPoint.y) > 0;
+});
+var generateEndpointCollisionDetours = ({
+  path,
+  collidingSegmentIndex,
+  obstacle
+}) => {
+  if (path.length !== 3) return [];
+  const lastSegmentIndex = path.length - 2;
+  if (collidingSegmentIndex !== 0 && collidingSegmentIndex !== lastSegmentIndex) {
+    return [];
+  }
+  const shouldReverse = collidingSegmentIndex === lastSegmentIndex;
+  const orderedPath = shouldReverse ? [...path].reverse() : path;
+  const [start, corner, end] = orderedPath;
+  const firstSegmentAxis = getSegmentAxis(start, corner);
+  const secondSegmentAxis = getSegmentAxis(corner, end);
+  if (!firstSegmentAxis || !secondSegmentAxis) return [];
+  if (firstSegmentAxis === secondSegmentAxis) return [];
+  const escapeCoordinates = [
+    ...midBetweenPointAndRect(secondSegmentAxis, start, obstacle),
+    ...midBetweenPointAndRect(secondSegmentAxis, end, obstacle)
+  ];
+  const detourCoordinates = [
+    ...midBetweenPointAndRect(firstSegmentAxis, start, obstacle),
+    ...midBetweenPointAndRect(firstSegmentAxis, end, obstacle)
+  ];
+  const detours = [];
+  for (const escapeCoordinate of [...new Set(escapeCoordinates)]) {
+    for (const detourCoordinate of [...new Set(detourCoordinates)]) {
+      const orderedDetour = firstSegmentAxis === "y" ? [
+        start,
+        { x: escapeCoordinate, y: start.y },
+        { x: escapeCoordinate, y: detourCoordinate },
+        { x: end.x, y: detourCoordinate },
+        end
+      ] : [
+        start,
+        { x: start.x, y: escapeCoordinate },
+        { x: detourCoordinate, y: escapeCoordinate },
+        { x: detourCoordinate, y: end.y },
+        end
+      ];
+      const detour = shouldReverse ? orderedDetour.reverse() : orderedDetour;
+      if (hasOnlyNonzeroOrthogonalSegments(detour)) detours.push(detour);
+    }
+  }
+  return detours;
+};
+
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/pathOps.ts
 var EPS3 = 1e-9;
 var shiftSegmentOrth = (pts, segIndex, axis, newCoord, eps = EPS3) => {
@@ -1210,6 +1277,29 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     let { segIndex, rect } = collision;
     const isFirstSegment = segIndex === 0;
     const isLastSegment = segIndex === path.length - 2;
+    if (path.length === 3 && (isFirstSegment || isLastSegment)) {
+      const detours = generateEndpointCollisionDetours({
+        path,
+        collidingSegmentIndex: segIndex,
+        obstacle: rect
+      }).filter((detour) => {
+        const key = pathKey(detour);
+        if (this.visited.has(key)) return false;
+        this.visited.add(key);
+        return true;
+      }).sort(
+        (a2, b2) => this.pathLength(a2) - this.pathLength(b2) || this.getPinBandPenalty(a2) - this.getPinBandPenalty(b2)
+      );
+      for (const detour of detours) {
+        const nextCollisionRects = new Set(collisionRects);
+        nextCollisionRects.add(rect);
+        this.queue.push({
+          path: detour,
+          collisionRects: nextCollisionRects
+        });
+      }
+      return;
+    }
     if (isFirstSegment) {
       if (path.length < 3) {
         return;
@@ -2961,7 +3051,7 @@ var mergeLabelGroup = (group, groupKey) => {
 };
 
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/filterLabelsAtTraceEdges.ts
-import { distance } from "@tscircuit/math-utils";
+import { distance as distance2 } from "@tscircuit/math-utils";
 var filterLabelsAtTraceEdges = ({
   labels,
   traces,
@@ -2994,8 +3084,8 @@ var filterLabelsAtTraceEdges = ({
       if (trace.tracePath.length === 0) continue;
       const startPoint = trace.tracePath[0];
       const endPoint = trace.tracePath[trace.tracePath.length - 1];
-      const startDist = distance(label.center, startPoint);
-      const endDist = distance(label.center, endPoint);
+      const startDist = distance2(label.center, startPoint);
+      const endDist = distance2(label.center, endPoint);
       if (startDist <= distanceThreshold || endDist <= distanceThreshold) {
         isNearTraceEdge = true;
         break;
@@ -4077,7 +4167,7 @@ function doesTraceOverlapWithExistingTraces(newTracePath, existingTraces) {
 
 // lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts
 var NEAREST_NEIGHBOR_COUNT = 3;
-var distance2 = (p1, p2) => {
+var distance3 = (p1, p2) => {
   return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
 };
 var LongDistancePairSolver = class extends BaseSolver {
@@ -4118,7 +4208,7 @@ var LongDistancePairSolver = class extends BaseSolver {
           return [
             {
               pin: targetPin,
-              distance: distance2(sourcePin, targetPin)
+              distance: distance3(sourcePin, targetPin)
             }
           ];
         }).sort((a, b) => a.distance - b.distance).slice(0, NEAREST_NEIGHBOR_COUNT);
@@ -4932,10 +5022,10 @@ var projectPointToPath = (point, path) => {
   let bestDistance = Number.POSITIVE_INFINITY;
   for (let i = 0; i < path.length - 1; i++) {
     const projectedPoint = projectPointToSegment(point, path[i], path[i + 1]);
-    const distance3 = getDistance2(point, projectedPoint);
-    if (distance3 < bestDistance) {
+    const distance4 = getDistance2(point, projectedPoint);
+    if (distance4 < bestDistance) {
       bestPoint = projectedPoint;
-      bestDistance = distance3;
+      bestDistance = distance4;
     }
   }
   return bestPoint;
@@ -6565,11 +6655,11 @@ var getLabelHugDistance = (tracePath, obstacleLabel) => {
     obstacleLabel.width,
     obstacleLabel.height
   );
-  let distance3 = 0;
+  let distance4 = 0;
   for (const point of tracePath) {
-    distance3 += getPointDistanceFromRect(point, bounds);
+    distance4 += getPointDistanceFromRect(point, bounds);
   }
-  return distance3;
+  return distance4;
 };
 var getPointDistanceFromRect = (point, rect) => {
   const dx = Math.max(rect.minX - point.x, 0, point.x - rect.maxX);
@@ -6846,16 +6936,16 @@ var Example28Solver = class extends BaseSolver {
     const outward = dir(label.orientation);
     if (outward.x === 0 && outward.y === 0) return null;
     for (let step = 1; step <= LABEL_MAX_OUTWARD_STEPS; step++) {
-      const distance3 = step * LABEL_OUTWARD_STEP;
+      const distance4 = step * LABEL_OUTWARD_STEP;
       const candidate = {
         ...label,
         anchorPoint: {
-          x: label.anchorPoint.x + outward.x * distance3,
-          y: label.anchorPoint.y + outward.y * distance3
+          x: label.anchorPoint.x + outward.x * distance4,
+          y: label.anchorPoint.y + outward.y * distance4
         },
         center: {
-          x: label.center.x + outward.x * distance3,
-          y: label.center.y + outward.y * distance3
+          x: label.center.x + outward.x * distance4,
+          y: label.center.y + outward.y * distance4
         }
       };
       const candidateWithClearance = {
@@ -7393,10 +7483,10 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       outwardDistance,
       phase = "shift"
     } = params;
-    for (let distance3 = LABEL_SEARCH_STEP; distance3 <= maxSearchDistance + EPS9; distance3 += LABEL_SEARCH_STEP) {
+    for (let distance4 = LABEL_SEARCH_STEP; distance4 <= maxSearchDistance + EPS9; distance4 += LABEL_SEARCH_STEP) {
       const anchorPoint = {
-        x: baseAnchor.x + direction.x * distance3,
-        y: baseAnchor.y + direction.y * distance3
+        x: baseAnchor.x + direction.x * distance4,
+        y: baseAnchor.y + direction.y * distance4
       };
       const candidate = this.createCandidate(label, anchorPoint, orientation);
       const result = this.evaluateCandidate(
@@ -7404,7 +7494,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         label,
         labelIndex,
         phase,
-        distance3,
+        distance4,
         outwardDistance
       );
       this.currentCandidateResults.push(result);
@@ -7416,11 +7506,11 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return null;
   }
-  evaluateCandidate(candidate, label, labelIndex, phase, distance3, outwardDistance) {
+  evaluateCandidate(candidate, label, labelIndex, phase, distance4, outwardDistance) {
     return {
       ...candidate,
       phase,
-      distance: distance3,
+      distance: distance4,
       outwardDistance,
       selected: false,
       status: this.getCandidateStatus({
@@ -7758,10 +7848,10 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       if (point.x < bounds.minX - EPS9 || point.x > bounds.maxX + EPS9 || point.y < bounds.minY - EPS9 || point.y > bounds.maxY + EPS9) {
         continue;
       }
-      for (const [side, distance3] of getSideDistances(point, bounds)) {
-        if (distance3 < nearestDistance) {
+      for (const [side, distance4] of getSideDistances(point, bounds)) {
+        if (distance4 < nearestDistance) {
           nearestSide = side;
-          nearestDistance = distance3;
+          nearestDistance = distance4;
         }
       }
     }
@@ -7790,10 +7880,10 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     let nearestSide = null;
     let nearestDistance = Number.POSITIVE_INFINITY;
     for (const chip of this.chipObstacleSpatialIndex.chips) {
-      for (const [side, distance3] of getSideDistances(point, chip.bounds)) {
-        if (distance3 < nearestDistance) {
+      for (const [side, distance4] of getSideDistances(point, chip.bounds)) {
+        if (distance4 < nearestDistance) {
           nearestSide = side;
-          nearestDistance = distance3;
+          nearestDistance = distance4;
         }
       }
     }
@@ -8194,17 +8284,17 @@ var getTraceLength = (trace) => {
   }
   return length;
 };
-var getPointAtTraceDistance = (trace, distance3) => {
+var getPointAtTraceDistance = (trace, distance4) => {
   let pathDistance = 0;
   for (let i = 0; i < trace.tracePath.length - 1; i++) {
     const start = trace.tracePath[i];
     const end = trace.tracePath[i + 1];
     const segmentLength = getManhattanDistance(start, end);
     const nextDistance = pathDistance + segmentLength;
-    if (distance3 <= nextDistance + EPS10) {
+    if (distance4 <= nextDistance + EPS10) {
       const offset = Math.max(
         0,
-        Math.min(segmentLength, distance3 - pathDistance)
+        Math.min(segmentLength, distance4 - pathDistance)
       );
       const direction = getSegmentDirection(start, end);
       return {
@@ -8329,13 +8419,13 @@ var getCandidateDistances = (traceLength, vertexDistances) => {
   const distances = /* @__PURE__ */ new Set();
   const maxSteps = Math.ceil(traceLength / CANDIDATE_STEP);
   for (let i = 0; i <= maxSteps; i++) {
-    const distance3 = Math.min(traceLength, i * CANDIDATE_STEP);
-    distances.add(roundDistance(distance3));
+    const distance4 = Math.min(traceLength, i * CANDIDATE_STEP);
+    distances.add(roundDistance(distance4));
   }
-  for (const distance3 of vertexDistances) {
-    distances.add(roundDistance(distance3));
+  for (const distance4 of vertexDistances) {
+    distances.add(roundDistance(distance4));
   }
-  return [...distances].filter((distance3) => distance3 >= -EPS10 && distance3 <= traceLength + EPS10).sort((a, b) => a - b);
+  return [...distances].filter((distance4) => distance4 >= -EPS10 && distance4 <= traceLength + EPS10).sort((a, b) => a - b);
 };
 var getOrientationsForPoint = (params) => {
   const { inputProblem, label, point, orientationConstraint } = params;
@@ -8513,7 +8603,7 @@ var getNetLabelHeight = (inputProblem, label) => {
     (nc) => nc.pinIds.some((pid) => label.pinIds.includes(pid))
   )?.netLabelHeight;
 };
-var roundDistance = (distance3) => Number(distance3.toFixed(6));
+var roundDistance = (distance4) => Number(distance4.toFixed(6));
 var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS10 && Math.abs(point.y - label.anchorPoint.y) <= EPS10 && orientation === label.orientation;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/visualize.ts