@tscircuit/schematic-trace-solver 0.0.91 → 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

@@ -577,7 +577,7 @@ var MspConnectionPairSolver = class extends BaseSolver {
 import "graphics-debug";
 
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts
-import { calculateElbow } from "calculate-elbow";
+import { calculateElbow as calculateElbow2 } from "calculate-elbow";
 
 // lib/solvers/GuidelinesSolver/getInputChipBounds.ts
 function getInputChipBounds(chip) {
@@ -846,6 +846,111 @@ function getRectBounds(center, w, h) {
   };
 }
 
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/calculateDirectShortPath.ts
+import { calculateElbow } from "calculate-elbow";
+var MAX_SHORT_TRACE_DISTANCE = 0.15;
+var SHORT_TRACE_OVERSHOOT = MAX_SHORT_TRACE_DISTANCE / 7.5;
+var FALLBACK_ELBOW_MAX_OVERSHOOT = 0.2;
+function segmentDirection(from, to) {
+  if (to.x > from.x) return "x+";
+  if (to.x < from.x) return "x-";
+  if (to.y > from.y) return "y+";
+  if (to.y < from.y) return "y-";
+  return null;
+}
+function pathMatchesPinDirections({
+  path,
+  pin1,
+  pin2
+}) {
+  const firstDirection = segmentDirection(path[0], path[1]);
+  const lastDirection = segmentDirection(
+    path[path.length - 1],
+    path[path.length - 2]
+  );
+  return firstDirection === pin1._facingDirection && lastDirection === pin2._facingDirection;
+}
+function calculateShortOrthogonalRoute(pin1, pin2) {
+  if (pin1.x === pin2.x || pin1.y === pin2.y) return null;
+  const firstDir = pin1._facingDirection;
+  const lastDir = pin2._facingDirection;
+  const start = { x: pin1.x, y: pin1.y };
+  const end = { x: pin2.x, y: pin2.y };
+  let path = null;
+  if (firstDir?.startsWith("y") && lastDir?.startsWith("x")) {
+    let yOffset = -SHORT_TRACE_OVERSHOOT;
+    if (firstDir === "y+") {
+      yOffset = SHORT_TRACE_OVERSHOOT;
+    }
+    const routeY = start.y + yOffset;
+    const routeX = (start.x + end.x) / 2;
+    path = [
+      start,
+      { x: start.x, y: routeY },
+      { x: routeX, y: routeY },
+      { x: routeX, y: end.y },
+      end
+    ];
+  } else if (firstDir?.startsWith("x") && lastDir?.startsWith("y")) {
+    let xOffset = -SHORT_TRACE_OVERSHOOT;
+    if (firstDir === "x+") {
+      xOffset = SHORT_TRACE_OVERSHOOT;
+    }
+    const routeX = start.x + xOffset;
+    const routeY = (start.y + end.y) / 2;
+    path = [
+      start,
+      { x: routeX, y: start.y },
+      { x: routeX, y: routeY },
+      { x: end.x, y: routeY },
+      end
+    ];
+  }
+  if (!path) return null;
+  if (pathMatchesPinDirections({ path, pin1, pin2 })) {
+    return path;
+  }
+  return null;
+}
+function calculateDirectShortPath(pin1, pin2) {
+  const routingDistance = Math.abs(pin1.x - pin2.x) + Math.abs(pin1.y - pin2.y);
+  if (routingDistance > MAX_SHORT_TRACE_DISTANCE) return null;
+  const start = { x: pin1.x, y: pin1.y };
+  const end = { x: pin2.x, y: pin2.y };
+  const orthogonalRoute = calculateShortOrthogonalRoute(pin1, pin2);
+  if (orthogonalRoute) return orthogonalRoute;
+  let candidatePaths = [];
+  if (pin1.x !== pin2.x && pin1.y !== pin2.y) {
+    candidatePaths = [
+      [start, { x: pin2.x, y: pin1.y }, end],
+      [start, { x: pin1.x, y: pin2.y }, end]
+    ];
+  } else {
+    candidatePaths = [[start, end]];
+  }
+  for (const path of candidatePaths) {
+    if (pathMatchesPinDirections({ path, pin1, pin2 })) return path;
+  }
+  return calculateElbow(
+    {
+      x: pin1.x,
+      y: pin1.y,
+      facingDirection: pin1._facingDirection
+    },
+    {
+      x: pin2.x,
+      y: pin2.y,
+      facingDirection: pin2._facingDirection
+    },
+    {
+      overshoot: Math.min(
+        FALLBACK_ELBOW_MAX_OVERSHOOT,
+        Math.max(SHORT_TRACE_OVERSHOOT, routingDistance / 4)
+      )
+    }
+  );
+}
+
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts
 var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
   pins;
@@ -885,7 +990,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
       ) : []
     );
     const [pin1, pin2] = this.pins;
