@tscircuit/schematic-trace-solver 0.0.68 → 0.0.69

package/dist/index.js

@@ -2799,19 +2799,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 +2930,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 +3053,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 +3153,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/package.json

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