@tscircuit/schematic-trace-solver 0.0.7 → 0.0.9

package/dist/index.js

@@ -6694,12 +6694,33 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
       return;
     }
     const nextCandidatePath = this.queuedCandidatePaths.shift();
-    const obstacleOps = {
-      excludeChipIds: [this.pins[0].chipId, this.pins[1].chipId]
-    };
     for (let i = 0; i < nextCandidatePath.length - 1; i++) {
       const start = nextCandidatePath[i];
       const end = nextCandidatePath[i + 1];
+      let excludeChipIds = [];
+      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 && !excludeChipIds.includes(startPin.chipId)) {
+          excludeChipIds.push(startPin.chipId);
+        }
+      }
+      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 && !excludeChipIds.includes(endPin.chipId)) {
+          excludeChipIds.push(endPin.chipId);
+        }
+      }
+      const obstacleOps = { excludeChipIds };
       const intersects = this.chipObstacleSpatialIndex.doesOrthogonalLineIntersectChip(
         [start, end],
         obstacleOps
@@ -6780,6 +6801,7 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
   chipMap;
   currentConnectionPair = null;
   solvedTracePaths = [];
+  failedConnectionPairs = [];
   constructor(params) {
     super();
     this.inputProblem = params.inputProblem;
@@ -6810,9 +6832,14 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
       this.currentConnectionPair = null;
     }
     if (this.activeSubSolver?.failed) {
-      this.failed = true;
-      this.error = this.activeSubSolver.error;
-      return;
+      if (this.currentConnectionPair) {
+        this.failedConnectionPairs.push({
+          ...this.currentConnectionPair,
+          error: this.activeSubSolver.error || void 0
+        });
+      }
+      this.activeSubSolver = null;
+      this.currentConnectionPair = null;
     }
     if (this.activeSubSolver) {
       this.activeSubSolver.step();
@@ -6848,6 +6875,17 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
         strokeColor: "green"
       });
     }
+    for (const pair of this.failedConnectionPairs) {
+      graphics.lines.push({
+        points: [
+          { x: pair.pins[0].x, y: pair.pins[0].y },
+          { x: pair.pins[1].x, y: pair.pins[1].y }
+        ],
+        strokeColor: "red",
+        strokeDash: "4 2",
+        strokeWidth: 4e-3
+      });
+    }
     return graphics;
   }
 };
@@ -7150,9 +7188,292 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
   }
 };
 
-// lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver.ts
+// lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry.ts
 var NET_LABEL_HORIZONTAL_WIDTH = 0.4;
 var NET_LABEL_HORIZONTAL_HEIGHT = 0.2;
