@tscircuit/schematic-trace-solver 0.0.96 → 0.0.97

package/dist/index.js

@@ -585,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;
@@ -658,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];
@@ -812,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;
@@ -1143,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) {

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts

@@ -1,24 +1,29 @@
+import type { Point } from "@tscircuit/math-utils"
+import { calculateElbow } from "calculate-elbow"
 import type { GraphicsObject } from "graphics-debug"
-import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { MspConnectionPair } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
-import type { InputChip, InputProblem, PinId } from "lib/types/InputProblem"
-import type { Point } from "@tscircuit/math-utils"
-import { calculateElbow } from "calculate-elbow"
+import { getDimsForOrientation } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type { InputChip, InputProblem } from "lib/types/InputProblem"
+import type { FacingDirection } from "lib/utils/dir"
+import type { RectPadding } from "lib/utils/textBoxBounds"
 import { getPinDirection } from "../SchematicTraceSingleLineSolver/getPinDirection"
-import { getObstacleRects, type ObstacleRect } from "./rect"
-import { findFirstCollision, isHorizontal, isVertical } from "./collisions"
+import { calculateDirectShortPath } from "./calculateDirectShortPath"
 import {
+  findFirstCollision,
+  isHorizontal,
+  isVertical,
+  segmentOverlapsRectBoundary,
+} from "./collisions"
+import {
+  type Axis,
   aabbFromPoints,
   candidateMidsFromSet,
   midBetweenPointAndRect,
-  type Axis,
 } from "./mid"
 import { pathKey, shiftSegmentOrth } from "./pathOps"
-import type { FacingDirection } from "lib/utils/dir"
-import { getDimsForOrientation } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
-import type { RectPadding } from "lib/utils/textBoxBounds"
-import { calculateDirectShortPath } from "./calculateDirectShortPath"
+import { getObstacleRects, type ObstacleRect } from "./rect"
 
 type PathKey = string
 
@@ -268,9 +273,42 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     const collision = findFirstCollision(path, this.obstacles, {
       excludeRectsForSegment: (segIndex) => {
         const lastSegIndex = path.length - 2
+        const excludedRects = new Set<ObstacleRect>()
+
         if (segIndex === 0 || segIndex === lastSegIndex) {
-          return this.textObstacles
+          for (const textObstacle of this.textObstacles) {
+            excludedRects.add(textObstacle)
+          }
         }
+
+        const segmentStart = path[segIndex]!
+        const segmentEnd = path[segIndex + 1]!
+        const endpointEpsilon = 1e-9
+        const segmentTouchesPin = (pin: MspConnectionPair["pins"][number]) =>
+          [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 =
           segIndex === 1
             ? 2
@@ -286,9 +324,12 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
             path[adjacentEndpointSegIndex + 1]!,
           )
         ) {
-          return this.endpointTextObstacles
+          for (const textObstacle of this.endpointTextObstacles) {
+            excludedRects.add(textObstacle)
+          }
         }
-        return new Set<ObstacleRect>()
+
+        return excludedRects
       },
     })
 

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions.ts

@@ -35,6 +35,37 @@ export const segmentIntersectsRect = <TRect extends RectBounds>(
   }
 }
 
+export const segmentOverlapsRectBoundary = <TRect extends RectBounds>(
+  a: Point,
+  b: Point,
+  r: TRect,
+  eps = EPS,
+): boolean => {
+  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
+}
+
 export const findFirstCollision = <TRect extends RectBounds>(
   pts: Point[],
   rects: TRect[],

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.96",
+  "version": "0.0.97",
   "type": "module",
   "scripts": {
     "start": "cosmos",