@tscircuit/schematic-trace-solver 0.0.68 → 0.0.70

package/dist/index.js

@@ -1234,12 +1234,43 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
   }) {
     const blockingCollisions = this.getBlockingCollisions({ group, offset });
     if (blockingCollisions.length === 0) return offset;
-    return blockingCollisions.flatMap(({ start, isVertical: isVertical4, obstacle }) => [
-      (isVertical4 ? obstacle.minX - start.x : obstacle.minY - start.y) - this.SHIFT_DISTANCE,
-      (isVertical4 ? obstacle.maxX - start.x : obstacle.maxY - start.y) + this.SHIFT_DISTANCE
-    ]).filter(
-      (candidateOffset) => this.getBlockingCollisions({ group, offset: candidateOffset }).length === 0
-    ).sort((a, b) => Math.abs(a - offset) - Math.abs(b - offset))[0] ?? offset;
+    const crossesThroughObstacle = (candidateOffset) => blockingCollisions.some(({ start, isVertical: isVertical4, obstacle }) => {
+      let orig;
+      let min;
+      let max;
+      if (isVertical4) {
+        orig = start.x;
+        min = obstacle.minX;
+        max = obstacle.maxX;
+      } else {
+        orig = start.y;
+        min = obstacle.minY;
+        max = obstacle.maxY;
+      }
+      const next = orig + candidateOffset;
+      return orig <= min + EPS4 && next >= max - EPS4 || orig >= max - EPS4 && next <= min + EPS4;
+    });
+    const edges = blockingCollisions.map(({ start, isVertical: isVertical4, obstacle }) => {
+      if (isVertical4) {
+        return {
+          coord: start.x,
+          lowEdge: obstacle.minX,
+          highEdge: obstacle.maxX
+        };
+      }
+      return { coord: start.y, lowEdge: obstacle.minY, highEdge: obstacle.maxY };
+    });
+    const bestCandidate = (clearance) => {
+      const candidates = edges.flatMap(({ coord, lowEdge, highEdge }) => [
+        lowEdge - coord - clearance,
+        highEdge - coord + clearance
+      ]);
+      return candidates.filter((candidateOffset) => !crossesThroughObstacle(candidateOffset)).filter(
+        (candidateOffset) => this.getBlockingCollisions({ group, offset: candidateOffset }).length === 0
+      ).sort((a, b) => Math.abs(a - offset) - Math.abs(b - offset))[0];
+    };
+    const EDGE_MARGIN = this.SHIFT_DISTANCE / 10;
+    return bestCandidate(this.SHIFT_DISTANCE) ?? bestCandidate(EDGE_MARGIN) ?? offset;
   }
   getBlockingCollisions({
     group,
@@ -2799,19 +2830,32 @@ var detectTraceLabelOverlap = ({
 };
 
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/violation.ts
-var findTraceViolationZone = (path, labelBounds) => {
-  const isPointInside = (p) => p.x > labelBounds.minX && p.x < labelBounds.maxX && p.y > labelBounds.minY && p.y < labelBounds.maxY;
-  let firstInsideIndex = -1;
-  let lastInsideIndex = -1;
-  for (let i = 0; i < path.length; i++) {
-    if (isPointInside(path[i])) {
-      if (firstInsideIndex === -1) {
-        firstInsideIndex = i;
-      }
-      lastInsideIndex = i;
+var findTraceViolationZone = ({
+  path,
+  labelBounds,
+  paddedBounds = labelBounds
+}) => {
+  let firstCollidingSeg = -1;
+  let lastCollidingSeg = -1;
+  for (let i = 0; i < path.length - 1; i++) {
+    if (segmentIntersectsRect2(path[i], path[i + 1], labelBounds)) {
+      if (firstCollidingSeg === -1) firstCollidingSeg = i;
+      lastCollidingSeg = i;
     }
   }
-  return { firstInsideIndex, lastInsideIndex };
+  if (firstCollidingSeg === -1) {
+    return { firstInsideIndex: -1, lastInsideIndex: -1 };
+  }
+  const isInsidePadded = (p) => p.x > paddedBounds.minX && p.x < paddedBounds.maxX && p.y > paddedBounds.minY && p.y < paddedBounds.maxY;
+  let entryIndex = firstCollidingSeg;
+  while (entryIndex > 0 && isInsidePadded(path[entryIndex])) {
+    entryIndex--;
+  }
+  let exitIndex = lastCollidingSeg + 1;
+  while (exitIndex < path.length - 1 && isInsidePadded(path[exitIndex])) {
+    exitIndex++;
+  }
+  return { firstInsideIndex: entryIndex + 1, lastInsideIndex: exitIndex - 1 };
 };
 
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/trySnipAndReconnect.ts
@@ -2917,20 +2961,21 @@ var generateFourPointDetourCandidates = ({
     }
     exitPoint = initialTrace.tracePath[exitIndex];
   } else {
-    let collidingSegIndex = -1;
+    let firstCollidingSeg = -1;
+    let lastCollidingSeg = -1;
     for (let i = 0; i < initialTrace.tracePath.length - 1; i++) {
       if (segmentIntersectsRect(
         initialTrace.tracePath[i],
         initialTrace.tracePath[i + 1],
-        { ...paddedLabelBounds, chipId: "temp-obstacle" }
+        { ...labelBounds, chipId: "temp-obstacle" }
       )) {
-        collidingSegIndex = i;
-        break;
+        if (firstCollidingSeg === -1) firstCollidingSeg = i;
+        lastCollidingSeg = i;
       }
     }
-    if (collidingSegIndex === -1) return [];
-    entryIndex = collidingSegIndex;
-    exitIndex = collidingSegIndex + 1;
+    if (firstCollidingSeg === -1) return [];
+    entryIndex = firstCollidingSeg;
+    exitIndex = lastCollidingSeg + 1;
     entryPoint = initialTrace.tracePath[entryIndex];
     exitPoint = initialTrace.tracePath[exitIndex];
   }
@@ -3039,10 +3084,18 @@ var generateRerouteCandidates = ({
     paddingBuffer,
     detourCount
   });
-  const { firstInsideIndex, lastInsideIndex } = findTraceViolationZone(
-    initialTrace.tracePath,
-    labelBounds
-  );
+  const effectivePadding = paddingBuffer + detourCount * paddingBuffer;
+  const paddedLabelBounds = {
+    minX: labelBounds.minX - effectivePadding,
+    maxX: labelBounds.maxX + effectivePadding,
+    minY: labelBounds.minY - effectivePadding,
+    maxY: labelBounds.maxY + effectivePadding
+  };
+  const { firstInsideIndex, lastInsideIndex } = findTraceViolationZone({
+    path: initialTrace.tracePath,
+    labelBounds,
+    paddedBounds: paddedLabelBounds
+  });
   const snipReconnectCandidates = generateSnipAndReconnectCandidates({
     initialTrace,
     firstInsideIndex,
@@ -3131,7 +3184,11 @@ var SingleOverlapSolver = class extends BaseSolver {
     this._tried++;
     const nextCandidatePath = this.queuedCandidatePaths.shift();
     const simplifiedPath = simplifyPath(nextCandidatePath);
-    if (!isPathCollidingWithObstacles(simplifiedPath, this.obstacles) && !doesPathCoincideWithTraces(simplifiedPath, this.tracesToAvoidOverlapping)) {
+    const stillOverlapsLabel = detectTraceLabelOverlap({
+      traces: [{ ...this.initialTrace, tracePath: simplifiedPath }],
+      netLabels: [this.label]
+    }).length > 0;
+    if (!stillOverlapsLabel && !isPathCollidingWithObstacles(simplifiedPath, this.obstacles) && !doesPathCoincideWithTraces(simplifiedPath, this.tracesToAvoidOverlapping)) {
       this.solvedTracePath = simplifiedPath;
       this.solved = true;
     }

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/rerouteCollidingTrace.ts

@@ -55,10 +55,19 @@ export const generateRerouteCandidates = ({
     detourCount,
   })
 
-  const { firstInsideIndex, lastInsideIndex } = findTraceViolationZone(
-    initialTrace.tracePath,
+  const effectivePadding = paddingBuffer + detourCount * paddingBuffer
+  const paddedLabelBounds = {
+    minX: labelBounds.minX - effectivePadding,
+    maxX: labelBounds.maxX + effectivePadding,
+    minY: labelBounds.minY - effectivePadding,
+    maxY: labelBounds.maxY + effectivePadding,
+  }
+
+  const { firstInsideIndex, lastInsideIndex } = findTraceViolationZone({
+    path: initialTrace.tracePath,
     labelBounds,
-  )
+    paddedBounds: paddedLabelBounds,
+  })
 
   const snipReconnectCandidates = generateSnipAndReconnectCandidates({
     initialTrace,

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver.ts

@@ -9,6 +9,7 @@ import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/Schemati
 import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
 import { generateRerouteCandidates } from "../../rerouteCollidingTrace"
 import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+import { detectTraceLabelOverlap } from "../../detectTraceLabelOverlap"
 
 interface SingleOverlapSolverInput {
   trace: SolvedTracePath
@@ -141,7 +142,17 @@ export class SingleOverlapSolver extends BaseSolver {
     const nextCandidatePath = this.queuedCandidatePaths.shift()!
     const simplifiedPath = simplifyPath(nextCandidatePath)
 
+    // A candidate is only valid if it actually clears the label it is meant to
+    // avoid. Without this check a "detour" that still grazes the label (e.g. one
+    // built around the wrong segment) would be accepted as solved.
+    const stillOverlapsLabel =
+      detectTraceLabelOverlap({
+        traces: [{ ...this.initialTrace, tracePath: simplifiedPath }],
+        netLabels: [this.label],
+      }).length > 0
+
     if (
+      !stillOverlapsLabel &&
       !isPathCollidingWithObstacles(simplifiedPath, this.obstacles) &&
       !doesPathCoincideWithTraces(simplifiedPath, this.tracesToAvoidOverlapping)
     ) {

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/tryFourPointDetour.ts

@@ -71,25 +71,30 @@ export const generateFourPointDetourCandidates = ({
     }
     exitPoint = initialTrace.tracePath[exitIndex]
   } else {
-    // STRATEGY 1: Single Label - find the first intersecting segment
-    let collidingSegIndex = -1
+    // STRATEGY 1: Single Label - reroute around the contiguous span of segments
+    // that actually overlap the label. Detection uses the *unpadded* bounds so
+    // a short pin stub that merely pokes into the padding zone is not mistaken
+    // for the real crossing (which would leave the offending segment in place
+    // and create a useless loop).
+    let firstCollidingSeg = -1
+    let lastCollidingSeg = -1
     for (let i = 0; i < initialTrace.tracePath.length - 1; i++) {
       if (
         segmentIntersectsRect(
           initialTrace.tracePath[i],
           initialTrace.tracePath[i + 1],
-          { ...paddedLabelBounds, chipId: "temp-obstacle" },
+          { ...labelBounds, chipId: "temp-obstacle" },
         )
       ) {
-        collidingSegIndex = i
-        break
+        if (firstCollidingSeg === -1) firstCollidingSeg = i
+        lastCollidingSeg = i
       }
     }
 
-    if (collidingSegIndex === -1) return []
+    if (firstCollidingSeg === -1) return []
 
-    entryIndex = collidingSegIndex
-    exitIndex = collidingSegIndex + 1
+    entryIndex = firstCollidingSeg
+    exitIndex = lastCollidingSeg + 1
     entryPoint = initialTrace.tracePath[entryIndex]
     exitPoint = initialTrace.tracePath[exitIndex]
   }

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/violation.ts

@@ -1,25 +1,59 @@
-import type { Point } from "@tscircuit/math-utils"
+import type { Point, Bounds } from "@tscircuit/math-utils"
+import { segmentIntersectsRect } from "../NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions"
 
-export const findTraceViolationZone = (
-  path: Point[],
-  labelBounds: { minX: number; maxX: number; minY: number; maxY: number },
-) => {
-  const isPointInside = (p: Point) =>
-    p.x > labelBounds.minX &&
-    p.x < labelBounds.maxX &&
-    p.y > labelBounds.minY &&
-    p.y < labelBounds.maxY
+/**
+ * Locates the portion of a trace that must be rerouted to clear a label.
+ *
+ * Detection is segment-based against the (unpadded) label bounds so it also
+ * catches traces that cross the label edge-to-edge, or run *along* one of its
+ * edges, without ever placing a vertex strictly inside it (the previous
+ * vertex-only test missed both cases).
+ *
+ * The returned range describes the vertices to remove: the reroute reconnects
+ * `path[firstInsideIndex - 1]` to `path[lastInsideIndex + 1]`. Those two anchor
+ * vertices are pushed outward until they sit outside the padded label so the
+ * detour has room to pivot without immediately re-entering it.
+ */
+export const findTraceViolationZone = ({
+  path,
+  labelBounds,
+  paddedBounds = labelBounds,
+}: {
+  path: Point[]
+  labelBounds: Bounds
+  paddedBounds?: Bounds
+}) => {
+  let firstCollidingSeg = -1
+  let lastCollidingSeg = -1
+  for (let i = 0; i < path.length - 1; i++) {
+    if (segmentIntersectsRect(path[i]!, path[i + 1]!, labelBounds)) {
+      if (firstCollidingSeg === -1) firstCollidingSeg = i
+      lastCollidingSeg = i
+    }
+  }
 
-  let firstInsideIndex = -1
-  let lastInsideIndex = -1
+  if (firstCollidingSeg === -1) {
+    return { firstInsideIndex: -1, lastInsideIndex: -1 }
+  }
 
-  for (let i = 0; i < path.length; i++) {
-    if (isPointInside(path[i])) {
-      if (firstInsideIndex === -1) {
-        firstInsideIndex = i
-      }
-      lastInsideIndex = i
-    }
+  const isInsidePadded = (p: Point) =>
+    p.x > paddedBounds.minX &&
+    p.x < paddedBounds.maxX &&
+    p.y > paddedBounds.minY &&
+    p.y < paddedBounds.maxY
+
+  // Anchor before the crossing: walk back to the first vertex clear of the
+  // padded label.
+  let entryIndex = firstCollidingSeg
+  while (entryIndex > 0 && isInsidePadded(path[entryIndex]!)) {
+    entryIndex--
+  }
+
+  // Anchor after the crossing.
+  let exitIndex = lastCollidingSeg + 1
+  while (exitIndex < path.length - 1 && isInsidePadded(path[exitIndex]!)) {
+    exitIndex++
   }
-  return { firstInsideIndex, lastInsideIndex }
+
+  return { firstInsideIndex: entryIndex + 1, lastInsideIndex: exitIndex - 1 }
 }

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapIssueSolver/TraceOverlapIssueSolver.ts

@@ -180,21 +180,56 @@ export class TraceOverlapIssueSolver extends BaseSolver {
     const blockingCollisions = this.getBlockingCollisions({ group, offset })
     if (blockingCollisions.length === 0) return offset
 
-    return (
-      blockingCollisions
-        .flatMap(({ start, isVertical, obstacle }) => [
-          (isVertical ? obstacle.minX - start.x : obstacle.minY - start.y) -
-            this.SHIFT_DISTANCE,
-          (isVertical ? obstacle.maxX - start.x : obstacle.maxY - start.y) +
-            this.SHIFT_DISTANCE,
-        ])
+    const crossesThroughObstacle = (candidateOffset: number) =>
+      blockingCollisions.some(({ start, isVertical, obstacle }) => {
+        let orig: number
+        let min: number
+        let max: number
+        if (isVertical) {
+          orig = start.x
+          min = obstacle.minX
+          max = obstacle.maxX
+        } else {
+          orig = start.y
+          min = obstacle.minY
+          max = obstacle.maxY
+        }
+        const next = orig + candidateOffset
+        return (
+          (orig <= min + EPS && next >= max - EPS) ||
+          (orig >= max - EPS && next <= min + EPS)
+        )
+      })
+
+    const edges = blockingCollisions.map(({ start, isVertical, obstacle }) => {
+      if (isVertical) {
+        return {
+          coord: start.x,
+          lowEdge: obstacle.minX,
+          highEdge: obstacle.maxX,
+        }
+      }
+      return { coord: start.y, lowEdge: obstacle.minY, highEdge: obstacle.maxY }
+    })
+
+    const bestCandidate = (clearance: number) => {
+      const candidates = edges.flatMap(({ coord, lowEdge, highEdge }) => [
+        lowEdge - coord - clearance,
+        highEdge - coord + clearance,
+      ])
+      return candidates
+        .filter((candidateOffset) => !crossesThroughObstacle(candidateOffset))
         .filter(
           (candidateOffset) =>
             this.getBlockingCollisions({ group, offset: candidateOffset })
               .length === 0,
         )
-        .sort((a, b) => Math.abs(a - offset) - Math.abs(b - offset))[0] ??
-      offset
+        .sort((a, b) => Math.abs(a - offset) - Math.abs(b - offset))[0]
+    }
+
+    const EDGE_MARGIN = this.SHIFT_DISTANCE / 10
+    return (
+      bestCandidate(this.SHIFT_DISTANCE) ?? bestCandidate(EDGE_MARGIN) ?? offset
     )
   }
 

package/package.json

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

package/site/examples/example42.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/assets/example42.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />

package/tests/assets/example42.json

@@ -0,0 +1,139 @@
+{
+  "chips": [
+    {
+      "chipId": "schematic_component_16",
+      "center": {
+        "x": 0,
+        "y": 0
+      },
+      "width": 4.4,
+      "height": 2,
+      "pins": [
+        {
+          "pinId": "U3.1",
+          "x": 2.6,
+          "y": 0.8499999999999999
+        },
+        {
+          "pinId": "U3.2",
+          "x": 2.6,
+          "y": 0.6499999999999999
+        },
+        {
+          "pinId": "U3.3",
+          "x": 2.6,
+          "y": 0.44999999999999996
+        },
+        {
+          "pinId": "U3.4",
+          "x": 2.6,
+          "y": 0.10000000000000009
+        },
+        {
+          "pinId": "U3.5",
+          "x": 2.6,
+          "y": -0.09999999999999987
+        },
+        {
+          "pinId": "U3.6",
+          "x": 2.6,
+          "y": -0.44999999999999984
+        },
+        {
+          "pinId": "U3.7",
+          "x": 2.6,
+          "y": -0.6499999999999999
+        },
+        {
+          "pinId": "U3.8",
+          "x": 2.6,
+          "y": -0.8499999999999999
+        }
+      ]
+    },
+    {
+      "chipId": "schematic_component_17",
+      "center": {
+        "x": 3.2,
+        "y": -1.4
+      },
+      "width": 1.1,
+      "height": 0.7789106999999986,
+      "pins": [
+        {
+          "pinId": "R8.1",
+          "x": 2.6500000000000004,
+          "y": -1.4
+        },
+        {
+          "pinId": "R8.2",
+          "x": 3.75,
+          "y": -1.4
+        }
+      ]
+    },
+    {
+      "chipId": "schematic_component_18",
+      "center": {
+        "x": 3.2,
+        "y": -2.4
+      },
+      "width": 1.1,
+      "height": 0.7789106999999986,
+      "pins": [
+        {
+          "pinId": "R9.1",
+          "x": 2.6500000000000004,
+          "y": -2.4
+        },
+        {
+          "pinId": "R9.2",
+          "x": 3.75,
+          "y": -2.4
+        }
+      ]
+    }
+  ],
+  "directConnections": [],
+  "netConnections": [
+    {
+      "netId": "GND",
+      "pinIds": ["U3.8", "R8.2", "R9.2"],
+      "netLabelWidth": 0.48
+    },
+    {
+      "netId": "D_MINUS",
+      "pinIds": ["U3.3"],
+      "netLabelWidth": 0.96
+    },
+    {
+      "netId": "D_PLUS",
+      "pinIds": ["U3.2"],
+      "netLabelWidth": 0.84
+    },
+    {
+      "netId": "VBUS",
+      "pinIds": ["U3.1"],
+      "netLabelWidth": 0.6
+    },
+    {
+      "netId": "CC1",
+      "pinIds": ["U3.4", "R8.1"],
+      "netLabelWidth": 0.48
+    },
+    {
+      "netId": "CC2",
+      "pinIds": ["U3.5", "R9.1"],
+      "netLabelWidth": 0.48
+    }
+  ],
+  "availableNetLabelOrientations": {
+    "D_MINUS": ["x-", "x+"],
+    "D_PLUS": ["x-", "x+"],
+    "GND": ["y-"],
+    "VBUS": ["y+"],
+    "CC1": ["x-", "x+"],
+    "CC2": ["x-", "x+"]
+  },
+  "maxMspPairDistance": 2.4
+}