-    this.baseElbow = calculateElbow(
+    const directShortPath = calculateDirectShortPath(pin1, pin2);
+    this.baseElbow = directShortPath ?? calculateElbow2(
       {
         x: pin1.x,
         y: pin1.y,
@@ -898,6 +1004,7 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
       },
       { overshoot: 0.2 }
     );
+    this.solvedTracePath = directShortPath;
     this.aabb = aabbFromPoints(
       { x: pin1.x, y: pin1.y },
       { x: pin2.x, y: pin2.y }
@@ -1005,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;
@@ -1103,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);
@@ -1136,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 });
     }
@@ -5520,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) {
@@ -5551,7 +5674,8 @@ var findBestReroutePath = ({
     obstacleLabel,
     outputTraces,
     outputNetLabelPlacements,
-    candidateResults
+    candidateResults,
+    chipObstacles
   });
   markSelectedCandidate(candidateResults, bestPath);
   return { bestPath, candidateResults };
@@ -5638,14 +5762,6 @@ var createCandidateResult = ({
       selected: false
     };
   }
-  if (doesPathRunAlongChipBoundary(path, chipObstacles)) {
-    return {
-      path,
-      status: "chip-collision",
-      usesHorizontalSegmentPush,
-      selected: false
-    };
-  }
   return {
     path,
     score: scoreTracePath({
@@ -5653,7 +5769,8 @@ var createCandidateResult = ({
       tracePath: path,
       obstacleLabel,
       outputTraces,
-      outputNetLabelPlacements
+      outputNetLabelPlacements,
+      chipObstacles
     }),
     status: "valid",
     usesHorizontalSegmentPush,
@@ -5743,7 +5860,8 @@ var selectBestReroutePath = ({
   obstacleLabel,
   outputTraces,
   outputNetLabelPlacements,
-  candidateResults
+  candidateResults,
+  chipObstacles
 }) => {
   for (const candidate of candidateResults) {
     if (!candidate.usesHorizontalSegmentPush) continue;
@@ -5757,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;
@@ -5843,7 +5962,8 @@ var scoreTracePath = ({
   tracePath,
   obstacleLabel,
   outputTraces,
-  outputNetLabelPlacements
+  outputNetLabelPlacements,
+  chipObstacles
 }) => {
   const candidateTrace = { ...trace, tracePath };
   return {
@@ -5853,6 +5973,7 @@ var scoreTracePath = ({
     }).length,
     labelHugDistance: getLabelHugDistance(tracePath, obstacleLabel),
     traceIntersections: countTraceIntersections(candidateTrace, outputTraces),
+    chipBoundaryOverlap: getChipBoundaryOverlap(tracePath, chipObstacles),
     pathLength: getPathLength(tracePath)
   };
 };
@@ -5865,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

@@ -18,6 +18,7 @@ import { pathKey, shiftSegmentOrth } from "./pathOps"
 import type { FacingDirection } from "lib/utils/dir"
 import { getDimsForOrientation } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
 import type { RectPadding } from "lib/utils/textBoxBounds"
+import { calculateDirectShortPath } from "./calculateDirectShortPath"
 
 type PathKey = string
 
@@ -80,21 +81,26 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
         : [],
     )
 
-    // Build initial elbow path
     const [pin1, pin2] = this.pins
-    this.baseElbow = calculateElbow(
-      {
-        x: pin1.x,
-        y: pin1.y,
-        facingDirection: pin1._facingDirection!,
-      },
-      {
-        x: pin2.x,
-        y: pin2.y,
-        facingDirection: pin2._facingDirection!,
-      },
-      { overshoot: 0.2 },
-    )
+    const directShortPath = calculateDirectShortPath(pin1, pin2)
+
+    // Build initial elbow path
+    this.baseElbow =
+      directShortPath ??
+      calculateElbow(
+        {
+          x: pin1.x,
+          y: pin1.y,
+          facingDirection: pin1._facingDirection!,
+        },
+        {
+          x: pin2.x,
+          y: pin2.y,
+          facingDirection: pin2._facingDirection!,
+        },
+        { overshoot: 0.2 },
+      )
+    this.solvedTracePath = directShortPath
 
     // Bounds defined by PA and PB
     this.aabb = aabbFromPoints(
@@ -233,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
@@ -356,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 = (
@@ -380,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) {
@@ -424,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 })
     }