@tscircuit/schematic-trace-solver 0.0.95 → 0.0.97

package/dist/index.d.ts

@@ -103,6 +103,7 @@ interface InputProblem {
     availableNetLabelOrientations: Record<NetId, FacingDirection[]>;
     maxMspPairDistance?: number;
     _chipObstacleSpatialIndex?: ChipObstacleSpatialIndex;
+    _hideRatsNet?: boolean;
 }
 
 type MspConnectionPairId = string;
@@ -1012,9 +1013,8 @@ type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
     onSolved?: (instance: SchematicTracePipelineSolver) => void;
     shouldSkip?: (instance: SchematicTracePipelineSolver) => boolean;
 };
-interface SchematicTracePipelineSolverParams {
-    inputProblem: InputProblem;
-    allowLongDistanceTraces?: boolean;
+interface Options {
+    hideRatsNet?: boolean;
 }
 declare class SchematicTracePipelineSolver extends BaseSolver {
     mspConnectionPairSolver?: MspConnectionPairSolver;
@@ -1036,9 +1036,10 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     timeSpentOnPhase: Record<string, number>;
     firstIterationOfPhase: Record<string, number>;
     inputProblem: InputProblem;
+    hideRatsNet: boolean;
     pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof LongDistancePairSolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver> | PipelineStep<typeof TraceCleanupSolver> | PipelineStep<typeof Example28Solver> | PipelineStep<typeof AvailableNetOrientationSolver> | PipelineStep<typeof RailNetLabelCornerPlacementSolver> | PipelineStep<typeof TraceAnchoredNetLabelOverlapSolver> | PipelineStep<typeof NetLabelTraceCollisionSolver> | PipelineStep<typeof NetLabelNetLabelCollisionSolver>)[];
-    constructor(inputProblem: InputProblem);
-    getConstructorParams(): ConstructorParameters<typeof SchematicTracePipelineSolver>[0];
+    constructor(inputProblem: InputProblem, opts?: Options);
+    getConstructorParams(): ConstructorParameters<typeof SchematicTracePipelineSolver>;
     currentPipelineStepIndex: number;
     private cloneAndCorrectInputProblem;
     _step(): void;
@@ -1052,4 +1053,4 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     preview(): GraphicsObject;
 }
 
-export { type ChipId, type InputChip, type InputDirectConnection, type InputNetConnection, type InputPin, type InputProblem, type NetId, type PinId, SchematicTracePipelineSolver, type SchematicTracePipelineSolverParams, SchematicTraceSingleLineSolver2, type SectionId, type TextBoxes };
+export { type ChipId, type InputChip, type InputDirectConnection, type InputNetConnection, type InputPin, type InputProblem, type NetId, type PinId, SchematicTracePipelineSolver, SchematicTraceSingleLineSolver2, type SectionId, type TextBoxes };

package/dist/index.js

