@tscircuit/schematic-trace-solver 0.0.92 → 0.0.94

package/dist/index.d.ts

@@ -194,7 +194,6 @@ declare class SchematicTraceSingleLineSolver2 extends BaseSolver {
     private axisOfSegment;
     private pathLength;
     private getPinBandPenalty;
-    private pathCost;
     private isSegmentOutsidePinBand;
     _step(): void;
     visualize(): GraphicsObject;
@@ -650,6 +649,13 @@ type TracePathScore = {
     labelIntersections: number;
     labelHugDistance: number;
     traceIntersections: number;
+    /**
+     * Total length the path runs along a chip boundary. A soft quality penalty
+     * (traces hugging a chip edge look bad) that is only preferred against once
+     * the more important factors above are equal, so a boundary-hugging route is
+     * still chosen over one that actually overlaps a label or another trace.
+     */
+    chipBoundaryOverlap: number;
     pathLength: number;
 };
 type RerouteCandidateResult = {

package/dist/index.js

@@ -1112,9 +1112,6 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     }
     return penalty;
   }
-  pathCost(path) {
-    return this.pathLength(path) + this.getPinBandPenalty(path);
-  }
   isSegmentOutsidePinBand(a, b) {
     if (isHorizontal(a, b)) {
       return a.y <= this.aabb.minY || a.y >= this.aabb.maxY;
@@ -1210,8 +1207,12 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
       this.visited.add(key);
       const nextSet = new Set(collisionRects);
       nextSet.add(rect);
-      const len = this.pathCost(newPath);
-      newStates.push({ path: newPath, collisionRects: nextSet, len });
+      newStates.push({
+        path: newPath,
+        collisionRects: nextSet,
+        length: this.pathLength(newPath),
+        pinBandPenalty: this.getPinBandPenalty(newPath)
+      });
     };
     for (const coord of candidates) {
       addShiftedCandidate(segIndex, axis, coord);
@@ -1243,7 +1244,9 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
         addShiftedCandidate(adjacentSegIndex, adjacentAxis, coord);
       }
     }
-    newStates.sort((a2, b2) => a2.len - b2.len);
+    newStates.sort(
+      (a2, b2) => a2.length - b2.length || a2.pinBandPenalty - b2.pinBandPenalty
+    );
     for (const st of newStates) {
       this.queue.push({ path: st.path, collisionRects: st.collisionRects });
     }
@@ -5627,6 +5630,19 @@ var doesPathRunAlongChipBoundary = (path, chipObstacles) => {
   }
   return false;
 };