+function getDimsForOrientation(orientation) {
+  if (orientation === "y+" || orientation === "y-") {
+    return {
+      width: NET_LABEL_HORIZONTAL_HEIGHT,
+      height: NET_LABEL_HORIZONTAL_WIDTH
+    };
+  }
+  return {
+    width: NET_LABEL_HORIZONTAL_WIDTH,
+    height: NET_LABEL_HORIZONTAL_HEIGHT
+  };
+}
+function getCenterFromAnchor(anchor, orientation, width, height) {
+  switch (orientation) {
+    case "x+":
+      return { x: anchor.x + width / 2, y: anchor.y };
+    case "x-":
+      return { x: anchor.x - width / 2, y: anchor.y };
+    case "y+":
+      return { x: anchor.x, y: anchor.y + height / 2 };
+    case "y-":
+      return { x: anchor.x, y: anchor.y - height / 2 };
+  }
+}
+function getRectBounds(center, w, h) {
+  return {
+    minX: center.x - w / 2,
+    minY: center.y - h / 2,
+    maxX: center.x + w / 2,
+    maxY: center.y + h / 2
+  };
+}
+
+// lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
+function segmentIntersectsRect(p1, p2, rect, EPS = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS;
+  if (!isVert && !isHorz) return false;
+  if (isVert) {
+    const x = p1.x;
+    if (x < rect.minX - EPS || x > rect.maxX + EPS) 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 > EPS;
+  } else {
+    const y = p1.y;
+    if (y < rect.minY - EPS || y > rect.maxY + EPS) 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 > EPS;
+  }
+}
+function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
+  for (const [pairId, solved] of Object.entries(inputTraceMap)) {
+    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)) return true;
+    }
+  }
+  return false;
+}
+
+// lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/host.ts
+function lengthOfTrace(path) {
+  let sum = 0;
+  const pts = path.tracePath;
+  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;
+}
+function chooseHostTraceForGroup(params) {
+  const { inputProblem, inputTraceMap, globalConnNetId, fallbackTrace } = params;
+  const chipsById = Object.fromEntries(
+    inputProblem.chips.map((c) => [c.chipId, c])
+  );
+  const groupTraces = Object.values(inputTraceMap).filter(
+    (t) => t.globalConnNetId === globalConnNetId
+  );
+  const chipIdsInGroup = /* @__PURE__ */ new Set();
+  for (const t of groupTraces) {
+    chipIdsInGroup.add(t.pins[0].chipId);
+    chipIdsInGroup.add(t.pins[1].chipId);
+  }
+  let largestChipId = null;
+  let largestPinCount = -1;
+  for (const id of chipIdsInGroup) {
+    const chip = chipsById[id];
+    const count = chip?.pins?.length ?? 0;
+    if (count > largestPinCount) {
+      largestPinCount = count;
+      largestChipId = id;
+    }
+  }
+  const hostCandidates = largestChipId == null ? [] : groupTraces.filter(
+    (t) => t.pins[0].chipId === largestChipId || t.pins[1].chipId === largestChipId
+  );
+  if (hostCandidates.length > 0) {
+    return hostCandidates.reduce(
+      (a, b) => lengthOfTrace(a) >= lengthOfTrace(b) ? a : b
+    );
+  }
+  return fallbackTrace;
+}
+
+// lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/anchors.ts
+function anchorsForSegment(a, b) {
+  return [
+    { x: a.x, y: a.y },
+    { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 },
+    { x: b.x, y: b.y }
+  ];
+}
+
+// lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/solvePortOnlyPin.ts
+function solveNetLabelPlacementForPortOnlyPin(params) {
+  const {
+    inputProblem,
+    inputTraceMap,
+    chipObstacleSpatialIndex,
+    overlappingSameNetTraceGroup,
+    availableOrientations
+  } = params;
+  const pinId = overlappingSameNetTraceGroup.portOnlyPinId;
+  if (!pinId) {
+    return {
+      placement: null,
+      testedCandidates: [],
+      error: "No portOnlyPinId provided"
+    };
+  }
+  let pin = null;
+  for (const chip of inputProblem.chips) {
+    const p = chip.pins.find((pp) => pp.pinId === pinId);
+    if (p) {
+      pin = { x: p.x, y: p.y };
+      break;
+    }
+  }
+  if (!pin) {
+    return {
+      placement: null,
+      testedCandidates: [],
+      error: `Port-only pin not found: ${pinId}`
+    };
+  }
+  const orientations = availableOrientations.length > 0 ? availableOrientations : ["x+", "x-", "y+", "y-"];
+  const anchor = { x: pin.x, y: pin.y };
+  const outwardOf = (o) => o === "x+" ? { x: 1, y: 0 } : o === "x-" ? { x: -1, y: 0 } : o === "y+" ? { x: 0, y: 1 } : { x: 0, y: -1 };
+  const testedCandidates = [];
+  for (const orientation of orientations) {
+    const { width, height } = getDimsForOrientation(orientation);
+    const baseCenter = getCenterFromAnchor(anchor, orientation, width, height);
+    const outward = outwardOf(orientation);
+    const offset = 1e-3;
+    const center = {
+      x: baseCenter.x + outward.x * offset,
+      y: baseCenter.y + outward.y * offset
+    };
+    const bounds = getRectBounds(center, width, height);
+    const chips = chipObstacleSpatialIndex.getChipsInBounds(bounds);
+    if (chips.length > 0) {
+      testedCandidates.push({
+        center,
+        width,
+        height,
+        bounds,
+        anchor,
+        orientation,
+        status: "chip-collision",
+        hostSegIndex: -1
+      });
+      continue;
+    }
+    if (rectIntersectsAnyTrace(
+      bounds,
+      inputTraceMap,
+      "",
+      -1
+    )) {
+      testedCandidates.push({
+        center,
+        width,
+        height,
+        bounds,
+        anchor,
+        orientation,
+        status: "trace-collision",
+        hostSegIndex: -1
+      });
+      continue;
+    }
+    testedCandidates.push({
+      center,
+      width,
+      height,
+      bounds,
+      anchor,
+      orientation,
+      status: "ok",
+      hostSegIndex: -1
+    });
+    const placement = {
+      globalConnNetId: overlappingSameNetTraceGroup.globalConnNetId,
+      dcConnNetId: void 0,
+      orientation,
+      anchorPoint: anchor,
+      width,
+      height,
+      center
+    };
+    return { placement, testedCandidates };
+  }
+  return {
+    placement: null,
+    testedCandidates,
+    error: "Could not place net label at port without collisions"
+  };
+}
+
+// lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver_visualize.ts
+function visualizeSingleNetLabelPlacementSolver(solver) {
+  const graphics = visualizeInputProblem(solver.inputProblem);
+  const groupId = solver.overlappingSameNetTraceGroup.globalConnNetId;
+  const host = chooseHostTraceForGroup({
+    inputProblem: solver.inputProblem,
+    inputTraceMap: solver.inputTraceMap,
+    globalConnNetId: groupId,
+    fallbackTrace: solver.overlappingSameNetTraceGroup.overlappingTraces
+  });
+  const groupStroke = getColorFromString(groupId, 0.9);
+  const groupFill = getColorFromString(groupId, 0.5);
+  for (const trace of Object.values(solver.inputTraceMap)) {
+    if (trace.globalConnNetId !== groupId) continue;
+    const isHost = host ? trace.mspPairId === host.mspPairId : false;
+    graphics.lines.push({
+      points: trace.tracePath,
+      strokeColor: isHost ? groupStroke : groupFill,
+      strokeWidth: isHost ? 6e-3 : 3e-3,
+      strokeDash: isHost ? void 0 : "4 2"
+    });
+  }
+  for (const c of solver.testedCandidates) {
+    const fill = c.status === "ok" ? "rgba(0, 180, 0, 0.25)" : c.status === "chip-collision" ? "rgba(220, 0, 0, 0.25)" : c.status === "trace-collision" ? "rgba(220, 140, 0, 0.25)" : "rgba(120, 120, 120, 0.15)";
+    const stroke = c.status === "ok" ? "green" : c.status === "chip-collision" ? "red" : c.status === "trace-collision" ? "orange" : "gray";
+    graphics.rects.push({
+      center: {
+        x: (c.bounds.minX + c.bounds.maxX) / 2,
+        y: (c.bounds.minY + c.bounds.maxY) / 2
+      },
+      width: c.width,
+      height: c.height,
+      fill,
+      strokeColor: stroke
+    });
+    graphics.points.push({
+      x: c.anchor.x,
+      y: c.anchor.y,
+      color: stroke
+    });
+  }
+  if (solver.netLabelPlacement) {
+    const p = solver.netLabelPlacement;
+    graphics.rects.push({
+      center: p.center,
+      width: p.width,
+      height: p.height,
+      fill: "rgba(0, 128, 255, 0.35)",
+      strokeColor: "blue"
+    });
+    graphics.points.push({
+      x: p.anchorPoint.x,
+      y: p.anchorPoint.y,
+      color: "blue"
+    });
+  }
+  return graphics;
+}
+
+// lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver.ts
 var SingleNetLabelPlacementSolver = class extends BaseSolver {
   inputProblem;
   inputTraceMap;
@@ -7169,260 +7490,127 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     this.availableOrientations = params.availableOrientations;
     this.chipObstacleSpatialIndex = params.inputProblem._chipObstacleSpatialIndex ?? new ChipObstacleSpatialIndex(params.inputProblem.chips);
   }