@@ -327,7 +327,11 @@ var arePinsInDifferentSchematicSections = (inputProblem, p1, p2) => {
 
 // lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem.ts
 var visualizeInputProblem = (inputProblem, opts = {}) => {
-  const { connectionAlpha = 0.8, chipAlpha = 0.8 } = opts;
+  const {
+    connectionAlpha = 0.8,
+    chipAlpha = 0.8,
+    hideRatsNet = inputProblem._hideRatsNet ?? false
+  } = opts;
   const graphics = {
     lines: [],
     points: [],
@@ -367,47 +371,49 @@ ${pin._facingDirection ?? getPinDirection(pin, chip)}`,
       strokeColor: "rgba(160, 0, 220, 0.9)"
     });
   }
-  for (const directConn of inputProblem.directConnections) {
-    const [pinId1, pinId2] = directConn.pinIds;
-    const pin1 = pinIdMap.get(pinId1);
-    const pin2 = pinIdMap.get(pinId2);
-    if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
-      continue;
+  if (!hideRatsNet) {
+    for (const directConn of inputProblem.directConnections) {
+      const [pinId1, pinId2] = directConn.pinIds;
+      const pin1 = pinIdMap.get(pinId1);
+      const pin2 = pinIdMap.get(pinId2);
+      if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
+        continue;
+      }
+      graphics.lines.push({
+        points: [
+          {
+            x: pin1.x,
+            y: pin1.y
+          },
+          {
+            x: pin2.x,
+            y: pin2.y
+          }
+        ],
+        strokeColor: getColorFromString(
+          directConn.netId ?? `${pinId1}-${pinId2}`,
+          connectionAlpha
+        )
+      });
     }
-    graphics.lines.push({
-      points: [
-        {
-          x: pin1.x,
-          y: pin1.y
-        },
-        {
-          x: pin2.x,
-          y: pin2.y
-        }
-      ],
-      strokeColor: getColorFromString(
-        directConn.netId ?? `${pinId1}-${pinId2}`,
-        connectionAlpha
-      )
-    });
-  }
-  for (const netConn of inputProblem.netConnections) {
-    const pins = netConn.pinIds.map((pinId) => pinIdMap.get(pinId));
-    for (let i = 0; i < pins.length - 1; i++) {
-      for (let j = i + 1; j < pins.length; j++) {
-        const pin1 = pins[i];
-        const pin2 = pins[j];
-        if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
-          continue;
+    for (const netConn of inputProblem.netConnections) {
+      const pins = netConn.pinIds.map((pinId) => pinIdMap.get(pinId));
+      for (let i = 0; i < pins.length - 1; i++) {
+        for (let j = i + 1; j < pins.length; j++) {
+          const pin1 = pins[i];
+          const pin2 = pins[j];
+          if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
+            continue;
+          }
+          graphics.lines.push({
+            points: [
+              { x: pin1.x, y: pin1.y },
+              { x: pin2.x, y: pin2.y }
+            ],
+            strokeColor: getColorFromString(netConn.netId, connectionAlpha),
+            strokeDash: "4 2"
+          });
         }
-        graphics.lines.push({
-          points: [
-            { x: pin1.x, y: pin1.y },
-            { x: pin2.x, y: pin2.y }
-          ],
-          strokeColor: getColorFromString(netConn.netId, connectionAlpha),
-          strokeDash: "4 2"
-        });
       }
     }
   }
@@ -579,54 +585,150 @@ import "graphics-debug";
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts
 import { calculateElbow as calculateElbow2 } from "calculate-elbow";
 
-// lib/solvers/GuidelinesSolver/getInputChipBounds.ts
-function getInputChipBounds(chip) {
-  const halfWidth = chip.width / 2;
-  const halfHeight = chip.height / 2;
+// lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry.ts
+var NET_LABEL_HORIZONTAL_WIDTH = 0.45;
+var NET_LABEL_HORIZONTAL_HEIGHT = 0.2;
+function getDimsForOrientation(params) {
+  const { orientation, netLabelWidth, netLabelHeight } = params;
+  const horizWidth = typeof netLabelWidth === "number" ? netLabelWidth : NET_LABEL_HORIZONTAL_WIDTH;
+  const horizHeight = typeof netLabelHeight === "number" ? netLabelHeight : NET_LABEL_HORIZONTAL_HEIGHT;
+  if (orientation === "y+" || orientation === "y-") {
+    return {
+      // Rotated: horizontal length = netLabelHeight, vertical length = netLabelWidth
+      width: horizHeight,
+      height: horizWidth
+    };
+  }
   return {
-    minX: chip.center.x - halfWidth,
-    maxX: chip.center.x + halfWidth,
-    minY: chip.center.y - halfHeight,
-    maxY: chip.center.y + halfHeight
+    width: horizWidth,
+    height: horizHeight
   };
 }
-
-// lib/utils/textBoxBounds.ts
-function getTextBoxBounds(textBox, padding = {}) {
+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: textBox.center.x - textBox.width / 2 - (padding.minX ?? 0),
-    minY: textBox.center.y - textBox.height / 2 - (padding.minY ?? 0),
-    maxX: textBox.center.x + textBox.width / 2 + (padding.maxX ?? 0),
-    maxY: textBox.center.y + textBox.height / 2 + (padding.maxY ?? 0)
+    minX: center.x - w / 2,
+    minY: center.y - h / 2,
+    maxX: center.x + w / 2,
+    maxY: center.y + h / 2
   };
 }
-function boundsOverlap(a, b, eps = 1e-9) {
-  return a.minX < b.maxX - eps && a.maxX > b.minX + eps && a.minY < b.maxY - eps && a.maxY > b.minY + eps;
+
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/calculateDirectShortPath.ts
+import { calculateElbow } from "calculate-elbow";
+var MAX_SHORT_TRACE_DISTANCE = 0.15;
+var SHORT_TRACE_OVERSHOOT = MAX_SHORT_TRACE_DISTANCE / 7.5;
+var FALLBACK_ELBOW_MAX_OVERSHOOT = 0.2;
+function segmentDirection(from, to) {
+  if (to.x > from.x) return "x+";
+  if (to.x < from.x) return "x-";
+  if (to.y > from.y) return "y+";
+  if (to.y < from.y) return "y-";
+  return null;
 }
-function rectIntersectsAnyTextBox(bounds, inputProblem) {
-  for (const textBox of inputProblem.textBoxes ?? []) {
-    if (boundsOverlap(bounds, getTextBoxBounds(textBox))) return true;
+function pathMatchesPinDirections({
+  path,
+  pin1,
+  pin2
+}) {
+  const firstDirection = segmentDirection(path[0], path[1]);
+  const lastDirection = segmentDirection(
+    path[path.length - 1],
+    path[path.length - 2]
+  );
+  return firstDirection === pin1._facingDirection && lastDirection === pin2._facingDirection;
+}
+function calculateShortOrthogonalRoute(pin1, pin2) {
+  if (pin1.x === pin2.x || pin1.y === pin2.y) return null;
+  const firstDir = pin1._facingDirection;
+  const lastDir = pin2._facingDirection;
+  const start = { x: pin1.x, y: pin1.y };
+  const end = { x: pin2.x, y: pin2.y };
+  let path = null;
+  if (firstDir?.startsWith("y") && lastDir?.startsWith("x")) {
+    let yOffset = -SHORT_TRACE_OVERSHOOT;
+    if (firstDir === "y+") {
+      yOffset = SHORT_TRACE_OVERSHOOT;
+    }
+    const routeY = start.y + yOffset;
+    const routeX = (start.x + end.x) / 2;
+    path = [
+      start,
+      { x: start.x, y: routeY },
+      { x: routeX, y: routeY },
+      { x: routeX, y: end.y },
+      end
+    ];
+  } else if (firstDir?.startsWith("x") && lastDir?.startsWith("y")) {
+    let xOffset = -SHORT_TRACE_OVERSHOOT;
+    if (firstDir === "x+") {
+      xOffset = SHORT_TRACE_OVERSHOOT;
+    }
+    const routeX = start.x + xOffset;
+    const routeY = (start.y + end.y) / 2;
+    path = [
+      start,
+      { x: routeX, y: start.y },
+      { x: routeX, y: routeY },
+      { x: end.x, y: routeY },
+      end
+    ];
   }
-  return false;
+  if (!path) return null;
+  if (pathMatchesPinDirections({ path, pin1, pin2 })) {
+    return path;
+  }
+  return null;
+}
+function calculateDirectShortPath(pin1, pin2) {
+  const routingDistance = Math.abs(pin1.x - pin2.x) + Math.abs(pin1.y - pin2.y);
+  if (routingDistance > MAX_SHORT_TRACE_DISTANCE) return null;
+  const start = { x: pin1.x, y: pin1.y };
+  const end = { x: pin2.x, y: pin2.y };
+  const orthogonalRoute = calculateShortOrthogonalRoute(pin1, pin2);
+  if (orthogonalRoute) return orthogonalRoute;
+  let candidatePaths = [];
+  if (pin1.x !== pin2.x && pin1.y !== pin2.y) {
+    candidatePaths = [
+      [start, { x: pin2.x, y: pin1.y }, end],
+      [start, { x: pin1.x, y: pin2.y }, end]
+    ];
+  } else {
+    candidatePaths = [[start, end]];
+  }
+  for (const path of candidatePaths) {
+    if (pathMatchesPinDirections({ path, pin1, pin2 })) return path;
+  }
+  return calculateElbow(
+    {
+      x: pin1.x,
+      y: pin1.y,
+      facingDirection: pin1._facingDirection
+    },
+    {
+      x: pin2.x,
+      y: pin2.y,
+      facingDirection: pin2._facingDirection
+    },
+    {
+      overshoot: Math.min(
+        FALLBACK_ELBOW_MAX_OVERSHOOT,
+        Math.max(SHORT_TRACE_OVERSHOOT, routingDistance / 4)
+      )
+    }
+  );
 }
-
-// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect.ts
-var chipToRect = (chip) => {
-  const b = getInputChipBounds(chip);
-  return { kind: "chip", chipId: chip.chipId, ...b };
-};
-var getObstacleRects = (problem, opts = {}) => {
-  const chipRects = problem.chips.map(chipToRect);
-  const textBoxRects = (problem.textBoxes ?? []).map((textBox) => {
-    const b = getTextBoxBounds(textBox, opts.textBoxPadding);
-    return {
-      kind: "text_box",
-      textBox,
-      ...b
-    };
-  });
-  return [...chipRects, ...textBoxRects];
-};
 
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions.ts
 var EPS = 1e-9;
@@ -652,6 +754,21 @@ var segmentIntersectsRect = (a, b, r, eps = EPS) => {
     return overlap > eps;
   }
 };
+var segmentOverlapsRectBoundary = (a, b, r, eps = EPS) => {
+  if (isVertical(a, b, eps)) {
+    const onVerticalBoundary = Math.abs(a.x - r.minX) <= eps || Math.abs(a.x - r.maxX) <= eps;
+    if (!onVerticalBoundary) return false;
+    const overlap = Math.min(Math.max(a.y, b.y), r.maxY) - Math.max(Math.min(a.y, b.y), r.minY);
+    return overlap > eps;
+  }
+  if (isHorizontal(a, b, eps)) {
+    const onHorizontalBoundary = Math.abs(a.y - r.minY) <= eps || Math.abs(a.y - r.maxY) <= eps;
+    if (!onHorizontalBoundary) return false;
+    const overlap = Math.min(Math.max(a.x, b.x), r.maxX) - Math.max(Math.min(a.x, b.x), r.minX);
+    return overlap > eps;
+  }
+  return false;
+};
 var findFirstCollision = (pts, rects, opts = {}) => {
   for (let i = 0; i < pts.length - 1; i++) {
     const a = pts[i];
@@ -806,151 +923,55 @@ var pathKey = (pts, decimals = 6) => {
   return key;
 };
 
-// lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry.ts
-var NET_LABEL_HORIZONTAL_WIDTH = 0.45;
-var NET_LABEL_HORIZONTAL_HEIGHT = 0.2;
-function getDimsForOrientation(params) {
-  const { orientation, netLabelWidth, netLabelHeight } = params;
-  const horizWidth = typeof netLabelWidth === "number" ? netLabelWidth : NET_LABEL_HORIZONTAL_WIDTH;
-  const horizHeight = typeof netLabelHeight === "number" ? netLabelHeight : NET_LABEL_HORIZONTAL_HEIGHT;
-  if (orientation === "y+" || orientation === "y-") {
-    return {
-      // Rotated: horizontal length = netLabelHeight, vertical length = netLabelWidth
-      width: horizHeight,
-      height: horizWidth
-    };
-  }
+// lib/solvers/GuidelinesSolver/getInputChipBounds.ts
+function getInputChipBounds(chip) {
+  const halfWidth = chip.width / 2;
+  const halfHeight = chip.height / 2;
   return {
-    width: horizWidth,
-    height: horizHeight
+    minX: chip.center.x - halfWidth,
+    maxX: chip.center.x + halfWidth,
+    minY: chip.center.y - halfHeight,
+    maxY: chip.center.y + halfHeight
   };
 }
-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) {
+
+// lib/utils/textBoxBounds.ts
+function getTextBoxBounds(textBox, padding = {}) {
   return {
-    minX: center.x - w / 2,
-    minY: center.y - h / 2,
-    maxX: center.x + w / 2,
-    maxY: center.y + h / 2
+    minX: textBox.center.x - textBox.width / 2 - (padding.minX ?? 0),
+    minY: textBox.center.y - textBox.height / 2 - (padding.minY ?? 0),
+    maxX: textBox.center.x + textBox.width / 2 + (padding.maxX ?? 0),
+    maxY: textBox.center.y + textBox.height / 2 + (padding.maxY ?? 0)
   };
 }
-
-// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/calculateDirectShortPath.ts
-import { calculateElbow } from "calculate-elbow";
-var MAX_SHORT_TRACE_DISTANCE = 0.15;
-var SHORT_TRACE_OVERSHOOT = MAX_SHORT_TRACE_DISTANCE / 7.5;
-var FALLBACK_ELBOW_MAX_OVERSHOOT = 0.2;
-function segmentDirection(from, to) {
-  if (to.x > from.x) return "x+";
-  if (to.x < from.x) return "x-";
-  if (to.y > from.y) return "y+";
-  if (to.y < from.y) return "y-";
-  return null;
-}
-function pathMatchesPinDirections({
-  path,
-  pin1,
-  pin2
-}) {
-  const firstDirection = segmentDirection(path[0], path[1]);
-  const lastDirection = segmentDirection(
-    path[path.length - 1],
-    path[path.length - 2]
-  );
-  return firstDirection === pin1._facingDirection && lastDirection === pin2._facingDirection;
-}
-function calculateShortOrthogonalRoute(pin1, pin2) {
-  if (pin1.x === pin2.x || pin1.y === pin2.y) return null;
-  const firstDir = pin1._facingDirection;
-  const lastDir = pin2._facingDirection;
-  const start = { x: pin1.x, y: pin1.y };
-  const end = { x: pin2.x, y: pin2.y };
-  let path = null;
-  if (firstDir?.startsWith("y") && lastDir?.startsWith("x")) {
-    let yOffset = -SHORT_TRACE_OVERSHOOT;
-    if (firstDir === "y+") {
-      yOffset = SHORT_TRACE_OVERSHOOT;
-    }
-    const routeY = start.y + yOffset;
-    const routeX = (start.x + end.x) / 2;
-    path = [
-      start,
-      { x: start.x, y: routeY },
-      { x: routeX, y: routeY },
-      { x: routeX, y: end.y },
-      end
-    ];
-  } else if (firstDir?.startsWith("x") && lastDir?.startsWith("y")) {
-    let xOffset = -SHORT_TRACE_OVERSHOOT;
-    if (firstDir === "x+") {
-      xOffset = SHORT_TRACE_OVERSHOOT;
-    }
-    const routeX = start.x + xOffset;
-    const routeY = (start.y + end.y) / 2;
-    path = [
-      start,
-      { x: routeX, y: start.y },
-      { x: routeX, y: routeY },
-      { x: end.x, y: routeY },
-      end
-    ];
-  }
-  if (!path) return null;
-  if (pathMatchesPinDirections({ path, pin1, pin2 })) {
-    return path;
-  }
-  return null;
+function boundsOverlap(a, b, eps = 1e-9) {
+  return a.minX < b.maxX - eps && a.maxX > b.minX + eps && a.minY < b.maxY - eps && a.maxY > b.minY + eps;
 }
-function calculateDirectShortPath(pin1, pin2) {
-  const routingDistance = Math.abs(pin1.x - pin2.x) + Math.abs(pin1.y - pin2.y);
-  if (routingDistance > MAX_SHORT_TRACE_DISTANCE) return null;
-  const start = { x: pin1.x, y: pin1.y };
-  const end = { x: pin2.x, y: pin2.y };
-  const orthogonalRoute = calculateShortOrthogonalRoute(pin1, pin2);
-  if (orthogonalRoute) return orthogonalRoute;
-  let candidatePaths = [];
-  if (pin1.x !== pin2.x && pin1.y !== pin2.y) {
-    candidatePaths = [
-      [start, { x: pin2.x, y: pin1.y }, end],
-      [start, { x: pin1.x, y: pin2.y }, end]
-    ];
-  } else {
-    candidatePaths = [[start, end]];
-  }
-  for (const path of candidatePaths) {
-    if (pathMatchesPinDirections({ path, pin1, pin2 })) return path;
+function rectIntersectsAnyTextBox(bounds, inputProblem) {
+  for (const textBox of inputProblem.textBoxes ?? []) {
+    if (boundsOverlap(bounds, getTextBoxBounds(textBox))) return true;
   }
-  return calculateElbow(
-    {
-      x: pin1.x,
-      y: pin1.y,
-      facingDirection: pin1._facingDirection
-    },
-    {
-      x: pin2.x,
-      y: pin2.y,
-      facingDirection: pin2._facingDirection
-    },
-    {
-      overshoot: Math.min(
-        FALLBACK_ELBOW_MAX_OVERSHOOT,
-        Math.max(SHORT_TRACE_OVERSHOOT, routingDistance / 4)
-      )
-    }
-  );
+  return false;
 }
 
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect.ts
+var chipToRect = (chip) => {
+  const b = getInputChipBounds(chip);
+  return { kind: "chip", chipId: chip.chipId, ...b };
+};
+var getObstacleRects = (problem, opts = {}) => {
+  const chipRects = problem.chips.map(chipToRect);
+  const textBoxRects = (problem.textBoxes ?? []).map((textBox) => {
+    const b = getTextBoxBounds(textBox, opts.textBoxPadding);
+    return {
+      kind: "text_box",
+      textBox,
+      ...b
+    };
+  });
+  return [...chipRects, ...textBoxRects];
+};
+
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts
 var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
   pins;
@@ -1137,17 +1158,41 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     const collision = findFirstCollision(path, this.obstacles, {
       excludeRectsForSegment: (segIndex2) => {
         const lastSegIndex2 = path.length - 2;
+        const excludedRects = /* @__PURE__ */ new Set();
         if (segIndex2 === 0 || segIndex2 === lastSegIndex2) {
-          return this.textObstacles;
+          for (const textObstacle of this.textObstacles) {
+            excludedRects.add(textObstacle);
+          }
+        }
+        const segmentStart = path[segIndex2];
+        const segmentEnd = path[segIndex2 + 1];
+        const endpointEpsilon = 1e-9;
+        const segmentTouchesPin = (pin) => [segmentStart, segmentEnd].some(
+          (point) => Math.abs(point.x - pin.x) <= endpointEpsilon && Math.abs(point.y - pin.y) <= endpointEpsilon
+        );
+        for (const pin of this.pins) {
+          if (!segmentTouchesPin(pin)) continue;
+          const endpointChipObstacle = this.obstacles.find(
+            (obstacle) => obstacle.kind === "chip" && obstacle.chipId === pin.chipId
+          );
+          if (endpointChipObstacle && segmentOverlapsRectBoundary(
+            segmentStart,
+            segmentEnd,
+            endpointChipObstacle
+          )) {
+            excludedRects.add(endpointChipObstacle);
+          }
         }
         const adjacentEndpointSegIndex = segIndex2 === 1 ? 2 : segIndex2 === lastSegIndex2 - 1 ? lastSegIndex2 - 2 : null;
         if (adjacentEndpointSegIndex !== null && adjacentEndpointSegIndex >= 0 && adjacentEndpointSegIndex < lastSegIndex2 && this.isSegmentOutsidePinBand(
           path[adjacentEndpointSegIndex],
           path[adjacentEndpointSegIndex + 1]
         )) {
-          return this.endpointTextObstacles;
+          for (const textObstacle of this.endpointTextObstacles) {
+            excludedRects.add(textObstacle);
+          }
         }
-        return /* @__PURE__ */ new Set();
+        return excludedRects;
       }
     });
     if (!collision) {
@@ -9034,6 +9079,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   timeSpentOnPhase;
   firstIterationOfPhase;
   inputProblem;
+  hideRatsNet;
   pipelineDef = [
     definePipelineStep(
       "mspConnectionPairSolver",
@@ -9233,8 +9279,9 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       ]
     )
   ];
-  constructor(inputProblem) {
+  constructor(inputProblem, opts) {
     super();
+    this.hideRatsNet = opts?.hideRatsNet ?? false;
     this.inputProblem = this.cloneAndCorrectInputProblem(inputProblem);
     this.MAX_ITERATIONS = 1e6;
     this.startTimeOfPhase = {};
@@ -9243,13 +9290,14 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
     this.firstIterationOfPhase = {};
   }
   getConstructorParams() {
-    return this.inputProblem;
+    return [this.inputProblem, { hideRatsNet: this.hideRatsNet }];
   }
   currentPipelineStepIndex = 0;
   cloneAndCorrectInputProblem(original) {
     const cloned = structuredClone({
       ...original,
-      _chipObstacleSpatialIndex: void 0
+      _chipObstacleSpatialIndex: void 0,
+      _hideRatsNet: this.hideRatsNet
     });
     expandChipsToFitPins(cloned);
     correctPinsInsideChips(cloned);
@@ -9295,7 +9343,9 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
     if (!this.solved && this.activeSubSolver)
       return this.activeSubSolver.visualize();
     const visualizations = [
-      visualizeInputProblem(this.inputProblem),
+      visualizeInputProblem(this.inputProblem, {
+        hideRatsNet: this.hideRatsNet
+      }),
       ...this.pipelineDef.map((p) => this[p.solverName]?.visualize()).filter(Boolean).map((viz, stepIndex) => {
         for (const rect of viz.rects ?? []) {
           rect.step = stepIndex;