+var getChipBoundaryOverlap = (path, chipObstacles) => {
+  let total = 0;
+  for (let i = 0; i < path.length - 1; i++) {
+    const start = path[i];
+    const end = path[i + 1];
+    for (const obstacle of chipObstacles) {
+      if (!segmentRunsAlongRectBoundary(start, end, obstacle)) continue;
+      const overlap = getSegmentOverlapWithRectSpan(start, end, obstacle);
+      if (overlap > EPS7) total += overlap;
+    }
+  }
+  return total;
+};
 var getSegmentOverlapWithRectSpan = (start, end, rect) => {
   const isVertical4 = Math.abs(start.x - end.x) < EPS7;
   if (isVertical4) {
@@ -5637,6 +5653,30 @@ var getSegmentOverlapWithRectSpan = (start, end, rect) => {
 
 // lib/solvers/Example28Solver/reroute.ts
 var LABEL_CLEARANCE = 0.1;
+var MAX_CORRIDOR_SHIFTS = 16;
+var corridorHasOtherNetTrace = ({
+  x,
+  lowY,
+  highY,
+  outputTraces,
+  netId
+}) => {
+  for (const other of outputTraces) {
+    if (other.globalConnNetId === netId) continue;
+    const path = other.tracePath;
+    for (let i = 0; i + 1 < path.length; i++) {
+      const start = path[i];
+      const end = path[i + 1];
+      if (Math.abs(start.x - end.x) >= 1e-9) continue;
+      if (Math.abs(start.x - x) >= LABEL_CLEARANCE / 2) continue;
+      const segLowY = Math.min(start.y, end.y);
+      const segHighY = Math.max(start.y, end.y);
+      if (Math.min(highY, segHighY) - Math.max(lowY, segLowY) > 1e-6)
+        return true;
+    }
+  }
+  return false;
+};
 var findBestReroutePath = ({
   trace,
   obstacleLabel,
@@ -5658,7 +5698,8 @@ var findBestReroutePath = ({
     obstacleLabel,
     outputTraces,
     outputNetLabelPlacements,
-    candidateResults
+    candidateResults,
+    chipObstacles
   });
   markSelectedCandidate(candidateResults, bestPath);
   return { bestPath, candidateResults };
@@ -5674,8 +5715,11 @@ var generateRerouteCandidateResults = ({
   const seen = /* @__PURE__ */ new Set();
   const candidateResults = [];
   const horizontalSegmentPushCandidate = generateHorizontalSegmentPushCandidate(
-    trace,
-    label
+    {
+      trace,
+      label,
+      outputTraces
+    }
   );
   if (horizontalSegmentPushCandidate) {
     candidateResults.push(
@@ -5745,14 +5789,6 @@ var createCandidateResult = ({
       selected: false
     };
   }
-  if (doesPathRunAlongChipBoundary(path, chipObstacles)) {
-    return {
-      path,
-      status: "chip-collision",
-      usesHorizontalSegmentPush,
-      selected: false
-    };
-  }
   return {
     path,
     score: scoreTracePath({
@@ -5760,7 +5796,8 @@ var createCandidateResult = ({
       tracePath: path,
       obstacleLabel,
       outputTraces,
-      outputNetLabelPlacements
+      outputNetLabelPlacements,
+      chipObstacles
     }),
     status: "valid",
     usesHorizontalSegmentPush,
@@ -5850,7 +5887,8 @@ var selectBestReroutePath = ({
   obstacleLabel,
   outputTraces,
   outputNetLabelPlacements,
-  candidateResults
+  candidateResults,
+  chipObstacles
 }) => {
   for (const candidate of candidateResults) {
     if (!candidate.usesHorizontalSegmentPush) continue;
@@ -5864,7 +5902,8 @@ var selectBestReroutePath = ({
     tracePath: trace.tracePath,
     obstacleLabel,
     outputTraces,
-    outputNetLabelPlacements
+    outputNetLabelPlacements,
+    chipObstacles
   });
   for (const candidate of candidateResults) {
     if (candidate.status !== "valid" || !candidate.score) continue;
@@ -5874,7 +5913,11 @@ var selectBestReroutePath = ({
   }
   return bestPath;
 };
-var generateHorizontalSegmentPushCandidate = (trace, label) => {
+var generateHorizontalSegmentPushCandidate = ({
+  trace,
+  label,
+  outputTraces
+}) => {
   const labelDirection = dir(label.orientation);
   if (labelDirection.x === 0) return null;
   const path = trace.tracePath;
@@ -5899,6 +5942,20 @@ var generateHorizontalSegmentPushCandidate = (trace, label) => {
   if (labelDirection.x > 0) {
     segmentPushX = bounds.maxX + LABEL_CLEARANCE;
   }
+  const corridorStep = labelDirection.x > 0 ? LABEL_CLEARANCE : -LABEL_CLEARANCE;
+  const verticalLowY = Math.min(verticalStart.y, verticalEnd.y);
+  const verticalHighY = Math.max(verticalStart.y, verticalEnd.y);
+  for (let shift = 0; shift < MAX_CORRIDOR_SHIFTS; shift++) {
+    const occupied = corridorHasOtherNetTrace({
+      x: segmentPushX,
+      lowY: verticalLowY,
+      highY: verticalHighY,
+      outputTraces,
+      netId: trace.globalConnNetId
+    });
+    if (!occupied) break;
+    segmentPushX += corridorStep;
+  }
   const segmentPushStartY = getClearedHorizontalY({
     start: previousAnchor,
     end: { x: segmentPushX, y: verticalStart.y },
@@ -5950,7 +6007,8 @@ var scoreTracePath = ({
   tracePath,
   obstacleLabel,
   outputTraces,
-  outputNetLabelPlacements
+  outputNetLabelPlacements,
+  chipObstacles
 }) => {
   const candidateTrace = { ...trace, tracePath };
   return {
@@ -5960,6 +6018,7 @@ var scoreTracePath = ({
     }).length,
     labelHugDistance: getLabelHugDistance(tracePath, obstacleLabel),
     traceIntersections: countTraceIntersections(candidateTrace, outputTraces),
+    chipBoundaryOverlap: getChipBoundaryOverlap(tracePath, chipObstacles),
     pathLength: getPathLength(tracePath)
   };
 };
@@ -5972,6 +6031,14 @@ var countTraceIntersections = (trace, outputTraces) => {
   return count;
 };
 var isBetterScore = (score, bestScore) => {
+  const scoreHasLabelOverlap = score.labelIntersections > 0;
+  const bestHasLabelOverlap = bestScore.labelIntersections > 0;
+  if (scoreHasLabelOverlap !== bestHasLabelOverlap) {
+    return !scoreHasLabelOverlap;
+  }
+  if (score.chipBoundaryOverlap !== bestScore.chipBoundaryOverlap) {
+    return score.chipBoundaryOverlap < bestScore.chipBoundaryOverlap;
+  }
   if (score.labelIntersections !== bestScore.labelIntersections) {
     return score.labelIntersections < bestScore.labelIntersections;
   }

package/lib/solvers/Example28Solver/doesPathRunAlongChipBoundary.ts

@@ -20,6 +20,24 @@ export const doesPathRunAlongChipBoundary = (
   return false
 }
 
+/** Total length of the path that runs along (overlapping) a chip boundary. */
+export const getChipBoundaryOverlap = (
+  path: Point[],
+  chipObstacles: ChipObstacle[],
+) => {
+  let total = 0
+  for (let i = 0; i < path.length - 1; i++) {
+    const start = path[i]!
+    const end = path[i + 1]!
+    for (const obstacle of chipObstacles) {
+      if (!segmentRunsAlongRectBoundary(start, end, obstacle)) continue
+      const overlap = getSegmentOverlapWithRectSpan(start, end, obstacle)
+      if (overlap > EPS) total += overlap
+    }
+  }
+  return total
+}
+
 const getSegmentOverlapWithRectSpan = (
   start: Point,
   end: Point,

package/lib/solvers/Example28Solver/reroute.ts

@@ -8,13 +8,13 @@ import { detectTraceLabelOverlap } from "lib/solvers/TraceLabelOverlapAvoidanceS
 import { generateRerouteCandidates } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/rerouteCollidingTrace"
 import type { InputProblem } from "lib/types/InputProblem"
 import { dir } from "lib/utils/dir"
+import { getChipBoundaryOverlap } from "./doesPathRunAlongChipBoundary"
 import {
   countPathIntersections,
   getPathKey,
   getPathLength,
   isPathCollidingWithChipInterior,
 } from "./geometry"
-import { doesPathRunAlongChipBoundary } from "./doesPathRunAlongChipBoundary"
 import type {
   ChipObstacle,
   RerouteCandidateResult,
@@ -22,6 +22,43 @@ import type {
 } from "./types"
 
 const LABEL_CLEARANCE = 0.1
+// How many LABEL_CLEARANCE-wide corridors to try before giving up on finding a
+// free one for a pushed segment.
+const MAX_CORRIDOR_SHIFTS = 16
+
+/**
+ * Whether a vertical trace segment of a different net already runs along the
+ * corridor at `x`, overlapping the [lowY, highY] span (within a corridor width).
+ */
+const corridorHasOtherNetTrace = ({
+  x,
+  lowY,
+  highY,
+  outputTraces,
+  netId,
+}: {
+  x: number
+  lowY: number
+  highY: number
+  outputTraces: SolvedTracePath[]
+  netId: string
+}): boolean => {
+  for (const other of outputTraces) {
+    if (other.globalConnNetId === netId) continue
+    const path = other.tracePath
+    for (let i = 0; i + 1 < path.length; i++) {
+      const start = path[i]!
+      const end = path[i + 1]!
+      if (Math.abs(start.x - end.x) >= 1e-9) continue
+      if (Math.abs(start.x - x) >= LABEL_CLEARANCE / 2) continue
+      const segLowY = Math.min(start.y, end.y)
+      const segHighY = Math.max(start.y, end.y)
+      if (Math.min(highY, segHighY) - Math.max(lowY, segLowY) > 1e-6)
+        return true
+    }
+  }
+  return false
+}
 
 export const findBestReroutePath = ({
   trace,
@@ -52,6 +89,7 @@ export const findBestReroutePath = ({
     outputTraces,
     outputNetLabelPlacements,
     candidateResults,
+    chipObstacles,
   })
 
   markSelectedCandidate(candidateResults, bestPath)
@@ -77,8 +115,11 @@ export const generateRerouteCandidateResults = ({
   const seen = new Set<string>()
   const candidateResults: RerouteCandidateResult[] = []
   const horizontalSegmentPushCandidate = generateHorizontalSegmentPushCandidate(
-    trace,
-    label,
+    {
+      trace,
+      label,
+      outputTraces,
+    },
   )
 
   if (horizontalSegmentPushCandidate) {
@@ -166,15 +207,11 @@ const createCandidateResult = ({
     }
   }
 
-  if (doesPathRunAlongChipBoundary(path, chipObstacles)) {
-    return {
-      path,
-      status: "chip-collision",
-      usesHorizontalSegmentPush,
-      selected: false,
-    }
-  }
-
+  // Note: a path that merely runs along a chip boundary is NOT rejected here.
+  // It is a valid route, just a lower-quality one — scoreTracePath penalizes it
+  // via chipBoundaryOverlap so it loses only to routes that are otherwise as
+  // good. Hard-rejecting it discarded the best available route when every
+  // alternative overlapped a label or another trace.
   return {
     path,
     score: scoreTracePath({
@@ -183,6 +220,7 @@ const createCandidateResult = ({
       obstacleLabel,
       outputTraces,
       outputNetLabelPlacements,
+      chipObstacles,
     }),
     status: "valid",
     usesHorizontalSegmentPush,
@@ -293,12 +331,14 @@ const selectBestReroutePath = ({
   outputTraces,
   outputNetLabelPlacements,
   candidateResults,
+  chipObstacles,
 }: {
   trace: SolvedTracePath
   obstacleLabel: NetLabelPlacement
   outputTraces: SolvedTracePath[]
   outputNetLabelPlacements: NetLabelPlacement[]
   candidateResults: RerouteCandidateResult[]
+  chipObstacles: ChipObstacle[]
 }) => {
   for (const candidate of candidateResults) {
     if (!candidate.usesHorizontalSegmentPush) continue
@@ -314,6 +354,7 @@ const selectBestReroutePath = ({
     obstacleLabel,
     outputTraces,
     outputNetLabelPlacements,
+    chipObstacles,
   })
 
   for (const candidate of candidateResults) {
@@ -327,10 +368,15 @@ const selectBestReroutePath = ({
   return bestPath
 }
 
-const generateHorizontalSegmentPushCandidate = (
-  trace: SolvedTracePath,
-  label: NetLabelPlacement,
-): Point[] | null => {
+const generateHorizontalSegmentPushCandidate = ({
+  trace,
+  label,
+  outputTraces,
+}: {
+  trace: SolvedTracePath
+  label: NetLabelPlacement
+  outputTraces: SolvedTracePath[]
+}): Point[] | null => {
   const labelDirection = dir(label.orientation)
   if (labelDirection.x === 0) return null
 
@@ -366,6 +412,25 @@ const generateHorizontalSegmentPushCandidate = (
   if (labelDirection.x > 0) {
     segmentPushX = bounds.maxX + LABEL_CLEARANCE
   }
+
+  // Two traces escaping the same label block would otherwise be pushed to the
+  // identical corridor and stack on one line. Slide the corridor further out
+  // until it no longer coincides with a different-net trace already routed
+  // there, giving each escaping trace its own parallel corridor.
+  const corridorStep = labelDirection.x > 0 ? LABEL_CLEARANCE : -LABEL_CLEARANCE
+  const verticalLowY = Math.min(verticalStart.y, verticalEnd.y)
+  const verticalHighY = Math.max(verticalStart.y, verticalEnd.y)
+  for (let shift = 0; shift < MAX_CORRIDOR_SHIFTS; shift++) {
+    const occupied = corridorHasOtherNetTrace({
+      x: segmentPushX,
+      lowY: verticalLowY,
+      highY: verticalHighY,
+      outputTraces,
+      netId: trace.globalConnNetId,
+    })
+    if (!occupied) break
+    segmentPushX += corridorStep
+  }
   const segmentPushStartY = getClearedHorizontalY({
     start: previousAnchor,
     end: { x: segmentPushX, y: verticalStart.y },
@@ -437,12 +502,14 @@ const scoreTracePath = ({
   obstacleLabel,
   outputTraces,
   outputNetLabelPlacements,
+  chipObstacles,
 }: {
   trace: SolvedTracePath
   tracePath: Point[]
   obstacleLabel: NetLabelPlacement
   outputTraces: SolvedTracePath[]
   outputNetLabelPlacements: NetLabelPlacement[]
+  chipObstacles: ChipObstacle[]
 }): TracePathScore => {
   const candidateTrace = { ...trace, tracePath }
   return {
@@ -452,6 +519,7 @@ const scoreTracePath = ({
     }).length,
     labelHugDistance: getLabelHugDistance(tracePath, obstacleLabel),
     traceIntersections: countTraceIntersections(candidateTrace, outputTraces),
+    chipBoundaryOverlap: getChipBoundaryOverlap(tracePath, chipObstacles),
     pathLength: getPathLength(tracePath),
   }
 }
@@ -469,6 +537,21 @@ const countTraceIntersections = (
 }
 
 const isBetterScore = (score: TracePathScore, bestScore: TracePathScore) => {
+  // A route with no label overlap is always preferred over one with any. This
+  // is separate from the full overlap count below so that a *clean* route wins
+  // even if it hugs a chip boundary, while a route that must overlap a label is
+  // still steered away from also hugging a boundary.
+  const scoreHasLabelOverlap = score.labelIntersections > 0
+  const bestHasLabelOverlap = bestScore.labelIntersections > 0
+  if (scoreHasLabelOverlap !== bestHasLabelOverlap) {
+    // Reached only when exactly one route overlaps a label; the clean one wins.
+    return !scoreHasLabelOverlap
+  }
+  // Boundary hugging is only accepted as the price of a clean route; once a
+  // label overlap is unavoidable, avoid hugging a boundary on top of it.
+  if (score.chipBoundaryOverlap !== bestScore.chipBoundaryOverlap) {
+    return score.chipBoundaryOverlap < bestScore.chipBoundaryOverlap
+  }
   if (score.labelIntersections !== bestScore.labelIntersections) {
     return score.labelIntersections < bestScore.labelIntersections
   }

package/lib/solvers/Example28Solver/types.ts

@@ -15,6 +15,13 @@ export type TracePathScore = {
   labelIntersections: number
   labelHugDistance: number
   traceIntersections: number
+  /**
+   * Total length the path runs along a chip boundary. A soft quality penalty
+   * (traces hugging a chip edge look bad) that is only preferred against once
+   * the more important factors above are equal, so a boundary-hugging route is
+   * still chosen over one that actually overlaps a label or another trace.
+   */
+  chipBoundaryOverlap: number
   pathLength: number
 }
 

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

@@ -239,10 +239,6 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     return penalty
   }
 
-  private pathCost(path: Point[]): number {
-    return this.pathLength(path) + this.getPinBandPenalty(path)
-  }
-
   private isSegmentOutsidePinBand(a: Point, b: Point): boolean {
     if (isHorizontal(a, b)) {
       return a.y <= this.aabb.minY || a.y >= this.aabb.maxY
@@ -362,11 +358,15 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       candidates.push(...mids)
     }
 
-    // Generate new shifted paths, order by total path length (shorter first)
+    // Generate new shifted paths. Order by path length first, then prefer paths
+    // that stay out of the pin band. The pin-band preference is a tiebreaker
+    // only: it must never make the solver pick a longer route (a flat additive
+    // penalty would, discarding a shorter valid route in favor of a detour).
     const newStates: Array<{
       path: Point[]
       collisionRects: Set<ObstacleRect>
-      len: number
+      length: number
+      pinBandPenalty: number
     }> = []
 
     const addShiftedCandidate = (
@@ -386,8 +386,12 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       this.visited.add(key)
       const nextSet = new Set(collisionRects)
       nextSet.add(rect)
-      const len = this.pathCost(newPath)
-      newStates.push({ path: newPath, collisionRects: nextSet, len })
+      newStates.push({
+        path: newPath,
+        collisionRects: nextSet,
+        length: this.pathLength(newPath),
+        pinBandPenalty: this.getPinBandPenalty(newPath),
+      })
     }
 
     for (const coord of candidates) {
@@ -430,7 +434,9 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       }
     }
 
-    newStates.sort((a, b) => a.len - b.len)
+    newStates.sort(
+      (a, b) => a.length - b.length || a.pinBandPenalty - b.pinBandPenalty,
+    )
     for (const st of newStates) {
       this.queue.push({ path: st.path, collisionRects: st.collisionRects })
     }

package/package.json

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