@tscircuit/schematic-trace-solver 0.0.32 → 0.0.34

package/dist/index.js

@@ -139,7 +139,8 @@ function getOrthogonalMinimumSpanningTree(pins, opts = {}) {
     for (let v = 0; v < n; v++) {
       if (!inTree[v]) {
         const d0 = manhattan(pins[u], pins[v]);
-        const d = d0 > maxDistance ? Number.POSITIVE_INFINITY : d0;
+        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;
@@ -150,14 +151,6 @@ function getOrthogonalMinimumSpanningTree(pins, opts = {}) {
   return edges;
 }
 
-// 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/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection.ts
 var getPinDirection = (pin, chip) => {
   const { x, y } = pin;
@@ -188,6 +181,126 @@ var getPinDirection = (pin, chip) => {
   return "x-";
 };
 
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getRestrictedCenterLines.ts
+var getRestrictedCenterLines = (params) => {
+  const { pins, inputProblem, pinIdMap, chipMap } = params;
+  const findAllDirectlyConnectedPins = (startPinId) => {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [startPinId];
+    visited.add(startPinId);
+    const directConns = inputProblem.directConnections || [];
+    while (queue.length) {
+      const cur = queue.shift();
+      for (const dc of directConns) {
+        if (dc.pinIds.includes(cur)) {
+          for (const p of dc.pinIds) {
+            if (!visited.has(p)) {
+              visited.add(p);
+              queue.push(p);
+            }
+          }
+        }
+      }
+    }
+    return visited;
+  };
+  const p0 = pins[0].pinId;
+  const p1 = pins[1].pinId;
+  const relatedPinIds = /* @__PURE__ */ new Set([
+    ...findAllDirectlyConnectedPins(p0),
+    ...findAllDirectlyConnectedPins(p1)
+  ]);
+  const restrictedCenterLines = /* @__PURE__ */ new Map();
+  const chipFacingMap = /* @__PURE__ */ new Map();
+  const chipsOfFacingPins = new Set(pins.map((p) => p.chipId));
+  for (const pinId of relatedPinIds) {
+    const pin = pinIdMap.get(pinId);
+    if (!pin) continue;
+    const chip = chipMap[pin.chipId];
+    if (!chip) continue;
+    const facing = pin._facingDirection ?? getPinDirection(pin, chip);
+    let entry = chipFacingMap.get(chip.chipId);
+    if (!entry) {
+      entry = { center: chip.center };
+      const counts = { xPos: 0, xNeg: 0, yPos: 0, yNeg: 0 };
+      for (const cp of chip.pins) {
+        const cpFacing = cp._facingDirection ?? getPinDirection(cp, chip);
+        if (cpFacing === "x+") counts.xPos++;
+        if (cpFacing === "x-") counts.xNeg++;
+        if (cpFacing === "y+") counts.yPos++;
+        if (cpFacing === "y-") counts.yNeg++;
+      }
+      entry.counts = counts;
+      chipFacingMap.set(chip.chipId, entry);
+    }
+    if (facing === "x+") entry.hasXPos = true;
+    if (facing === "x-") entry.hasXNeg = true;
+    if (facing === "y+") entry.hasYPos = true;
+    if (facing === "y-") entry.hasYNeg = true;
+  }
+  for (const [chipId, faces] of chipFacingMap) {
+    const axes = /* @__PURE__ */ new Set();
+    const rcl = { axes };
+    const counts = faces.counts;
+    const anySideHasMultiplePins = !!(counts && (counts.xPos > 1 || counts.xNeg > 1 || counts.yPos > 1 || counts.yNeg > 1));
+    const skipCenterRestriction = !anySideHasMultiplePins && chipsOfFacingPins.has(chipId);
+    if (!skipCenterRestriction) {
+      if (faces.hasXPos && faces.hasXNeg) {
+        rcl.x = faces.center.x;
+        axes.add("x");
+      }
+      if (faces.hasYPos && faces.hasYNeg) {
+        rcl.y = faces.center.y;
+        axes.add("y");
+      }
+    }
+    if (axes.size > 0) {
+      restrictedCenterLines.set(chipId, rcl);
+    }
+  }
+  return restrictedCenterLines;
+};
+
+// lib/solvers/MspConnectionPairSolver/doesPairCrossRestrictedCenterLines.ts
+var doesPairCrossRestrictedCenterLines = (params) => {
+  const { inputProblem, chipMap, pinIdMap, p1, p2 } = params;
+  const restrictedCenterLines = getRestrictedCenterLines({
+    pins: [p1, p2],
+    inputProblem,
+    pinIdMap,
+    chipMap
+  });
+  if (restrictedCenterLines.size === 0) return false;
+  const EPS4 = 1e-9;
+  const crossesSegment = (a, b) => {
+    for (const [, rcl] of restrictedCenterLines) {
+      if (rcl.axes.has("x") && typeof rcl.x === "number") {
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS4) return true;
+      }
+      if (rcl.axes.has("y") && typeof rcl.y === "number") {
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS4) return true;
+      }
+    }
+    return false;
+  };
+  if (Math.abs(p1.x - p2.x) < EPS4 || Math.abs(p1.y - p2.y) < EPS4) {
+    return crossesSegment({ x: p1.x, y: p1.y }, { x: p2.x, y: p2.y });
+  }
+  const elbowHV = { x: p2.x, y: p1.y };
+  const elbowVH = { x: p1.x, y: p2.y };
+  const hvCrosses = crossesSegment({ x: p1.x, y: p1.y }, elbowHV) || crossesSegment(elbowHV, { x: p2.x, y: p2.y });
+  const vhCrosses = crossesSegment({ x: p1.x, y: p1.y }, elbowVH) || crossesSegment(elbowVH, { x: p2.x, y: p2.y });
+  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/solvers/SchematicTracePipelineSolver/visualizeInputProblem.ts
 var visualizeInputProblem = (inputProblem, opts = {}) => {
   const { connectionAlpha = 0.8, chipAlpha = 0.8 } = opts;
@@ -328,6 +441,16 @@ var MspConnectionPairSolver = class extends BaseSolver {
       if (manhattanDist > this.maxMspPairDistance) {
         return;
       }
+      const pinIdMap2 = new Map(Object.entries(this.pinMap));
+      if (doesPairCrossRestrictedCenterLines({
+        inputProblem: this.inputProblem,
+        chipMap: this.chipMap,
+        pinIdMap: pinIdMap2,
+        p1,
+        p2
+      })) {
+        return;
+      }
       const globalConnNetId = this.globalConnMap.getNetConnectedToId(pin1);
       const userNetId = this.userNetIdByPinId[pin1] ?? this.userNetIdByPinId[pin2];
       this.mspConnectionPairs.push({
@@ -339,11 +462,32 @@ var MspConnectionPairSolver = class extends BaseSolver {
       });
       return;
     }
+    const pinIdMap = new Map(Object.entries(this.pinMap));
     const msp = getOrthogonalMinimumSpanningTree(
       directlyConnectedPins.map((p) => this.pinMap[p]).filter(Boolean),
-      { maxDistance: this.maxMspPairDistance }
+      {
+        maxDistance: this.maxMspPairDistance,
+        forbidEdge: (a, b) => doesPairCrossRestrictedCenterLines({
+          inputProblem: this.inputProblem,
+          chipMap: this.chipMap,
+          pinIdMap,
+          p1: a,
+          p2: b
+        })
+      }
     );
     for (const [pin1, pin2] of msp) {
+      const p1Obj = this.pinMap[pin1];
+      const p2Obj = this.pinMap[pin2];
+      if (doesPairCrossRestrictedCenterLines({
+        inputProblem: this.inputProblem,
+        chipMap: this.chipMap,
+        pinIdMap,
+        p1: p1Obj,
+        p2: p2Obj
+      })) {
+        continue;
+      }
       const globalConnNetId = this.globalConnMap.getNetConnectedToId(pin1);
       const userNetId = this.userNetIdByPinId[pin1] ?? this.userNetIdByPinId[pin2];
       this.mspConnectionPairs.push({
@@ -351,7 +495,7 @@ var MspConnectionPairSolver = class extends BaseSolver {
         dcConnNetId: dcNetId,
         globalConnNetId,
         userNetId,
-        pins: [this.pinMap[pin1], this.pinMap[pin2]]
+        pins: [p1Obj, p2Obj]
       });
     }
   }
@@ -382,11 +526,8 @@ var MspConnectionPairSolver = class extends BaseSolver {
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver.ts
 import "graphics-debug";
 
-// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver.ts
-import { getBounds as getBounds2 } from "graphics-debug";
-
-// lib/data-structures/ChipObstacleSpatialIndex.ts
-import Flatbush from "flatbush";
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts
+import { calculateElbow } from "calculate-elbow";
 
 // lib/solvers/GuidelinesSolver/getInputChipBounds.ts
 function getInputChipBounds(chip) {
@@ -400,460 +541,189 @@ function getInputChipBounds(chip) {
   };
 }
 
-// lib/data-structures/ChipObstacleSpatialIndex.ts
-var ChipObstacleSpatialIndex = class {
-  chips;
-  spatialIndex;
-  spatialIndexIdToChip;
-  constructor(chips) {
-    this.chips = chips.map((chip) => ({
-      ...chip,
-      bounds: getInputChipBounds(chip),
-      spatialIndexId: null
-    }));
-    this.spatialIndexIdToChip = /* @__PURE__ */ new Map();
-    this.spatialIndex = new Flatbush(chips.length);
-    for (const chip of this.chips) {
-      chip.spatialIndexId = this.spatialIndex.add(
-        chip.bounds.minX,
-        chip.bounds.minY,
-        chip.bounds.maxX,
-        chip.bounds.maxY
-      );
-      this.spatialIndexIdToChip.set(chip.spatialIndexId, chip);
-    }
-    this.spatialIndex.finish();
-  }
-  getChipsInBounds(bounds) {
-    const chipSpatialIndexIds = this.spatialIndex.search(
-      bounds.minX,
-      bounds.minY,
-      bounds.maxX,
-      bounds.maxY
-    );
-    return chipSpatialIndexIds.map((id) => this.spatialIndexIdToChip.get(id));
-  }
-  doesOrthogonalLineIntersectChip(line, opts = {}) {
-    const excludeChipIds = opts.excludeChipIds ?? [];
-    const [p1, p2] = line;
-    const { x: x1, y: y1 } = p1;
-    const { x: x2, y: y2 } = p2;
-    const chips = this.getChipsInBounds({
-      minX: Math.min(x1, x2),
-      minY: Math.min(y1, y2),
-      maxX: Math.max(x1, x2),
-      maxY: Math.max(y1, y2)
-    }).filter((chip) => !excludeChipIds.includes(chip.chipId));
-    return chips.length > 0;
-  }
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect.ts
+var chipToRect = (chip) => {
+  const b = getInputChipBounds(chip);
+  return { chipId: chip.chipId, ...b };
 };
-
-// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver.ts
-import { calculateElbow } from "calculate-elbow";
-
-// lib/utils/dir.ts
-var dir = (facingDirection) => {
-  switch (facingDirection) {
-    case "x+":
-      return { x: 1, y: 0 };
-    case "x-":
-      return { x: -1, y: 0 };
-    case "y+":
-      return { x: 0, y: 1 };
-    case "y-":
-      return { x: 0, y: -1 };
-  }
-  throw new Error(`Invalid facing direction: ${facingDirection}`);
+var getObstacleRects = (problem) => {
+  return problem.chips.map(chipToRect);
 };
 
-// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/generateElbowVariants.ts
-var EPS = 1e-6;
-var MIN_LEN = 1e-6;
-var checkIfUTurnNeeded = (elbow) => {
-  if (elbow.length !== 4) return false;
-  const [start, p1, p2, end] = elbow;
-  const startOrient = orientationOf(start, p1);
-  const startFacing = startOrient === "horizontal" ? p1.x > start.x ? "x+" : "x-" : p1.y > start.y ? "y+" : "y-";
-  const endOrient = orientationOf(p2, end);
-  const endFacing = endOrient === "horizontal" ? end.x > p2.x ? "x+" : "x-" : end.y > p2.y ? "y+" : "y-";
-  if (startFacing === "x+" && end.x < p1.x - EPS) return true;
-  if (startFacing === "x-" && end.x > p1.x + EPS) return true;
-  if (startFacing === "y+" && end.y < p1.y - EPS) return true;
-  if (startFacing === "y-" && end.y > p1.y + EPS) return true;
-  if (endFacing === "x-" && p2.x > end.x + EPS && startFacing === "x+")
-    return true;
-  if (endFacing === "x+" && p2.x < end.x - EPS && startFacing === "x-")
-    return true;
-  if (endFacing === "y-" && p2.y > end.y + EPS && startFacing === "y+")
-    return true;
-  if (endFacing === "y+" && p2.y < end.y - EPS && startFacing === "y-")
-    return true;
-  return false;
-};
-var expandToUTurn = (elbow) => {
-  if (elbow.length !== 4) return elbow;
-  const [start, p1, p2, end] = elbow;
-  const overshoot = Math.max(
-    Math.abs(start.x - p1.x),
-    Math.abs(start.y - p1.y),
-    0.2
-    // minimum overshoot
-  );
-  const startOrient = orientationOf(start, p1);
-  const expanded = [{ ...start }];
-  if (startOrient === "horizontal") {
-    const startDir = p1.x > start.x ? 1 : -1;
-    expanded.push({ x: start.x + startDir * overshoot, y: start.y });
-    const verticalSpace = Math.max(
-      overshoot * 2,
-      Math.abs(end.y - start.y) + overshoot
-    );
-    const midY = end.y > start.y ? start.y - verticalSpace : start.y + verticalSpace;
-    expanded.push({ x: start.x + startDir * overshoot, y: midY });
-    const endOrient = orientationOf(p2, end);
-    const endApproachX = endOrient === "horizontal" ? end.x > p2.x ? end.x - overshoot : end.x + overshoot : end.x;
-    expanded.push({ x: endApproachX, y: midY });
-    expanded.push({ x: endApproachX, y: end.y });
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions.ts
+var EPS = 1e-9;
+var isVertical = (a, b, eps = EPS) => Math.abs(a.x - b.x) < eps;
+var isHorizontal = (a, b, eps = EPS) => Math.abs(a.y - b.y) < eps;
+var segmentIntersectsRect = (a, b, r, eps = EPS) => {
+  const vert = isVertical(a, b, eps);
+  const horz = isHorizontal(a, b, eps);
+  if (!vert && !horz) return false;
+  if (vert) {
+    const x = a.x;
+    if (x < r.minX - eps || x > r.maxX + eps) return false;
+    const segMinY = Math.min(a.y, b.y);
+    const segMaxY = Math.max(a.y, b.y);
+    const overlap = Math.min(segMaxY, r.maxY) - Math.max(segMinY, r.minY);
+    return overlap > eps;
   } else {
-    const startDir = p1.y > start.y ? 1 : -1;
-    expanded.push({ x: start.x, y: start.y + startDir * overshoot });
-    const horizontalSpace = Math.max(
-      overshoot * 2,
-      Math.abs(end.x - start.x) + overshoot
-    );
-    const midX = end.x > start.x ? start.x - horizontalSpace : start.x + horizontalSpace;
-    expanded.push({ x: midX, y: start.y + startDir * overshoot });
-    const endOrient = orientationOf(p2, end);
-    const endApproachY = endOrient === "vertical" ? end.y > p2.y ? end.y - overshoot : end.y + overshoot : end.y;
-    expanded.push({ x: midX, y: endApproachY });
-    expanded.push({ x: end.x, y: endApproachY });
-  }
-  expanded.push({ ...end });
-  return expanded;
-};
-var isAxisAligned = (a, b) => Math.abs(a.x - b.x) < EPS || Math.abs(a.y - b.y) < EPS;
-var orientationOf = (a, b) => {
-  const dx = Math.abs(a.x - b.x);
-  const dy = Math.abs(a.y - b.y);
-  if (dx < EPS && dy >= EPS) return "vertical";
-  if (dy < EPS && dx >= EPS) return "horizontal";
-  throw new Error("Non-orthogonal or degenerate segment detected.");
-};
-var assertOrthogonalPolyline = (pts) => {
-  if (pts.length < 2) {
-    throw new Error("Polyline must have at least two points.");
+    const y = a.y;
+    if (y < r.minY - eps || y > r.maxY + eps) return false;
+    const segMinX = Math.min(a.x, b.x);
+    const segMaxX = Math.max(a.x, b.x);
+    const overlap = Math.min(segMaxX, r.maxX) - Math.max(segMinX, r.minX);
+    return overlap > eps;
   }
-  for (let i = 0; i < pts.length - 1; i++) {
-    const a = pts[i];
-    const b = pts[i + 1];
-    if (!isAxisAligned(a, b)) {
-      throw new Error("Polyline contains a non-orthogonal segment.");
-    }
-    const manhattan = Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-    if (manhattan < MIN_LEN) {
-      throw new Error("Polyline contains a near-zero length segment.");
-    }
-  }
-};
-var uniqSortedWithTol = (vals, tol = EPS) => {
-  const sorted = vals.slice().sort((a, b) => a - b);
-  const out = [];
-  for (const v of sorted) {
-    if (out.length === 0 || Math.abs(v - out[out.length - 1]) > tol) out.push(v);
-  }
-  return out;
-};
-var keyForPolyline = (pts, decimals = 9) => pts.map((p) => `${p.x.toFixed(decimals)},${p.y.toFixed(decimals)}`).join("|");
-var preprocessElbow = (pts, tol = MIN_LEN) => {
-  if (pts.length === 0) return [];
-  const out = [{ ...pts[0] }];
-  for (let i = 1; i < pts.length; i++) {
-    const p = pts[i];
-    const last = out[out.length - 1];
-    const manhattan = Math.abs(p.x - last.x) + Math.abs(p.y - last.y);
-    if (manhattan > tol) out.push({ ...p });
-  }
-  return out;
-};
-var collectAxisCandidates = (axis, guidelines, currentCoord) => {
-  const positions = [];
-  for (const g of guidelines) {
-    if (axis === "x") {
-      if (g.orientation === "vertical" && typeof g.x === "number") {
-        positions.push(g.x);
-      }
-    } else {
-      if (g.orientation === "horizontal" && typeof g.y === "number") {
-        positions.push(g.y);
-      }
-    }
-  }
-  positions.push(currentCoord);
-  return uniqSortedWithTol(positions);
-};
-var computeFreedom = (prev, start, end) => {
-  const orient = orientationOf(start, end);
-  if (orient === "horizontal") {
-    const facing = prev.y <= start.y ? "y+" : "y-";
-    return { axis: "y", facing };
-  } else {
-    const facing = prev.x <= start.x ? "x+" : "x-";
-    return { axis: "x", facing };
-  }
-};
-var cartesian = (arrays) => arrays.length === 0 ? [[]] : arrays.reduce(
-  (acc, curr) => acc.flatMap((a) => curr.map((c) => [...a, c])),
-  [[]]
-);
-var generateElbowVariants = ({
-  baseElbow,
-  guidelines,
-  maxVariants = 1e4
-}) => {
-  const elbow = preprocessElbow(baseElbow);
-  assertOrthogonalPolyline(elbow);
-  const nPts = elbow.length;
-  if (nPts < 4) {
-    return {
-      elbowVariants: [elbow.map((p) => ({ ...p }))],
-      movableSegments: []
-    };
-  } else if (nPts === 4) {
-    const needsUTurn = checkIfUTurnNeeded(elbow);
-    if (needsUTurn) {
-      const expandedElbow = expandToUTurn(elbow);
-      return generateElbowVariants({ baseElbow: expandedElbow, guidelines });
-    }
-  }
-  const firstMovableIndex = 1;
-  const lastMovableIndex = nPts - 3;
-  const movableSegments = [];
-  const movableIdx = [];
-  const axes = [];
-  const optionsPerSegment = [];
-  for (let i = firstMovableIndex; i <= lastMovableIndex; i++) {
-    const prev = elbow[i - 1];
-    const start = elbow[i];
-    const end = elbow[i + 1];
-    const next2 = elbow[i + 2];
-    const { axis, facing } = computeFreedom(prev, start, end);
-    movableSegments.push({
-      start: { ...start },
-      end: { ...end },
-      freedom: facing,
-      dir: dir(facing)
-    });
-    movableIdx.push(i);
-    axes.push(axis);
-    const currentCoord = axis === "x" ? start.x : start.y;
-    const rawCandidates = collectAxisCandidates(axis, guidelines, currentCoord);
-    const filtered = rawCandidates.filter((pos) => {
-      if (axis === "y") {
-        const lenPrev = Math.abs(prev.y - pos);
-        const lenNext = Math.abs(next2.y - pos);
-        return lenPrev > MIN_LEN && lenNext > MIN_LEN;
-      } else {
-        const lenPrev = Math.abs(prev.x - pos);
-        const lenNext = Math.abs(next2.x - pos);
-        return lenPrev > MIN_LEN && lenNext > MIN_LEN;
-      }
-    });
-    optionsPerSegment.push(filtered);
-  }
-  const combos = cartesian(optionsPerSegment);
-  const seen = /* @__PURE__ */ new Set();
-  const elbowVariants = [];
-  {
-    const key = keyForPolyline(elbow);
-    seen.add(key);
-    elbowVariants.push(elbow.map((p) => ({ ...p })));
-  }
-  for (const combo of combos) {
-    if (combo.length === 0) continue;
-    const variant = elbow.map((p) => ({ ...p }));
-    for (let k = 0; k < movableIdx.length; k++) {
-      const segIndex = movableIdx[k];
-      const axis = axes[k];
-      const newPos = combo[k];
-      if (typeof newPos !== "number" || Number.isNaN(newPos)) continue;
-      if (axis === "y") {
-        variant[segIndex] = { ...variant[segIndex], y: newPos };
-        variant[segIndex + 1] = { ...variant[segIndex + 1], y: newPos };
-      } else {
-        variant[segIndex] = { ...variant[segIndex], x: newPos };
-        variant[segIndex + 1] = { ...variant[segIndex + 1], x: newPos };
-      }
-    }
-    try {
-      assertOrthogonalPolyline(variant);
-    } catch {
-      continue;
-    }
-    const key = keyForPolyline(variant);
-    if (!seen.has(key)) {
-      seen.add(key);
-      elbowVariants.push(variant);
-      if (elbowVariants.length >= maxVariants) {
-        break;
-      }
-    }
-  }
-  return { elbowVariants, movableSegments };
-};
-
-// lib/solvers/GuidelinesSolver/visualizeGuidelines.ts
-import { getBounds } from "graphics-debug";
-var visualizeGuidelines = ({
-  guidelines,
-  graphics
-}) => {
-  const globalBounds = getBounds(graphics);
-  const boundsWidth = globalBounds.maxX - globalBounds.minX;
-  const boundsHeight = globalBounds.maxY - globalBounds.minY;
-  globalBounds.minX -= boundsWidth * 0.3;
-  globalBounds.maxX += boundsWidth * 0.3;
-  globalBounds.minY -= boundsHeight * 0.3;
-  globalBounds.maxY += boundsHeight * 0.3;
-  for (const guideline of guidelines) {
-    if (guideline.orientation === "horizontal") {
-      graphics.lines.push({
-        points: [
-          { x: globalBounds.minX, y: guideline.y },
-          { x: globalBounds.maxX, y: guideline.y }
-        ],
-        strokeColor: "rgba(0, 0, 0, 0.5)",
-        strokeDash: "2 2"
-      });
-    }
-    if (guideline.orientation === "vertical") {
-      graphics.lines.push({
-        points: [
-          { x: guideline.x, y: globalBounds.minY },
-          { x: guideline.x, y: globalBounds.maxY }
-        ],
-        strokeColor: "rgba(0, 0, 0, 0.5)",
-        strokeDash: "2 2"
-      });
-    }
-  }
-  return graphics;
-};
-
-// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getRestrictedCenterLines.ts
-var getRestrictedCenterLines = (params) => {
-  const { pins, inputProblem, pinIdMap, chipMap } = params;
-  const findAllDirectlyConnectedPins = (startPinId) => {
-    const visited = /* @__PURE__ */ new Set();
-    const queue = [startPinId];
-    visited.add(startPinId);
-    const directConns = inputProblem.directConnections || [];
-    while (queue.length) {
-      const cur = queue.shift();
-      for (const dc of directConns) {
-        if (dc.pinIds.includes(cur)) {
-          for (const p of dc.pinIds) {
-            if (!visited.has(p)) {
-              visited.add(p);
-              queue.push(p);
-            }
-          }
-        }
-      }
-    }
-    return visited;
-  };
-  const p0 = pins[0].pinId;
-  const p1 = pins[1].pinId;
-  const relatedPinIds = /* @__PURE__ */ new Set([
-    ...findAllDirectlyConnectedPins(p0),
-    ...findAllDirectlyConnectedPins(p1)
-  ]);
-  const restrictedCenterLines = /* @__PURE__ */ new Map();
-  const chipFacingMap = /* @__PURE__ */ new Map();
-  const chipsOfFacingPins = new Set(pins.map((p) => p.chipId));
-  for (const pinId of relatedPinIds) {
-    const pin = pinIdMap.get(pinId);
-    if (!pin) continue;
-    const chip = chipMap[pin.chipId];
-    if (!chip) continue;
-    const facing = pin._facingDirection ?? getPinDirection(pin, chip);
-    let entry = chipFacingMap.get(chip.chipId);
-    if (!entry) {
-      entry = { center: chip.center };
-      const counts = { xPos: 0, xNeg: 0, yPos: 0, yNeg: 0 };
-      for (const cp of chip.pins) {
-        const cpFacing = cp._facingDirection ?? getPinDirection(cp, chip);
-        if (cpFacing === "x+") counts.xPos++;
-        if (cpFacing === "x-") counts.xNeg++;
-        if (cpFacing === "y+") counts.yPos++;
-        if (cpFacing === "y-") counts.yNeg++;
+};
+var findFirstCollision = (pts, rects, opts = {}) => {
+  for (let i = 0; i < pts.length - 1; i++) {
+    const a = pts[i];
+    const b = pts[i + 1];
+    const excluded = opts.excludeRectIdsForSegment?.(i) ?? /* @__PURE__ */ new Set();
+    for (const r of rects) {
+      if (excluded.has(r.chipId)) continue;
+      if (segmentIntersectsRect(a, b, r)) {
+        return { segIndex: i, rect: r };
       }
-      entry.counts = counts;
-      chipFacingMap.set(chip.chipId, entry);
     }
-    if (facing === "x+") entry.hasXPos = true;
-    if (facing === "x-") entry.hasXNeg = true;
-    if (facing === "y+") entry.hasYPos = true;
-    if (facing === "y-") entry.hasYNeg = true;
   }
-  for (const [chipId, faces] of chipFacingMap) {
-    const axes = /* @__PURE__ */ new Set();
-    const rcl = { axes };
-    const counts = faces.counts;
-    const anySideHasMultiplePins = !!(counts && (counts.xPos > 1 || counts.xNeg > 1 || counts.yPos > 1 || counts.yNeg > 1));
-    const skipCenterRestriction = !anySideHasMultiplePins && chipsOfFacingPins.has(chipId);
-    if (!skipCenterRestriction) {
-      if (faces.hasXPos && faces.hasXNeg) {
-        rcl.x = faces.center.x;
-        axes.add("x");
-      }
-      if (faces.hasYPos && faces.hasYNeg) {
-        rcl.y = faces.center.y;
-        axes.add("y");
-      }
+  return null;
+};
+
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/mid.ts
+var EPS2 = 1e-9;
+var aabbFromPoints = (a, b) => ({
+  minX: Math.min(a.x, b.x),
+  maxX: Math.max(a.x, b.x),
+  minY: Math.min(a.y, b.y),
+  maxY: Math.max(a.y, b.y)
+});
+var midBetweenPointAndRect = (axis, p, r, eps = EPS2) => {
+  if (axis === "x") {
+    if (p.x < r.minX - eps) {
+      return [(p.x + r.minX) / 2];
+    }
+    if (p.x > r.maxX + eps) {
+      return [(p.x + r.maxX) / 2];
+    }
+    return [r.minX - 0.2, r.maxX + 0.2];
+  } else {
+    if (p.y < r.minY - eps) {
+      return [(p.y + r.minY) / 2];
     }
-    if (axes.size > 0) {
-      restrictedCenterLines.set(chipId, rcl);
+    if (p.y > r.maxY + eps) {
+      return [(p.y + r.maxY) / 2];
     }
+    return [r.minY - 0.2, r.maxY + 0.2];
   }
-  return restrictedCenterLines;
 };
+var candidateMidsFromSet = (axis, colliding, rectsById, collisionRectIds, aabb, eps = EPS2) => {
+  const setRects = [...collisionRectIds].map((id) => rectsById.get(id)).filter((r) => !!r);
+  if (axis === "x") {
+    const leftBoundaries = [aabb.minX, ...setRects.map((r) => r.maxX)].filter(
+      (v) => v < colliding.minX - eps
+    );
+    const rightBoundaries = [aabb.maxX, ...setRects.map((r) => r.minX)].filter(
+      (v) => v > colliding.maxX + eps
+    );
+    const leftNeighbor = leftBoundaries.length > 0 ? Math.max(...leftBoundaries) : void 0;
+    const rightNeighbor = rightBoundaries.length > 0 ? Math.min(...rightBoundaries) : void 0;
+    const out = [];
+    if (leftNeighbor !== void 0) {
+      out.push((leftNeighbor + colliding.minX) / 2);
+    }
+    if (rightNeighbor !== void 0) {
+      out.push((colliding.maxX + rightNeighbor) / 2);
+    }
+    return out;
+  } else {
+    const bottomBoundaries = [aabb.minY, ...setRects.map((r) => r.maxY)].filter(
+      (v) => v < colliding.minY - eps
+    );
+    const topBoundaries = [aabb.maxY, ...setRects.map((r) => r.minY)].filter(
+      (v) => v > colliding.maxY + eps
+    );
+    const bottomNeighbor = bottomBoundaries.length > 0 ? Math.max(...bottomBoundaries) : void 0;
+    const topNeighbor = topBoundaries.length > 0 ? Math.min(...topBoundaries) : void 0;
+    const out = [];
+    if (bottomNeighbor !== void 0) {
+      out.push((bottomNeighbor + colliding.minY) / 2);
+    }
+    if (topNeighbor !== void 0) {
+      out.push((colliding.maxY + topNeighbor) / 2);
+    }
+    return out;
+  }
+};
+
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/pathOps.ts
+var EPS3 = 1e-9;
+var shiftSegmentOrth = (pts, segIndex, axis, newCoord, eps = EPS3) => {
+  if (segIndex < 0 || segIndex >= pts.length - 1) return null;
+  const a = pts[segIndex];
+  const b = pts[segIndex + 1];
+  const vert = isVertical(a, b, eps);
+  const horz = isHorizontal(a, b, eps);
+  if (!vert && !horz) return null;
+  if (vert && axis !== "x") return null;
+  if (horz && axis !== "y") return null;
+  const out = pts.map((p) => ({ ...p }));
+  if (axis === "x") {
+    if (Math.abs(a.x - newCoord) < eps && Math.abs(b.x - newCoord) < eps)
+      return null;
+    out[segIndex] = { ...out[segIndex], x: newCoord };
+    out[segIndex + 1] = { ...out[segIndex + 1], x: newCoord };
+  } else {
+    if (Math.abs(a.y - newCoord) < eps && Math.abs(b.y - newCoord) < eps)
+      return null;
+    out[segIndex] = { ...out[segIndex], y: newCoord };
+    out[segIndex + 1] = { ...out[segIndex + 1], y: newCoord };
+  }
+  if (segIndex - 1 >= 0) {
+    const p = out[segIndex - 1];
+    const q = out[segIndex];
+    const manhattan = Math.abs(p.x - q.x) + Math.abs(p.y - q.y);
+    if (manhattan < eps) return null;
+  }
+  if (segIndex + 2 <= out.length - 1) {
+    const p = out[segIndex + 1];
+    const q = out[segIndex + 2];
+    const manhattan = Math.abs(p.x - q.x) + Math.abs(p.y - q.y);
+    if (manhattan < eps) return null;
+  }
+  for (let i = 0; i < out.length - 1; i++) {
+    const u = out[i];
+    const v = out[i + 1];
+    if (!isHorizontal(u, v, eps) && !isVertical(u, v, eps)) return null;
+  }
+  return out;
+};
+var pathKey = (pts, decimals = 6) => pts.map((p) => `${p.x.toFixed(decimals)},${p.y.toFixed(decimals)}`).join("|");
 
-// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver.ts
-var SchematicTraceSingleLineSolver = class extends BaseSolver {
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts
+var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
   pins;
   inputProblem;
-  guidelines;
   chipMap;
-  movableSegments;
+  obstacles;
+  rectById;
+  aabb;
   baseElbow;
-  allCandidatePaths;
-  queuedCandidatePaths;
-  chipObstacleSpatialIndex;
   solvedTracePath = null;
-  // map of pinId -> pin (with chipId attached)
-  pinIdMap = /* @__PURE__ */ new Map();
+  queue = [];
+  visited = /* @__PURE__ */ new Set();
   constructor(params) {
     super();
     this.pins = params.pins;
     this.inputProblem = params.inputProblem;
-    this.guidelines = params.guidelines;
     this.chipMap = params.chipMap;
-    this.chipObstacleSpatialIndex = this.inputProblem._chipObstacleSpatialIndex || new ChipObstacleSpatialIndex(this.inputProblem.chips);
-    if (!this.inputProblem._chipObstacleSpatialIndex) {
-      this.inputProblem._chipObstacleSpatialIndex = this.chipObstacleSpatialIndex;
-    }
-    for (const chip of this.inputProblem.chips) {
-      for (const pin of chip.pins) {
-        this.pinIdMap.set(pin.pinId, { ...pin, chipId: chip.chipId });
-      }
-    }
     for (const pin of this.pins) {
       if (!pin._facingDirection) {
         const chip = this.chipMap[pin.chipId];
         pin._facingDirection = getPinDirection(pin, chip);
       }
     }
+    this.obstacles = getObstacleRects(this.inputProblem);
+    this.rectById = new Map(this.obstacles.map((r) => [r.chipId, r]));
     const [pin1, pin2] = this.pins;
     this.baseElbow = calculateElbow(
       {
@@ -866,204 +736,130 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
         y: pin2.y,
         facingDirection: pin2._facingDirection
       },
-      {
-        overshoot: 0.2
-      }
+      { overshoot: 0.2 }
     );
-    const { elbowVariants, movableSegments } = generateElbowVariants({
-      baseElbow: this.baseElbow,
-      guidelines: this.guidelines,
-      maxVariants: 1e3
-    });
-    this.movableSegments = movableSegments;
-    const getPathLength = (pts) => {
-      let len = 0;
-      for (let i = 0; i < pts.length - 1; i++) {
-        const dx = pts[i + 1].x - pts[i].x;
-        const dy = pts[i + 1].y - pts[i].y;
-        len += Math.sqrt(dx * dx + dy * dy);
-      }
-      return len;
-    };
-    this.allCandidatePaths = [this.baseElbow, ...elbowVariants];
-    this.queuedCandidatePaths = [...this.allCandidatePaths].sort(
-      (a, b) => getPathLength(a) - getPathLength(b)
+    this.aabb = aabbFromPoints(
+      { x: pin1.x, y: pin1.y },
+      { x: pin2.x, y: pin2.y }
     );
+    this.queue.push({ path: this.baseElbow, collisionChipIds: /* @__PURE__ */ new Set() });
+    this.visited.add(pathKey(this.baseElbow));
   }
   getConstructorParams() {
     return {
       chipMap: this.chipMap,
       pins: this.pins,
-      guidelines: this.guidelines,
       inputProblem: this.inputProblem
     };
   }
+  axisOfSegment(a, b) {
+    if (isVertical(a, b)) return "x";
+    if (isHorizontal(a, b)) return "y";
+    return null;
+  }
+  pathLength(pts) {
+    let sum = 0;
+    for (let i = 0; i < pts.length - 1; i++) {
+      sum += Math.abs(pts[i + 1].x - pts[i].x) + Math.abs(pts[i + 1].y - pts[i].y);
+    }
+    return sum;
+  }
   _step() {
-    if (this.queuedCandidatePaths.length === 0) {
+    if (this.solvedTracePath) {
+      this.solved = true;
+      return;
+    }
+    const state = this.queue.shift();
+    if (!state) {
       this.failed = true;
-      this.error = "No more candidate elbows, everything had collisions";
+      this.error = "No collision-free path found";
       return;
     }
-    const nextCandidatePath = this.queuedCandidatePaths.shift();
-    const restrictedCenterLines = getRestrictedCenterLines({
-      pins: this.pins,
-      inputProblem: this.inputProblem,
-      pinIdMap: this.pinIdMap,
-      chipMap: this.chipMap
-    });
-    let pathIsValid = true;
-    for (let i = 0; i < nextCandidatePath.length - 1; i++) {
-      const start = nextCandidatePath[i];
-      const end = nextCandidatePath[i + 1];
-      let excludeChipIds = [];
-      const EPS2 = 1e-9;
-      for (const [, rcl] of restrictedCenterLines) {
-        if (rcl.axes.has("x") && typeof rcl.x === "number") {
-          if ((start.x - rcl.x) * (end.x - rcl.x) < -EPS2) {
-            pathIsValid = false;
-            break;
-          }
-        }
-        if (rcl.axes.has("y") && typeof rcl.y === "number") {
-          if ((start.y - rcl.y) * (end.y - rcl.y) < -EPS2) {
-            pathIsValid = false;
-            break;
-          }
-        }
-      }
-      if (!pathIsValid) break;
-      const isStartPin = this.pins.some(
-        (pin) => Math.abs(pin.x - start.x) < 1e-10 && Math.abs(pin.y - start.y) < 1e-10
-      );
-      const isEndPin = this.pins.some(
-        (pin) => Math.abs(pin.x - end.x) < 1e-10 && Math.abs(pin.y - end.y) < 1e-10
-      );
-      if (isStartPin) {
-        const startPin = this.pins.find(
-          (pin) => Math.abs(pin.x - start.x) < 1e-10 && Math.abs(pin.y - start.y) < 1e-10
-        );
-        if (startPin) {
-          const bounds = getInputChipBounds(this.chipMap[startPin.chipId]);
-          const dx = end.x - start.x;
-          const dy = end.y - start.y;
-          const EPS3 = 1e-9;
-          const onLeft = Math.abs(start.x - bounds.minX) < 1e-9;
-          const onRight = Math.abs(start.x - bounds.maxX) < 1e-9;
-          const onBottom = Math.abs(start.y - bounds.minY) < 1e-9;
-          const onTop = Math.abs(start.y - bounds.maxY) < 1e-9;
-          const entersInterior = onLeft && dx > EPS3 || onRight && dx < -EPS3 || onBottom && dy > EPS3 || onTop && dy < -EPS3;
-          if (entersInterior) {
-            pathIsValid = false;
-            break;
-          }
-          if (!excludeChipIds.includes(startPin.chipId)) {
-            excludeChipIds.push(startPin.chipId);
-          }
-        }
+    const { path, collisionChipIds } = state;
+    const collision = findFirstCollision(path, this.obstacles);
+    if (!collision) {
+      this.solvedTracePath = path;
+      this.solved = true;
+      return;
+    }
+    let { segIndex, rect } = collision;
+    const isFirstSegment = segIndex === 0;
+    const isLastSegment = segIndex === path.length - 2;
+    if (isFirstSegment) {
+      if (path.length < 3) {
+        return;
       }
-      if (!pathIsValid) break;
-      if (isEndPin) {
-        const endPin = this.pins.find(
-          (pin) => Math.abs(pin.x - end.x) < 1e-10 && Math.abs(pin.y - end.y) < 1e-10
-        );
-        if (endPin) {
-          const bounds = getInputChipBounds(this.chipMap[endPin.chipId]);
-          const dx = start.x - end.x;
-          const dy = start.y - end.y;
-          const EPS3 = 1e-9;
-          const onLeft = Math.abs(end.x - bounds.minX) < 1e-9;
-          const onRight = Math.abs(end.x - bounds.maxX) < 1e-9;
-          const onBottom = Math.abs(end.y - bounds.minY) < 1e-9;
-          const onTop = Math.abs(end.y - bounds.maxY) < 1e-9;
-          const entersInterior = onLeft && dx > EPS3 || onRight && dx < -EPS3 || onBottom && dy > EPS3 || onTop && dy < -EPS3;
-          if (entersInterior) {
-            pathIsValid = false;
-            break;
-          }
-          if (!excludeChipIds.includes(endPin.chipId)) {
-            excludeChipIds.push(endPin.chipId);
-          }
-        }
+      segIndex = 1;
+    } else if (isLastSegment) {
+      if (path.length < 3) {
+        return;
       }
-      if (!pathIsValid) break;
-      const obstacleOps = { excludeChipIds };
-      const intersects = this.chipObstacleSpatialIndex.doesOrthogonalLineIntersectChip(
-        [start, end],
-        obstacleOps
+      segIndex = path.length - 3;
+    }
+    const a = path[segIndex];
+    const b = path[segIndex + 1];
+    const axis = this.axisOfSegment(a, b);
+    if (!axis) {
+      return;
+    }
+    const [PA, PB] = this.pins;
+    const candidates = [];
+    if (collisionChipIds.size === 0) {
+      const m1 = midBetweenPointAndRect(axis, { x: PA.x, y: PA.y }, rect);
+      const m2 = midBetweenPointAndRect(axis, { x: PB.x, y: PB.y }, rect);
+      const allCandidates = [...m1, ...m2];
+      const uniqueCandidates = [...new Set(allCandidates)];
+      candidates.push(...uniqueCandidates);
+    } else {
+      const mids = candidateMidsFromSet(
+        axis,
+        rect,
+        this.rectById,
+        collisionChipIds,
+        this.aabb
       );
-      if (intersects) {
-        pathIsValid = false;
-        break;
-      }
+      candidates.push(...mids);
     }
-    if (pathIsValid) {
-      this.solvedTracePath = nextCandidatePath;
-      this.solved = true;
+    const newStates = [];
+    for (const coord of candidates) {
+      const newPath = shiftSegmentOrth(path, segIndex, axis, coord);
+      if (!newPath) continue;
+      const key = pathKey(newPath);
+      if (this.visited.has(key)) continue;
+      this.visited.add(key);
+      const nextSet = new Set(collisionChipIds);
+      nextSet.add(rect.chipId);
+      const len = this.pathLength(newPath);
+      newStates.push({ path: newPath, collisionRectIds: nextSet, len });
+    }
+    newStates.sort((a2, b2) => a2.len - b2.len);
+    for (const st of newStates) {
+      this.queue.push({ path: st.path, collisionChipIds: st.collisionRectIds });
     }
   }
   visualize() {
-    const graphics = visualizeInputProblem(this.inputProblem, {
+    const g = visualizeInputProblem(this.inputProblem, {
       chipAlpha: 0.1,
       connectionAlpha: 0.1
     });
-    const bounds = getBounds2(graphics);
-    const boundsWidth = bounds.maxX - bounds.minX;
-    const boundsHeight = bounds.maxY - bounds.minY;
-    visualizeGuidelines({ guidelines: this.guidelines, graphics });
-    for (const { start, end, dir: dir2 } of this.movableSegments) {
-      const mid = { x: (start.x + end.x) / 2, y: (start.y + end.y) / 2 };
-      const dist = Math.sqrt((start.x - end.x) ** 2 + (start.y - end.y) ** 2);
-      graphics.lines.push({
-        points: [start, mid, end],
-        strokeColor: "rgba(0,0,255,0.5)",
-        strokeDash: "2 2"
-      });
-      graphics.lines.push({
-        points: [
-          mid,
-          { x: mid.x + dir2.x * dist * 0.1, y: mid.y + dir2.y * dist * 0.1 }
-        ],
-        strokeColor: "rgba(0,0,255,0.5)",
-        strokeDash: "2 2"
-      });
-    }
-    if (!this.solvedTracePath) {
-      if (this.queuedCandidatePaths.length > 0) {
-        graphics.lines.push({
-          points: this.queuedCandidatePaths[0],
-          strokeColor: "orange"
-        });
-      }
-      for (let i = 1; i < this.queuedCandidatePaths.length; i++) {
-        const candidatePath = this.queuedCandidatePaths[i];
-        const pi = i / this.queuedCandidatePaths.length;
-        graphics.lines.push({
-          points: candidatePath.map((p) => ({
-            x: p.x + pi * boundsWidth * 5e-3,
-            y: p.y + pi * boundsHeight * 5e-3
-          })),
-          strokeColor: getColorFromString(
-            `${candidatePath.reduce((acc, p) => `${acc},${p.x},${p.y}`, "")}`,
-            0.5
-          ),
-          strokeDash: "8 8"
-        });
-      }
+    for (const { path, collisionChipIds: collisionRectIds } of this.queue) {
+      g.lines.push({ points: path, strokeColor: "teal", strokeDash: "2 2" });
     }
     if (this.solvedTracePath) {
-      graphics.lines.push({
-        points: this.solvedTracePath,
-        strokeColor: "green"
-      });
+      g.lines.push({ points: this.solvedTracePath, strokeColor: "green" });
+    } else if (this.queue.length > 0) {
+      g.lines.push({ points: this.queue[0].path, strokeColor: "orange" });
     }
-    return graphics;
+    return g;
   }
 };
 
+// lib/solvers/GuidelinesSolver/visualizeGuidelines.ts
+import { getBounds } from "graphics-debug";
+
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver.ts
 var SchematicTraceLinesSolver = class extends BaseSolver {
   inputProblem;
-  guidelines;
   mspConnectionPairs;
   dcConnMap;
   globalConnMap;
@@ -1078,7 +874,6 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
     this.mspConnectionPairs = params.mspConnectionPairs;
     this.dcConnMap = params.dcConnMap;
     this.globalConnMap = params.globalConnMap;
-    this.guidelines = params.guidelines;
     this.chipMap = params.chipMap;
     this.queuedConnectionPairs = [...this.mspConnectionPairs];
   }
@@ -1088,8 +883,7 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
       chipMap: this.chipMap,
       mspConnectionPairs: this.mspConnectionPairs,
       dcConnMap: this.dcConnMap,
-      globalConnMap: this.globalConnMap,
-      guidelines: this.guidelines
+      globalConnMap: this.globalConnMap
     };
   }
   _step() {
@@ -1127,11 +921,10 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
     }
     this.currentConnectionPair = connectionPair;
     const { pins } = connectionPair;
-    this.activeSubSolver = new SchematicTraceSingleLineSolver({
+    this.activeSubSolver = new SchematicTraceSingleLineSolver2({
       inputProblem: this.inputProblem,
       pins,
-      chipMap: this.chipMap,
-      guidelines: this.guidelines
+      chipMap: this.chipMap
     });
   }
   visualize() {
@@ -1142,7 +935,6 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
       chipAlpha: 0.1,
       connectionAlpha: 0.1
     });
-    visualizeGuidelines({ guidelines: this.guidelines, graphics });
     for (const { mspPairId, tracePath } of this.solvedTracePaths) {
       graphics.lines.push({
         points: tracePath,
@@ -1169,17 +961,17 @@ var applyJogToTerminalSegment = ({
   segmentIndex: si,
   offset,
   JOG_SIZE,
-  EPS: EPS2 = 1e-6
+  EPS: EPS4 = 1e-6
 }) => {
   if (si !== 0 && si !== pts.length - 2) return;
   const start = pts[si];
   const end = pts[si + 1];
-  const isVertical = Math.abs(start.x - end.x) < EPS2;
-  const isHorizontal = Math.abs(start.y - end.y) < EPS2;
-  if (!isVertical && !isHorizontal) return;
-  const segDir = isVertical ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
+  const isVertical2 = Math.abs(start.x - end.x) < EPS4;
+  const isHorizontal2 = Math.abs(start.y - end.y) < EPS4;
+  if (!isVertical2 && !isHorizontal2) return;
+  const segDir = isVertical2 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (si === 0) {
-    if (isVertical) {
+    if (isVertical2) {
       const jogY = start.y + segDir * JOG_SIZE;
       pts.splice(
         1,
@@ -1199,7 +991,7 @@ var applyJogToTerminalSegment = ({
       );
     }
   } else {
-    if (isVertical) {
+    if (isVertical2) {
       const jogY = end.y - segDir * JOG_SIZE;
       pts.splice(
         si,
@@ -1242,13 +1034,13 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
     }
   }
   _step() {
-    const EPS2 = 1e-6;
+    const EPS4 = 1e-6;
     const offsets = this.overlappingTraceSegments.map((_, idx) => {
       const n = Math.floor(idx / 2) + 1;
       const signed = idx % 2 === 0 ? -n : n;
       return signed * this.SHIFT_DISTANCE;
     });
-    const eq = (a, b) => Math.abs(a - b) < EPS2;
+    const eq = (a, b) => Math.abs(a - b) < EPS4;
     const samePoint = (p, q) => !!p && !!q && eq(p.x, q.x) && eq(p.y, q.y);
     this.overlappingTraceSegments.forEach((group, gidx) => {
       const offset = offsets[gidx];
@@ -1274,15 +1066,15 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
               segmentIndex: si,
               offset,
               JOG_SIZE,
-              EPS: EPS2
+              EPS: EPS4
             });
           } else {
             const start = pts[si];
             const end = pts[si + 1];
-            const isVertical = Math.abs(start.x - end.x) < EPS2;
-            const isHorizontal = Math.abs(start.y - end.y) < EPS2;
-            if (!isVertical && !isHorizontal) continue;
-            if (isVertical) {
+            const isVertical2 = Math.abs(start.x - end.x) < EPS4;
+            const isHorizontal2 = Math.abs(start.y - end.y) < EPS4;
+            if (!isVertical2 && !isHorizontal2) continue;
+            if (isVertical2) {
               start.x += offset;
               end.x += offset;
             } else {
@@ -1376,7 +1168,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS2 = 2e-3;
+    const EPS4 = 2e-3;
     const netIds = Object.keys(this.traceNetIslands);
     for (let i = 0; i < netIds.length; i++) {
       for (let j = i + 1; j < netIds.length; j++) {
@@ -1394,7 +1186,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           const minB = Math.min(b1, b2);
           const maxB = Math.max(b1, b2);
           const overlap = Math.min(maxA, maxB) - Math.max(minA, minB);
-          return overlap > EPS2;
+          return overlap > EPS4;
         };
         for (let pa = 0; pa < pathsA.length; pa++) {
           const pathA = pathsA[pa];
@@ -1402,8 +1194,8 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           for (let sa = 0; sa < ptsA.length - 1; sa++) {
             const a1 = ptsA[sa];
             const a2 = ptsA[sa + 1];
-            const aVert = Math.abs(a1.x - a2.x) < EPS2;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS2;
+            const aVert = Math.abs(a1.x - a2.x) < EPS4;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS4;
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
@@ -1411,11 +1203,11 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
               for (let sb = 0; sb < ptsB.length - 1; sb++) {
                 const b1 = ptsB[sb];
                 const b2 = ptsB[sb + 1];
-                const bVert = Math.abs(b1.x - b2.x) < EPS2;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS2;
+                const bVert = Math.abs(b1.x - b2.x) < EPS4;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS4;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS2) {
+                  if (Math.abs(a1.x - b1.x) < EPS4) {
                     if (overlaps1D(a1.y, a2.y, b1.y, b2.y)) {
                       const keyA = `${pa}:${sa}`;
                       const keyB = `${pb}:${sb}`;
@@ -1436,7 +1228,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     }
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS2) {
+                  if (Math.abs(a1.y - b1.y) < EPS4) {
                     if (overlaps1D(a1.x, a2.x, b1.x, b2.x)) {
                       const keyA = `${pa}:${sa}`;
                       const keyB = `${pb}:${sb}`;
@@ -1513,6 +1305,55 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
   }
 };
 
+// lib/data-structures/ChipObstacleSpatialIndex.ts
+import Flatbush from "flatbush";
+var ChipObstacleSpatialIndex = class {
+  chips;
+  spatialIndex;
+  spatialIndexIdToChip;
+  constructor(chips) {
+    this.chips = chips.map((chip) => ({
+      ...chip,
+      bounds: getInputChipBounds(chip),
+      spatialIndexId: null
+    }));
+    this.spatialIndexIdToChip = /* @__PURE__ */ new Map();
+    this.spatialIndex = new Flatbush(chips.length);
+    for (const chip of this.chips) {
+      chip.spatialIndexId = this.spatialIndex.add(
+        chip.bounds.minX,
+        chip.bounds.minY,
+        chip.bounds.maxX,
+        chip.bounds.maxY
+      );
+      this.spatialIndexIdToChip.set(chip.spatialIndexId, chip);
+    }
+    this.spatialIndex.finish();
+  }
+  getChipsInBounds(bounds) {
+    const chipSpatialIndexIds = this.spatialIndex.search(
+      bounds.minX,
+      bounds.minY,
+      bounds.maxX,
+      bounds.maxY
+    );
+    return chipSpatialIndexIds.map((id) => this.spatialIndexIdToChip.get(id));
+  }
+  doesOrthogonalLineIntersectChip(line, opts = {}) {
+    const excludeChipIds = opts.excludeChipIds ?? [];
+    const [p1, p2] = line;
+    const { x: x1, y: y1 } = p1;
+    const { x: x2, y: y2 } = p2;
+    const chips = this.getChipsInBounds({
+      minX: Math.min(x1, x2),
+      minY: Math.min(y1, y2),
+      maxX: Math.max(x1, x2),
+      maxY: Math.max(y1, y2)
+    }).filter((chip) => !excludeChipIds.includes(chip.chipId));
+    return chips.length > 0;
+  }
+};
+
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry.ts
 var NET_LABEL_HORIZONTAL_WIDTH = 0.45;
 var NET_LABEL_HORIZONTAL_HEIGHT = 0.2;
@@ -1550,24 +1391,24 @@ function getRectBounds(center, w, h) {
 }
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-function segmentIntersectsRect(p1, p2, rect, EPS2 = 1e-9) {
-  const isVert = Math.abs(p1.x - p2.x) < EPS2;
-  const isHorz = Math.abs(p1.y - p2.y) < EPS2;
+function segmentIntersectsRect2(p1, p2, rect, EPS4 = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS4;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS4;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS2 || x > rect.maxX + EPS2) return false;
+    if (x < rect.minX - EPS4 || x > rect.maxX + EPS4) return false;
     const segMinY = Math.min(p1.y, p2.y);
     const segMaxY = Math.max(p1.y, p2.y);
     const overlap = Math.min(segMaxY, rect.maxY) - Math.max(segMinY, rect.minY);
-    return overlap > EPS2;
+    return overlap > EPS4;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS2 || y > rect.maxY + EPS2) return false;
+    if (y < rect.minY - EPS4 || y > rect.maxY + EPS4) return false;
     const segMinX = Math.min(p1.x, p2.x);
     const segMaxX = Math.max(p1.x, p2.x);
     const overlap = Math.min(segMaxX, rect.maxX) - Math.max(segMinX, rect.minX);
-    return overlap > EPS2;
+    return overlap > EPS4;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -1575,7 +1416,7 @@ function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex)
     const pts = solved.tracePath;
     for (let i = 0; i < pts.length - 1; i++) {
       if (pairId === hostPathId && i === hostSegIndex) continue;
-      if (segmentIntersectsRect(pts[i], pts[i + 1], bounds))
+      if (segmentIntersectsRect2(pts[i], pts[i + 1], bounds))
         return { hasIntersection: true, mspPairId: pairId, segIndex: i };
     }
   }
@@ -1924,14 +1765,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS2 = 1e-6;
+    const EPS4 = 1e-6;
     for (const curr of tracesToScan) {
       const pts = curr.tracePath.slice();
       for (let si = 0; si < pts.length - 1; si++) {
         const a = pts[si];
         const b = pts[si + 1];
-        const isH = Math.abs(a.y - b.y) < EPS2;
-        const isV = Math.abs(a.x - b.x) < EPS2;
+        const isH = Math.abs(a.y - b.y) < EPS4;
+        const isV = Math.abs(a.x - b.x) < EPS4;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(
@@ -2086,6 +1927,12 @@ var NetLabelPlacementSolver = class extends BaseSolver {
     const { netConnMap } = getConnectivityMapsFromInputProblem(
       this.inputProblem
     );
+    const pinIdToPinMap = /* @__PURE__ */ new Map();
+    for (const chip of this.inputProblem.chips) {
+      for (const pin of chip.pins) {
+        pinIdToPinMap.set(pin.pinId, pin);
+      }
+    }
     const userNetIdByPinId = {};
     for (const dc of this.inputProblem.directConnections) {
       if (dc.netId) {
@@ -2100,10 +1947,21 @@ var NetLabelPlacementSolver = class extends BaseSolver {
       }
     }
     const groups = [];
-    for (const globalConnNetId of Object.keys(netConnMap.netMap)) {
-      const pinsInNet = netConnMap.getIdsConnectedToNet(
+    const allPinIds = this.inputProblem.chips.flatMap(
+      (c) => c.pins.map((p) => p.pinId)
+    );
+    const allGlobalConnNetIds = /* @__PURE__ */ new Set();
+    for (const pinId of allPinIds) {
+      const netId = netConnMap.getNetConnectedToId(pinId);
+      if (netId) {
+        allGlobalConnNetIds.add(netId);
+      }
+    }
+    for (const globalConnNetId of allGlobalConnNetIds) {
+      const allIdsInNet = netConnMap.getIdsConnectedToNet(
         globalConnNetId
       );
+      const pinsInNet = allIdsInNet.filter((id) => pinIdToPinMap.has(id));
       const adj = {};
       for (const pid of pinsInNet) adj[pid] = /* @__PURE__ */ new Set();
       for (const t of byGlobal[globalConnNetId] ?? []) {
@@ -2167,12 +2025,13 @@ var NetLabelPlacementSolver = class extends BaseSolver {
               )
             )
           );
-          groups.push({
+          const group = {
             globalConnNetId,
             netId: userNetId,
             overlappingTraces: rep,
             mspConnectionPairIds
-          });
+          };
+          groups.push(group);
         } else {
           for (const p of component) {
             const userNetId = userNetIdByPinId[p];
@@ -2263,187 +2122,7 @@ var NetLabelPlacementSolver = class extends BaseSolver {
 };
 
 // lib/solvers/GuidelinesSolver/GuidelinesSolver.ts
-import { getBounds as getBounds4 } from "graphics-debug";
-
-// lib/solvers/GuidelinesSolver/getGeneratorForAllChipPairs.ts
-var getGeneratorForAllChipPairs = (chips) => {
-  return (function* () {
-    for (let i = 0; i < chips.length; i++) {
-      for (let j = 0; j < chips.length; j++) {
-        if (i !== j) {
-          yield [chips[i], chips[j]];
-        }
-      }
-    }
-  })();
-};
-
-// lib/solvers/GuidelinesSolver/getHorizontalGuidelineY.ts
-function getHorizontalGuidelineY(chip1Bounds, chip2Bounds) {
-  if (chip1Bounds.maxY <= chip2Bounds.minY) {
-    return (chip1Bounds.maxY + chip2Bounds.minY) / 2;
-  }
-  if (chip2Bounds.maxY <= chip1Bounds.minY) {
-    return (chip2Bounds.maxY + chip1Bounds.minY) / 2;
-  }
-  const overlapMinY = Math.max(chip1Bounds.minY, chip2Bounds.minY);
-  const overlapMaxY = Math.min(chip1Bounds.maxY, chip2Bounds.maxY);
-  return (overlapMinY + overlapMaxY) / 2;
-}
-
-// lib/solvers/GuidelinesSolver/getVerticalGuidelineX.ts
-function getVerticalGuidelineX(chip1Bounds, chip2Bounds) {
-  if (chip1Bounds.maxX <= chip2Bounds.minX) {
-    return (chip1Bounds.maxX + chip2Bounds.minX) / 2;
-  }
-  if (chip2Bounds.maxX <= chip1Bounds.minX) {
-    return (chip2Bounds.maxX + chip1Bounds.minX) / 2;
-  }
-  const overlapMinX = Math.max(chip1Bounds.minX, chip2Bounds.minX);
-  const overlapMaxX = Math.min(chip1Bounds.maxX, chip2Bounds.maxX);
-  return (overlapMinX + overlapMaxX) / 2;
-}
-
-// lib/solvers/GuidelinesSolver/getInputProblemBounds.ts
-var getInputProblemBounds = (inputProblem) => {
-  const bounds = {
-    minX: Infinity,
-    maxX: -Infinity,
-    minY: Infinity,
-    maxY: -Infinity
-  };
-  for (const chip of inputProblem.chips) {
-    const chipBounds = getInputChipBounds(chip);
-    bounds.minX = Math.min(bounds.minX, chipBounds.minX);
-    bounds.maxX = Math.max(bounds.maxX, chipBounds.maxX);
-    bounds.minY = Math.min(bounds.minY, chipBounds.minY);
-    bounds.maxY = Math.max(bounds.maxY, chipBounds.maxY);
-  }
-  return bounds;
-};
-
-// lib/solvers/GuidelinesSolver/GuidelinesSolver.ts
-var GUIDELINE_PADDING_FROM_PROBLEM_BOUNDS = 0.1;
-var GuidelinesSolver = class extends BaseSolver {
-  inputProblem;
-  guidelines;
-  chipPairsGenerator;
-  usedXGuidelines;
-  usedYGuidelines;
-  constructor(params) {
-    super();
-    this.inputProblem = params.inputProblem;
-    const inputProblemBounds = getInputProblemBounds(this.inputProblem);
-    this.guidelines = [
-      {
-        orientation: "horizontal",
-        y: inputProblemBounds.minY - GUIDELINE_PADDING_FROM_PROBLEM_BOUNDS,
-        x: void 0
-      },
-      {
-        orientation: "horizontal",
-        y: inputProblemBounds.maxY + GUIDELINE_PADDING_FROM_PROBLEM_BOUNDS,
-        x: void 0
-      },
-      {
-        orientation: "vertical",
-        y: void 0,
-        x: inputProblemBounds.minX - GUIDELINE_PADDING_FROM_PROBLEM_BOUNDS
-      },
-      {
-        orientation: "vertical",
-        y: void 0,
-        x: inputProblemBounds.maxX + GUIDELINE_PADDING_FROM_PROBLEM_BOUNDS
-      }
-    ];
-    this.chipPairsGenerator = getGeneratorForAllChipPairs(
-      this.inputProblem.chips
-    );
-    this.usedXGuidelines = /* @__PURE__ */ new Set();
-    this.usedYGuidelines = /* @__PURE__ */ new Set();
-  }
-  getConstructorParams() {
-    return {
-      inputProblem: this.inputProblem
-    };
-  }
-  _step() {
-    const { done, value: chipPair } = this.chipPairsGenerator.next();
-    if (done) {
-      this.solved = true;
-      return;
-    }
-    const [chip1, chip2] = chipPair;
-    const chip1Bounds = getInputChipBounds(chip1);
-    const chip2Bounds = getInputChipBounds(chip2);
-    const horizontalGuidelineY = getHorizontalGuidelineY(
-      chip1Bounds,
-      chip2Bounds
-    );
-    const verticalGuidelineX = getVerticalGuidelineX(chip1Bounds, chip2Bounds);
-    if (!this.usedYGuidelines.has(horizontalGuidelineY)) {
-      this.usedYGuidelines.add(horizontalGuidelineY);
-      this.guidelines.push({
-        orientation: "horizontal",
-        y: horizontalGuidelineY,
-        x: void 0
-      });
-    }
-    if (!this.usedXGuidelines.has(verticalGuidelineX)) {
-      this.usedXGuidelines.add(verticalGuidelineX);
-      this.guidelines.push({
-        orientation: "vertical",
-        y: void 0,
-        x: verticalGuidelineX
-      });
-    }
-  }
-  visualize() {
-    const graphics = visualizeInputProblem(this.inputProblem);
-    const bounds = getBounds4(graphics);
-    const boundsWidth = bounds.maxX - bounds.minX;
-    const boundsHeight = bounds.maxY - bounds.minY;
-    bounds.minX -= boundsWidth * 0.3;
-    bounds.maxX += boundsWidth * 0.3;
-    bounds.minY -= boundsHeight * 0.3;
-    bounds.maxY += boundsHeight * 0.3;
-    for (const guideline of this.guidelines) {
-      if (guideline.orientation === "horizontal") {
-        graphics.lines.push({
-          points: [
-            {
-              x: bounds.minX,
-              y: guideline.y
-            },
-            {
-              x: bounds.maxX,
-              y: guideline.y
-            }
-          ],
-          strokeColor: "rgba(0, 0, 0, 0.5)",
-          strokeDash: "2 2"
-        });
-      }
-      if (guideline.orientation === "vertical") {
-        graphics.lines.push({
-          points: [
-            {
-              x: guideline.x,
-              y: bounds.minY
-            },
-            {
-              x: guideline.x,
-              y: bounds.maxY
-            }
-          ],
-          strokeColor: "rgba(0, 0, 0, 0.5)",
-          strokeDash: "2 2"
-        });
-      }
-    }
-    return graphics;
-  }
-};
+import { getBounds as getBounds3 } from "graphics-debug";
 
 // lib/solvers/SchematicTracePipelineSolver/correctPinsInsideChip.ts
 var correctPinsInsideChips = (problem) => {
@@ -2507,7 +2186,7 @@ function definePipelineStep(solverName, solverClass, getConstructorParams, opts
 }
 var SchematicTracePipelineSolver = class extends BaseSolver {
   mspConnectionPairSolver;
-  guidelinesSolver;
+  // guidelinesSolver?: GuidelinesSolver
   schematicTraceLinesSolver;
   traceOverlapShiftSolver;
   netLabelPlacementSolver;
@@ -2526,19 +2205,18 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         }
       }
     ),
-    definePipelineStep(
-      "guidelinesSolver",
-      GuidelinesSolver,
-      () => [
-        {
-          inputProblem: this.inputProblem
-        }
-      ],
-      {
-        onSolved: (guidelinesSolver) => {
-        }
-      }
-    ),
+    // definePipelineStep(
+    //   "guidelinesSolver",
+    //   GuidelinesSolver,
+    //   () => [
+    //     {
+    //       inputProblem: this.inputProblem,
+    //     },
+    //   ],
+    //   {
+    //     onSolved: (guidelinesSolver) => {},
+    //   },
+    // ),
     definePipelineStep(
       "schematicTraceLinesSolver",
       SchematicTraceLinesSolver,
@@ -2548,7 +2226,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           dcConnMap: this.mspConnectionPairSolver.dcConnMap,
           globalConnMap: this.mspConnectionPairSolver.globalConnMap,
           inputProblem: this.inputProblem,
-          guidelines: this.guidelinesSolver.guidelines,
+          // guidelines: this.guidelinesSolver!.guidelines,
           chipMap: this.mspConnectionPairSolver.chipMap
         }
       ],
@@ -2695,5 +2373,6 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   }
 };
 export {
-  SchematicTracePipelineSolver
+  SchematicTracePipelineSolver,
+  SchematicTraceSingleLineSolver2
 };