-  getDimsForOrientation(orientation) {
-    if (orientation === "y+" || orientation === "y-") {
-      return {
-        width: NET_LABEL_HORIZONTAL_HEIGHT,
-        height: NET_LABEL_HORIZONTAL_WIDTH
-      };
-    }
-    return {
-      width: NET_LABEL_HORIZONTAL_WIDTH,
-      height: NET_LABEL_HORIZONTAL_HEIGHT
-    };
-  }
-  getCenterFromAnchor(anchor, orientation, width, height) {
-    switch (orientation) {
-      case "x+":
-        return { x: anchor.x + width / 2, y: anchor.y };
-      case "x-":
-        return { x: anchor.x - width / 2, y: anchor.y };
-      case "y+":
-        return { x: anchor.x, y: anchor.y + height / 2 };
-      case "y-":
-        return { x: anchor.x, y: anchor.y - height / 2 };
-    }
-  }
-  getRectBounds(center, w, h) {
-    return {
-      minX: center.x - w / 2,
-      minY: center.y - h / 2,
-      maxX: center.x + w / 2,
-      maxY: center.y + h / 2
-    };
-  }
-  segmentIntersectsRect(p1, p2, rect, EPS = 1e-9) {
-    const isVert = Math.abs(p1.x - p2.x) < EPS;
-    const isHorz = Math.abs(p1.y - p2.y) < EPS;
-    if (!isVert && !isHorz) return false;
-    if (isVert) {
-      const x = p1.x;
-      if (x < rect.minX - EPS || x > rect.maxX + EPS) 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 > EPS;
-    } else {
-      const y = p1.y;
-      if (y < rect.minY - EPS || y > rect.maxY + EPS) 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 > EPS;
-    }
-  }
-  rectIntersectsAnyTrace(bounds, hostPathId, hostSegIndex) {
-    for (const [pairId, solved] of Object.entries(this.inputTraceMap)) {
-      const pts = solved.tracePath;
-      for (let i = 0; i < pts.length - 1; i++) {
-        if (pairId === hostPathId && i === hostSegIndex) continue;
-        if (this.segmentIntersectsRect(pts[i], pts[i + 1], bounds))
-          return true;
-      }
-    }
-    return false;
-  }
   _step() {
     if (this.netLabelPlacement) {
       this.solved = true;
       return;
     }
     if (this.overlappingSameNetTraceGroup.portOnlyPinId) {
-      const pinId = this.overlappingSameNetTraceGroup.portOnlyPinId;
-      let pin = null;
-      for (const chip of this.inputProblem.chips) {
-        const p = chip.pins.find((pp) => pp.pinId === pinId);
-        if (p) {
-          pin = { x: p.x, y: p.y };
-          break;
-        }
-      }
-      if (!pin) {
-        this.failed = true;
-        this.error = `Port-only pin not found: ${pinId}`;
-        return;
-      }
-      const orientations2 = this.availableOrientations.length > 0 ? this.availableOrientations : ["x+", "x-", "y+", "y-"];
-      const anchor = { x: pin.x, y: pin.y };
-      const outwardOf = (o) => o === "x+" ? { x: 1, y: 0 } : o === "x-" ? { x: -1, y: 0 } : o === "y+" ? { x: 0, y: 1 } : { x: 0, y: -1 };
-      for (const orientation of orientations2) {
-        const { width, height } = this.getDimsForOrientation(orientation);
-        const baseCenter = this.getCenterFromAnchor(
-          anchor,
-          orientation,
-          width,
-          height
-        );
-        const outward = outwardOf(orientation);
-        const offset = 1e-3;
-        const center = {
-          x: baseCenter.x + outward.x * offset,
-          y: baseCenter.y + outward.y * offset
-        };
-        const bounds = this.getRectBounds(center, width, height);
-        const chips = this.chipObstacleSpatialIndex.getChipsInBounds(bounds);
-        if (chips.length > 0) {
-          this.testedCandidates.push({
-            center,
-            width,
-            height,
-            bounds,
-            anchor,
-            orientation,
-            status: "chip-collision",
-            hostSegIndex: -1
-          });
-          continue;
-        }
-        if (this.rectIntersectsAnyTrace(bounds, "", -1)) {
-          this.testedCandidates.push({
-            center,
-            width,
-            height,
-            bounds,
-            anchor,
-            orientation,
-            status: "trace-collision",
-            hostSegIndex: -1
-          });
-          continue;
-        }
-        this.testedCandidates.push({
-          center,
-          width,
-          height,
-          bounds,
-          anchor,
-          orientation,
-          status: "ok",
-          hostSegIndex: -1
-        });
-        this.netLabelPlacement = {
-          globalConnNetId: this.overlappingSameNetTraceGroup.globalConnNetId,
-          dcConnNetId: void 0,
-          orientation,
-          anchorPoint: anchor,
-          width,
-          height,
-          center
-        };
+      const res = solveNetLabelPlacementForPortOnlyPin({
+        inputProblem: this.inputProblem,
+        inputTraceMap: this.inputTraceMap,
+        chipObstacleSpatialIndex: this.chipObstacleSpatialIndex,
+        overlappingSameNetTraceGroup: this.overlappingSameNetTraceGroup,
+        availableOrientations: this.availableOrientations
+      });
+      this.testedCandidates.push(...res.testedCandidates);
+      if (res.placement) {
+        this.netLabelPlacement = res.placement;
         this.solved = true;
         return;
       }
       this.failed = true;
-      this.error = "Could not place net label at port without collisions";
+      this.error = res.error ?? "Could not place net label at port without collisions";
       return;
     }
     const groupId = this.overlappingSameNetTraceGroup.globalConnNetId;
-    const chipsById = Object.fromEntries(
-      this.inputProblem.chips.map((c) => [c.chipId, c])
-    );
-    const groupTraces = Object.values(this.inputTraceMap).filter(
-      (t) => t.globalConnNetId === groupId
-    );
-    const chipIdsInGroup = /* @__PURE__ */ new Set();
-    for (const t of groupTraces) {
-      chipIdsInGroup.add(t.pins[0].chipId);
-      chipIdsInGroup.add(t.pins[1].chipId);
-    }
-    let largestChipId = null;
-    let largestPinCount = -1;
-    for (const id of chipIdsInGroup) {
-      const chip = chipsById[id];
-      const count = chip?.pins?.length ?? 0;
-      if (count > largestPinCount) {
-        largestPinCount = count;
-        largestChipId = id;
-      }
-    }
-    const lengthOf = (path) => {
-      let sum = 0;
-      const pts2 = path.tracePath;
-      for (let i = 0; i < pts2.length - 1; i++) {
-        sum += Math.abs(pts2[i + 1].x - pts2[i].x) + Math.abs(pts2[i + 1].y - pts2[i].y);
-      }
-      return sum;
-    };
-    const hostCandidates = largestChipId == null ? [] : groupTraces.filter(
-      (t) => t.pins[0].chipId === largestChipId || t.pins[1].chipId === largestChipId
-    );
-    let host = hostCandidates.length > 0 ? hostCandidates.reduce((a, b) => lengthOf(a) >= lengthOf(b) ? a : b) : this.overlappingSameNetTraceGroup.overlappingTraces;
+    let host = chooseHostTraceForGroup({
+      inputProblem: this.inputProblem,
+      inputTraceMap: this.inputTraceMap,
+      globalConnNetId: groupId,
+      fallbackTrace: this.overlappingSameNetTraceGroup.overlappingTraces
+    });
     if (!host) {
       this.failed = true;
       this.error = "No host trace found for net label placement";
       return;
     }
-    let pts = host.tracePath.slice();
-    if (largestChipId && host) {
-      const largePin = host.pins[0].chipId === largestChipId ? host.pins[0] : host.pins[1];
-      const d0 = Math.abs(pts[0].x - largePin.x) + Math.abs(pts[0].y - largePin.y);
-      const dL = Math.abs(pts[pts.length - 1].x - largePin.x) + Math.abs(pts[pts.length - 1].y - largePin.y);
-      if (d0 > dL) {
-        pts = pts.slice().reverse();
-      }
-    }
+    const tracesToScanBase = Object.values(this.inputTraceMap).filter(
+      (t) => t.globalConnNetId === groupId
+    );
+    const tracesToScan = this.availableOrientations.length === 1 ? [
+      host,
+      ...tracesToScanBase.filter((t) => t.mspPairId !== host.mspPairId)
+    ] : [host];
     const orientations = this.availableOrientations.length > 0 ? this.availableOrientations : ["x+", "x-", "y+", "y-"];
+    const singleOrientationMode = this.availableOrientations.length === 1;
+    const scoreFor = (orientation, anchor) => {
+      switch (orientation) {
+        case "y+":
+          return anchor.y;
+        case "y-":
+          return -anchor.y;
+        case "x+":
+          return anchor.x;
+        case "x-":
+          return -anchor.x;
+      }
+    };
+    let bestCandidate = null;
+    let bestScore = -Infinity;
     const EPS = 1e-6;
-    const anchorsForSegment = (a, b) => {
-      return [
-        { x: a.x, y: a.y },
-        { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 },
-        { x: b.x, y: b.y }
-      ];
-    };
-    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) < EPS;
-      const isV = Math.abs(a.x - b.x) < EPS;
-      if (!isH && !isV) continue;
-      const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
-      const candidateOrients = orientations.filter(
-        (o) => segmentAllowed.includes(o)
-      );
-      if (candidateOrients.length === 0) continue;
-      const anchors = anchorsForSegment(a, b);
-      for (const anchor of anchors) {
-        for (const orientation of candidateOrients) {
-          const { width, height } = this.getDimsForOrientation(orientation);
-          const center = this.getCenterFromAnchor(
-            anchor,
-            orientation,
-            width,
-            height
-          );
-          const outward = orientation === "x+" ? { x: 1, y: 0 } : orientation === "x-" ? { x: -1, y: 0 } : orientation === "y+" ? { x: 0, y: 1 } : { x: 0, y: -1 };
-          const offset = 1e-4;
-          const testCenter = {
-            x: center.x + outward.x * offset,
-            y: center.y + outward.y * offset
-          };
-          const bounds = this.getRectBounds(testCenter, width, height);
-          const chips = this.chipObstacleSpatialIndex.getChipsInBounds(bounds);
-          if (chips.length > 0) {
-            this.testedCandidates.push({
-              center: testCenter,
-              width,
-              height,
-              bounds,
+    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) < EPS;
+        const isV = Math.abs(a.x - b.x) < EPS;
+        if (!isH && !isV) continue;
+        const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
+        const candidateOrients = orientations.filter(
+          (o) => segmentAllowed.includes(o)
+        );
+        if (candidateOrients.length === 0) continue;
+        const anchors = anchorsForSegment(a, b);
+        for (const anchor of anchors) {
+          for (const orientation of candidateOrients) {
+            const { width, height } = getDimsForOrientation(orientation);
+            const center = getCenterFromAnchor(
               anchor,
               orientation,
-              status: "chip-collision",
-              hostSegIndex: si
-            });
-            continue;
-          }
-          if (this.rectIntersectsAnyTrace(bounds, host.mspPairId, si)) {
+              width,
+              height
+            );
+            const outward = orientation === "x+" ? { x: 1, y: 0 } : orientation === "x-" ? { x: -1, y: 0 } : orientation === "y+" ? { x: 0, y: 1 } : { x: 0, y: -1 };
+            const offset = 1e-4;
+            const testCenter = {
+              x: center.x + outward.x * offset,
+              y: center.y + outward.y * offset
+            };
+            const bounds = getRectBounds(testCenter, width, height);
+            const chips = this.chipObstacleSpatialIndex.getChipsInBounds(bounds);
+            if (chips.length > 0) {
+              this.testedCandidates.push({
+                center: testCenter,
+                width,
+                height,
+                bounds,
+                anchor,
+                orientation,
+                status: "chip-collision",
+                hostSegIndex: si
+              });
+              continue;
+            }
+            if (rectIntersectsAnyTrace(
+              bounds,
+              this.inputTraceMap,
+              curr.mspPairId,
+              si
+            )) {
+              this.testedCandidates.push({
+                center: testCenter,
+                width,
+                height,
+                bounds,
+                anchor,
+                orientation,
+                status: "trace-collision",
+                hostSegIndex: si
+              });
+              continue;
+            }
             this.testedCandidates.push({
               center: testCenter,
               width,
@@ -7430,121 +7618,58 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
               bounds,
               anchor,
               orientation,
-              status: "trace-collision",
+              status: "ok",
               hostSegIndex: si
             });
-            continue;
+            if (singleOrientationMode) {
+              const s = scoreFor(orientation, anchor);
+              if (s > bestScore + 1e-9) {
+                bestScore = s;
+                bestCandidate = {
+                  anchor,
+                  orientation,
+                  width,
+                  height,
+                  center,
+                  hostSegIndex: si,
+                  dcConnNetId: curr.dcConnNetId
+                };
+              }
+              continue;
+            }
+            this.netLabelPlacement = {
+              globalConnNetId: this.overlappingSameNetTraceGroup.globalConnNetId,
+              dcConnNetId: curr.dcConnNetId,
+              orientation,
+              anchorPoint: anchor,
+              width,
+              height,
+              center
+            };
+            this.solved = true;
+            return;
           }
-          this.testedCandidates.push({
-            center: testCenter,
-            width,
-            height,
-            bounds,
-            anchor,
-            orientation,
-            status: "ok",
-            hostSegIndex: si
-          });
-          this.netLabelPlacement = {
-            globalConnNetId: this.overlappingSameNetTraceGroup.globalConnNetId,
-            dcConnNetId: host.dcConnNetId,
-            orientation,
-            anchorPoint: anchor,
-            width,
-            height,
-            center
-          };
-          this.solved = true;
-          return;
         }
       }
     }
+    if (singleOrientationMode && bestCandidate) {
+      this.netLabelPlacement = {
+        globalConnNetId: this.overlappingSameNetTraceGroup.globalConnNetId,
+        dcConnNetId: bestCandidate.dcConnNetId,
+        orientation: bestCandidate.orientation,
+        anchorPoint: bestCandidate.anchor,
+        width: bestCandidate.width,
+        height: bestCandidate.height,
+        center: bestCandidate.center
+      };
+      this.solved = true;
+      return;
+    }
     this.failed = true;
     this.error = "Could not place net label without collisions";
   }
   visualize() {
-    const graphics = visualizeInputProblem(this.inputProblem);
-    const groupId = this.overlappingSameNetTraceGroup.globalConnNetId;
-    const chipsById = Object.fromEntries(
-      this.inputProblem.chips.map((c) => [c.chipId, c])
-    );
-    const groupTraces = Object.values(this.inputTraceMap).filter(
-      (t) => t.globalConnNetId === groupId
-    );
-    const chipIdsInGroup = /* @__PURE__ */ new Set();
-    for (const t of groupTraces) {
-      chipIdsInGroup.add(t.pins[0].chipId);
-      chipIdsInGroup.add(t.pins[1].chipId);
-    }
-    let largestChipId = null;
-    let largestPinCount = -1;
-    for (const id of chipIdsInGroup) {
-      const chip = chipsById[id];
-      const count = chip?.pins?.length ?? 0;
-      if (count > largestPinCount) {
-        largestPinCount = count;
-        largestChipId = id;
-      }
-    }
-    const lengthOf = (path) => {
-      let sum = 0;
-      const pts = path.tracePath;
-      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;
-    };
-    const hostCandidates = largestChipId == null ? [] : groupTraces.filter(
-      (t) => t.pins[0].chipId === largestChipId || t.pins[1].chipId === largestChipId
-    );
-    const host = hostCandidates.length > 0 ? hostCandidates.reduce((a, b) => lengthOf(a) >= lengthOf(b) ? a : b) : this.overlappingSameNetTraceGroup.overlappingTraces;
-    const groupStroke = getColorFromString(groupId, 0.9);
-    const groupFill = getColorFromString(groupId, 0.5);
-    for (const trace of Object.values(this.inputTraceMap)) {
-      if (trace.globalConnNetId !== groupId) continue;
-      const isHost = host ? trace.mspPairId === host.mspPairId : false;
-      graphics.lines.push({
-        points: trace.tracePath,
-        strokeColor: isHost ? groupStroke : groupFill,
-        strokeWidth: isHost ? 6e-3 : 3e-3,
-        strokeDash: isHost ? void 0 : "4 2"
-      });
-    }
-    for (const c of this.testedCandidates) {
-      const fill = c.status === "ok" ? "rgba(0, 180, 0, 0.25)" : c.status === "chip-collision" ? "rgba(220, 0, 0, 0.25)" : c.status === "trace-collision" ? "rgba(220, 140, 0, 0.25)" : "rgba(120, 120, 120, 0.15)";
-      const stroke = c.status === "ok" ? "green" : c.status === "chip-collision" ? "red" : c.status === "trace-collision" ? "orange" : "gray";
-      graphics.rects.push({
-        center: {
-          x: (c.bounds.minX + c.bounds.maxX) / 2,
-          y: (c.bounds.minY + c.bounds.maxY) / 2
-        },
-        width: c.width,
-        height: c.height,
-        fill,
-        strokeColor: stroke
-      });
-      graphics.points.push({
-        x: c.anchor.x,
-        y: c.anchor.y,
-        color: stroke
-      });
-    }
-    if (this.netLabelPlacement) {
-      const p = this.netLabelPlacement;
-      graphics.rects.push({
-        center: p.center,
-        width: p.width,
-        height: p.height,
-        fill: "rgba(0, 128, 255, 0.35)",
-        strokeColor: "blue"
-      });
-      graphics.points.push({
-        x: p.anchorPoint.x,
-        y: p.anchorPoint.y,
-        color: "blue"
-      });
-    }
-    return graphics;
+    return visualizeSingleNetLabelPlacementSolver(this);
   }
 };
 
