@tscircuit/schematic-trace-solver 0.0.67 → 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;
     }
@@ -4550,6 +4576,7 @@ var visualizeCollision = (collisionInfo) => {
 // lib/solvers/TraceCleanupSolver/sub-solver/UntangleTraceSubsolver.ts
 var UntangleTraceSubsolver = class extends BaseSolver {
   input;
+  chipObstacleSpatialIndex;
   lShapesToProcess = [];
   visualizationMode = "l_shapes";
   currentLShape = null;
@@ -4570,6 +4597,10 @@ var UntangleTraceSubsolver = class extends BaseSolver {
     super();
     this.input = solverInput;
     this.visualizationMode = "l_shapes";
+    this.chipObstacleSpatialIndex = this.input.inputProblem._chipObstacleSpatialIndex ?? new ChipObstacleSpatialIndex(this.input.inputProblem.chips);
+    if (!this.input.inputProblem._chipObstacleSpatialIndex) {
+      this.input.inputProblem._chipObstacleSpatialIndex = this.chipObstacleSpatialIndex;
+    }
     for (const trace of this.input.allTraces) {
       const lShapes = findAllLShapedTurns(trace.tracePath);
       this.lShapesToProcess.push(
@@ -4696,6 +4727,12 @@ var UntangleTraceSubsolver = class extends BaseSolver {
       this.input.allTraces,
       this.currentLShape.traceId
     );
+    if (!collisionResult?.isColliding && this._doesCandidateCrossChip(currentCandidate)) {
+      this.lastCollision = null;
+      this.collidingCandidate = currentCandidate;
+      this.currentCandidateIndex++;
+      return;
+    }
     if (!collisionResult?.isColliding) {
       this.bestRouteFound = currentCandidate;
       this.lastCollision = null;
@@ -4706,6 +4743,21 @@ var UntangleTraceSubsolver = class extends BaseSolver {
       this.currentCandidateIndex++;
     }
   }
+  /**
+   * Returns true if any segment of the candidate reroute passes through a
+   * schematic component (chip) body.
+   */
+  _doesCandidateCrossChip(candidate) {
+    for (let i = 0; i < candidate.length - 1; i++) {
+      if (this.chipObstacleSpatialIndex.doesOrthogonalLineIntersectChip([
+        candidate[i],
+        candidate[i + 1]
+      ])) {
+        return true;
+      }
+    }
+    return false;
+  }
   _applyBestRoute(bestRoute) {
     this.bestRoute = bestRoute;
     this.collidingCandidate = null;

package/lib/solvers/TraceCleanupSolver/sub-solver/UntangleTraceSubsolver.ts

@@ -2,6 +2,7 @@ import { BaseSolver } from "../../BaseSolver/BaseSolver"
 import type { InputProblem } from "../../../types/InputProblem"
 import type { SolvedTracePath } from "../../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { NetLabelPlacement } from "../../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { ChipObstacleSpatialIndex } from "lib/data-structures/ChipObstacleSpatialIndex"
 
 import { findAllLShapedTurns, type LShape } from "./findAllLShapedTurns"
 import { getTraceObstacles } from "./getTraceObstacles"
@@ -57,6 +58,7 @@ type VisualizationMode =
  */
 export class UntangleTraceSubsolver extends BaseSolver {
   private input: UntangleTraceSubsolverInput
+  private chipObstacleSpatialIndex: ChipObstacleSpatialIndex
   private lShapesToProcess: LShape[] = []
   private visualizationMode: VisualizationMode = "l_shapes"
 
@@ -86,6 +88,14 @@ export class UntangleTraceSubsolver extends BaseSolver {
     this.input = solverInput
     this.visualizationMode = "l_shapes"
 
+    this.chipObstacleSpatialIndex =
+      this.input.inputProblem._chipObstacleSpatialIndex ??
+      new ChipObstacleSpatialIndex(this.input.inputProblem.chips)
+    if (!this.input.inputProblem._chipObstacleSpatialIndex) {
+      this.input.inputProblem._chipObstacleSpatialIndex =
+        this.chipObstacleSpatialIndex
+    }
+
     for (const trace of this.input.allTraces) {
       const lShapes = findAllLShapedTurns(trace.tracePath)
       this.lShapesToProcess.push(
@@ -232,6 +242,20 @@ export class UntangleTraceSubsolver extends BaseSolver {
       this.currentLShape!.traceId,
     )
 
+    // Untangling must never move a trace through a component body. The candidate
+    // only covers the rerouted corner (not the pin-terminal segments), so reject
+    // any candidate that crosses a chip; the original (component-clear) path is
+    // kept instead, so this stage only ever improves or leaves the trace valid.
+    if (
+      !collisionResult?.isColliding &&
+      this._doesCandidateCrossChip(currentCandidate)
+    ) {
+      this.lastCollision = null
+      this.collidingCandidate = currentCandidate
+      this.currentCandidateIndex++
+      return
+    }
+
     if (!collisionResult?.isColliding) {
       this.bestRouteFound = currentCandidate
       this.lastCollision = null
@@ -243,6 +267,24 @@ export class UntangleTraceSubsolver extends BaseSolver {
     }
   }
 
+  /**
+   * Returns true if any segment of the candidate reroute passes through a
+   * schematic component (chip) body.
+   */
+  private _doesCandidateCrossChip(candidate: Point[]): boolean {
+    for (let i = 0; i < candidate.length - 1; i++) {
+      if (
+        this.chipObstacleSpatialIndex.doesOrthogonalLineIntersectChip([
+          candidate[i]!,
+          candidate[i + 1]!,
+        ])
+      ) {
+        return true
+      }
+    }
+    return false
+  }
+
   private _applyBestRoute(bestRoute: Point[]) {
     this.bestRoute = bestRoute
     this.collidingCandidate = null

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.67",
+  "version": "0.0.69",
   "type": "module",
   "scripts": {
     "start": "cosmos",