@tscircuit/schematic-trace-solver 0.0.92 → 0.0.93

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) {
@@ -5658,7 +5674,8 @@ var findBestReroutePath = ({
     obstacleLabel,
     outputTraces,
     outputNetLabelPlacements,
-    candidateResults
+    candidateResults,
+    chipObstacles
   });
   markSelectedCandidate(candidateResults, bestPath);
   return { bestPath, candidateResults };
@@ -5745,14 +5762,6 @@ var createCandidateResult = ({
       selected: false
     };
   }
-  if (doesPathRunAlongChipBoundary(path, chipObstacles)) {
-    return {
-      path,
-      status: "chip-collision",
-      usesHorizontalSegmentPush,
-      selected: false
-    };
-  }
   return {
     path,
     score: scoreTracePath({
@@ -5760,7 +5769,8 @@ var createCandidateResult = ({
       tracePath: path,
       obstacleLabel,
       outputTraces,
-      outputNetLabelPlacements
+      outputNetLabelPlacements,
+      chipObstacles
     }),
     status: "valid",
     usesHorizontalSegmentPush,
@@ -5850,7 +5860,8 @@ var selectBestReroutePath = ({
   obstacleLabel,
   outputTraces,
   outputNetLabelPlacements,
-  candidateResults
+  candidateResults,
+  chipObstacles
 }) => {
   for (const candidate of candidateResults) {
     if (!candidate.usesHorizontalSegmentPush) continue;
@@ -5864,7 +5875,8 @@ var selectBestReroutePath = ({
     tracePath: trace.tracePath,
     obstacleLabel,
     outputTraces,
-    outputNetLabelPlacements
+    outputNetLabelPlacements,
+    chipObstacles
   });
   for (const candidate of candidateResults) {
     if (candidate.status !== "valid" || !candidate.score) continue;
@@ -5950,7 +5962,8 @@ var scoreTracePath = ({
   tracePath,
   obstacleLabel,
   outputTraces,
-  outputNetLabelPlacements
+  outputNetLabelPlacements,
+  chipObstacles
 }) => {
   const candidateTrace = { ...trace, tracePath };
   return {
@@ -5960,6 +5973,7 @@ var scoreTracePath = ({
     }).length,
     labelHugDistance: getLabelHugDistance(tracePath, obstacleLabel),
     traceIntersections: countTraceIntersections(candidateTrace, outputTraces),
+    chipBoundaryOverlap: getChipBoundaryOverlap(tracePath, chipObstacles),
     pathLength: getPathLength(tracePath)
   };
 };
@@ -5972,6 +5986,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

@@ -14,7 +14,7 @@ import {
   getPathLength,
   isPathCollidingWithChipInterior,
 } from "./geometry"
-import { doesPathRunAlongChipBoundary } from "./doesPathRunAlongChipBoundary"
+import { getChipBoundaryOverlap } from "./doesPathRunAlongChipBoundary"
 import type {
   ChipObstacle,
   RerouteCandidateResult,
@@ -52,6 +52,7 @@ export const findBestReroutePath = ({
     outputTraces,
     outputNetLabelPlacements,
     candidateResults,
+    chipObstacles,
   })
 
   markSelectedCandidate(candidateResults, bestPath)
@@ -166,15 +167,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 +180,7 @@ const createCandidateResult = ({
       obstacleLabel,
       outputTraces,
       outputNetLabelPlacements,
+      chipObstacles,
     }),
     status: "valid",
     usesHorizontalSegmentPush,
@@ -293,12 +291,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 +314,7 @@ const selectBestReroutePath = ({
     obstacleLabel,
     outputTraces,
     outputNetLabelPlacements,
+    chipObstacles,
   })
 
   for (const candidate of candidateResults) {
@@ -437,12 +438,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 +455,7 @@ const scoreTracePath = ({
     }).length,
     labelHugDistance: getLabelHugDistance(tracePath, obstacleLabel),
     traceIntersections: countTraceIntersections(candidateTrace, outputTraces),
+    chipBoundaryOverlap: getChipBoundaryOverlap(tracePath, chipObstacles),
     pathLength: getPathLength(tracePath),
   }
 }
@@ -469,6 +473,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.93",
   "type": "module",
   "scripts": {
     "start": "cosmos",