@@ -7555,6 +7680,8 @@ var NetLabelPlacementSolver = class extends BaseSolver {
   overlappingSameNetTraceGroups;
   queuedOverlappingSameNetTraceGroups;
   netLabelPlacements = [];
+  currentGroup = null;
+  triedAnyOrientationFallbackForCurrentGroup = false;
   constructor(params) {
     super();
     this.inputProblem = params.inputProblem;
@@ -7672,9 +7799,24 @@ var NetLabelPlacementSolver = class extends BaseSolver {
     if (this.activeSubSolver?.solved) {
       this.netLabelPlacements.push(this.activeSubSolver.netLabelPlacement);
       this.activeSubSolver = null;
+      this.currentGroup = null;
+      this.triedAnyOrientationFallbackForCurrentGroup = false;
       return;
     }
     if (this.activeSubSolver?.failed) {
+      const fullOrients = ["x+", "x-", "y+", "y-"];
+      const currOrients = this.activeSubSolver.availableOrientations;
+      const isAlreadyFull = currOrients.length === 4 && fullOrients.every((o) => currOrients.includes(o));
+      if (!this.triedAnyOrientationFallbackForCurrentGroup && !isAlreadyFull && this.currentGroup) {
+        this.triedAnyOrientationFallbackForCurrentGroup = true;
+        this.activeSubSolver = new SingleNetLabelPlacementSolver({
+          inputProblem: this.inputProblem,
+          inputTraceMap: this.inputTraceMap,
+          overlappingSameNetTraceGroup: this.currentGroup,
+          availableOrientations: fullOrients
+        });
+        return;
+      }
       this.failed = true;
       this.error = this.activeSubSolver.error;
       return;
@@ -7689,6 +7831,8 @@ var NetLabelPlacementSolver = class extends BaseSolver {
       return;
     }
     const netId = nextOverlappingSameNetTraceGroup.netId ?? nextOverlappingSameNetTraceGroup.globalConnNetId;
+    this.currentGroup = nextOverlappingSameNetTraceGroup;
+    this.triedAnyOrientationFallbackForCurrentGroup = false;
     this.activeSubSolver = new SingleNetLabelPlacementSolver({
       inputProblem: this.inputProblem,
       inputTraceMap: this.inputTraceMap,