@tscircuit/schematic-trace-solver 0.0.88 → 0.0.90

package/dist/index.d.ts

@@ -170,6 +170,7 @@ declare class SchematicTraceSingleLineSolver2 extends BaseSolver {
     chipMap: Record<string, InputChip>;
     obstacles: ObstacleRect[];
     textObstacles: Set<ObstacleRect>;
+    endpointTextObstacles: Set<ObstacleRect>;
     aabb: {
         minX: number;
         maxX: number;
@@ -192,6 +193,9 @@ declare class SchematicTraceSingleLineSolver2 extends BaseSolver {
     private getNetLabelHeightForConnectionPair;
     private axisOfSegment;
     private pathLength;
+    private getPinBandPenalty;
+    private pathCost;
+    private isSegmentOutsidePinBand;
     _step(): void;
     visualize(): GraphicsObject;
 }

package/dist/index.js

@@ -854,6 +854,7 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
   chipMap;
   obstacles;
   textObstacles;
+  endpointTextObstacles;
   aabb;
   baseElbow;
   solvedTracePath = null;
@@ -877,6 +878,12 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     this.textObstacles = new Set(
       this.obstacles.filter((r) => r.kind === "text_box")
     );
+    const endpointChipIds = new Set(this.pins.map((pin) => pin.chipId));
+    this.endpointTextObstacles = new Set(
+      endpointChipIds.size > 1 ? this.obstacles.filter(
+        (r) => r.kind === "text_box" && r.textBox.chipId !== void 0 && endpointChipIds.has(r.textBox.chipId)
+      ) : []
+    );
     const [pin1, pin2] = this.pins;
     this.baseElbow = calculateElbow(
       {
@@ -985,6 +992,31 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     }
     return sum;
   }
+  getPinBandPenalty(path) {
+    let penalty = 0;
+    for (let i = 1; i < path.length - 2; i++) {
+      const a = path[i];
+      const b = path[i + 1];
+      if (isHorizontal(a, b) && a.y > this.aabb.minY && a.y < this.aabb.maxY) {
+        penalty += 10;
+      } else if (isVertical(a, b) && a.x > this.aabb.minX && a.x < this.aabb.maxX) {
+        penalty += 10;
+      }
+    }
+    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;
+    }
+    if (isVertical(a, b)) {
+      return a.x <= this.aabb.minX || a.x >= this.aabb.maxX;
+    }
+    return false;
+  }
   _step() {
     if (this.solvedTracePath) {
       this.solved = true;
@@ -1000,10 +1032,17 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     const [PA, PB] = this.pins;
     const collision = findFirstCollision(path, this.obstacles, {
       excludeRectsForSegment: (segIndex2) => {
-        const lastSegIndex = path.length - 2;
-        if (segIndex2 === 0 || segIndex2 === lastSegIndex) {
+        const lastSegIndex2 = path.length - 2;
+        if (segIndex2 === 0 || segIndex2 === lastSegIndex2) {
           return this.textObstacles;
         }
+        const adjacentEndpointSegIndex = segIndex2 === 1 ? 2 : segIndex2 === lastSegIndex2 - 1 ? lastSegIndex2 - 2 : null;
+        if (adjacentEndpointSegIndex !== null && adjacentEndpointSegIndex >= 0 && adjacentEndpointSegIndex < lastSegIndex2 && this.isSegmentOutsidePinBand(
+          path[adjacentEndpointSegIndex],
+          path[adjacentEndpointSegIndex + 1]
+        )) {
+          return this.endpointTextObstacles;
+        }
         return /* @__PURE__ */ new Set();
       }
     });
@@ -1018,6 +1057,7 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
       }
       return;
     }
+    const originalSegIndex = collision.segIndex;
     let { segIndex, rect } = collision;
     const isFirstSegment = segIndex === 0;
     const isLastSegment = segIndex === path.length - 2;
@@ -1050,16 +1090,51 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
       candidates.push(...mids);
     }
     const newStates = [];
-    for (const coord of candidates) {
-      const newPath = shiftSegmentOrth(path, segIndex, axis, coord);
-      if (!newPath) continue;
+    const addShiftedCandidate = (candidateSegIndex, candidateAxis, coord) => {
+      const newPath = shiftSegmentOrth(
+        path,
+        candidateSegIndex,
+        candidateAxis,
+        coord
+      );
+      if (!newPath) return;
       const key = pathKey(newPath);
-      if (this.visited.has(key)) continue;
+      if (this.visited.has(key)) return;
       this.visited.add(key);
       const nextSet = new Set(collisionRects);
       nextSet.add(rect);
-      const len = this.pathLength(newPath);
+      const len = this.pathCost(newPath);
       newStates.push({ path: newPath, collisionRects: nextSet, len });
+    };
+    for (const coord of candidates) {
+      addShiftedCandidate(segIndex, axis, coord);
+    }
+    const lastSegIndex = path.length - 2;
+    const adjacentSegmentIndexes = originalSegIndex === 1 ? [2] : originalSegIndex === lastSegIndex - 1 ? [lastSegIndex - 2] : [];
+    for (const adjacentSegIndex of adjacentSegmentIndexes) {
+      if (adjacentSegIndex < 0 || adjacentSegIndex >= lastSegIndex) continue;
+      const adjacentAxis = this.axisOfSegment(
+        path[adjacentSegIndex],
+        path[adjacentSegIndex + 1]
+      );
+      if (!adjacentAxis || adjacentAxis === axis) continue;
+      const adjacentCandidates = [
+        ...midBetweenPointAndRect(adjacentAxis, { x: PA.x, y: PA.y }, rect),
+        ...midBetweenPointAndRect(adjacentAxis, { x: PB.x, y: PB.y }, rect)
+      ];
+      if (collisionRects.size > 0) {
+        adjacentCandidates.push(
+          ...candidateMidsFromSet(
+            adjacentAxis,
+            rect,
+            collisionRects,
+            this.aabb
+          )
+        );
+      }
+      for (const coord of [...new Set(adjacentCandidates)]) {
+        addShiftedCandidate(adjacentSegIndex, adjacentAxis, coord);
+      }
     }
     newStates.sort((a2, b2) => a2.len - b2.len);
     for (const st of newStates) {
@@ -5419,6 +5494,28 @@ var moveAttachedLabelsToReroutedTrace = ({
   };
 });
 
+// lib/solvers/Example28Solver/doesPathRunAlongChipBoundary.ts
+var doesPathRunAlongChipBoundary = (path, chipObstacles) => {
+  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;
+      if (getSegmentOverlapWithRectSpan(start, end, obstacle) > EPS7) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+var getSegmentOverlapWithRectSpan = (start, end, rect) => {
+  const isVertical4 = Math.abs(start.x - end.x) < EPS7;
+  if (isVertical4) {
+    return Math.min(Math.max(start.y, end.y), rect.maxY) - Math.max(Math.min(start.y, end.y), rect.minY);
+  }
+  return Math.min(Math.max(start.x, end.x), rect.maxX) - Math.max(Math.min(start.x, end.x), rect.minX);
+};
+
 // lib/solvers/Example28Solver/reroute.ts
 var LABEL_CLEARANCE = 0.1;
 var findBestReroutePath = ({
@@ -5529,6 +5626,14 @@ var createCandidateResult = ({
       selected: false
     };
   }
+  if (doesPathRunAlongChipBoundary(path, chipObstacles)) {
+    return {
+      path,
+      status: "chip-collision",
+      usesHorizontalSegmentPush,
+      selected: false
+    };
+  }
   return {
     path,
     score: scoreTracePath({
@@ -5792,28 +5897,6 @@ var countCrossingsWithOtherTraces = (params) => {
   return crossingCount;
 };
 
-// lib/solvers/Example28Solver/doesPathRunAlongChipBoundary.ts
-var doesPathRunAlongChipBoundary = (path, chipObstacles) => {
-  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;
-      if (getSegmentOverlapWithRectSpan(start, end, obstacle) > EPS7) {
-        return true;
-      }
-    }
-  }
-  return false;
-};
-var getSegmentOverlapWithRectSpan = (start, end, rect) => {
-  const isVertical4 = Math.abs(start.x - end.x) < EPS7;
-  if (isVertical4) {
-    return Math.min(Math.max(start.y, end.y), rect.maxY) - Math.max(Math.min(start.y, end.y), rect.minY);
-  }
-  return Math.min(Math.max(start.x, end.x), rect.maxX) - Math.max(Math.min(start.x, end.x), rect.minX);
-};
-
 // lib/solvers/Example28Solver/scoreSolutionTracePath.ts
 var scoreSolutionTracePath = (params) => {
   const { traces, outputTraces, chipObstacles } = params;

package/lib/solvers/Example28Solver/reroute.ts

@@ -14,6 +14,7 @@ import {
   getPathLength,
   isPathCollidingWithChipInterior,
 } from "./geometry"
+import { doesPathRunAlongChipBoundary } from "./doesPathRunAlongChipBoundary"
 import type {
   ChipObstacle,
   RerouteCandidateResult,
@@ -165,6 +166,15 @@ const createCandidateResult = ({
     }
   }
 
+  if (doesPathRunAlongChipBoundary(path, chipObstacles)) {
+    return {
+      path,
+      status: "chip-collision",
+      usesHorizontalSegmentPush,
+      selected: false,
+    }
+  }
+
   return {
     path,
     score: scoreTracePath({

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

@@ -29,6 +29,7 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
 
   obstacles: ObstacleRect[]
   textObstacles: Set<ObstacleRect>
+  endpointTextObstacles: Set<ObstacleRect>
   aabb: { minX: number; maxX: number; minY: number; maxY: number }
 
   baseElbow: Point[]
@@ -67,6 +68,17 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     this.textObstacles = new Set(
       this.obstacles.filter((r) => r.kind === "text_box"),
     )
+    const endpointChipIds = new Set(this.pins.map((pin) => pin.chipId))
+    this.endpointTextObstacles = new Set(
+      endpointChipIds.size > 1
+        ? this.obstacles.filter(
+            (r) =>
+              r.kind === "text_box" &&
+              r.textBox.chipId !== undefined &&
+              endpointChipIds.has(r.textBox.chipId),
+          )
+        : [],
+    )
 
     // Build initial elbow path
     const [pin1, pin2] = this.pins
@@ -203,6 +215,38 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     return sum
   }
 
+  private getPinBandPenalty(path: Point[]): number {
+    let penalty = 0
+    for (let i = 1; i < path.length - 2; i++) {
+      const a = path[i]!
+      const b = path[i + 1]!
+      if (isHorizontal(a, b) && a.y > this.aabb.minY && a.y < this.aabb.maxY) {
+        penalty += 10
+      } else if (
+        isVertical(a, b) &&
+        a.x > this.aabb.minX &&
+        a.x < this.aabb.maxX
+      ) {
+        penalty += 10
+      }
+    }
+    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
+    }
+    if (isVertical(a, b)) {
+      return a.x <= this.aabb.minX || a.x >= this.aabb.maxX
+    }
+    return false
+  }
+
   override _step() {
     if (this.solvedTracePath) {
       this.solved = true
@@ -225,6 +269,23 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
         if (segIndex === 0 || segIndex === lastSegIndex) {
           return this.textObstacles
         }
+        const adjacentEndpointSegIndex =
+          segIndex === 1
+            ? 2
+            : segIndex === lastSegIndex - 1
+              ? lastSegIndex - 2
+              : null
+        if (
+          adjacentEndpointSegIndex !== null &&
+          adjacentEndpointSegIndex >= 0 &&
+          adjacentEndpointSegIndex < lastSegIndex &&
+          this.isSegmentOutsidePinBand(
+            path[adjacentEndpointSegIndex]!,
+            path[adjacentEndpointSegIndex + 1]!,
+          )
+        ) {
+          return this.endpointTextObstacles
+        }
         return new Set<ObstacleRect>()
       },
     })
@@ -246,6 +307,7 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       return
     }
 
+    const originalSegIndex = collision.segIndex
     let { segIndex, rect } = collision
 
     // Never move the first or last segments - move adjacent segment instead
@@ -301,18 +363,67 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       len: number
     }> = []
 
-    for (const coord of candidates) {
-      const newPath = shiftSegmentOrth(path, segIndex, axis, coord)
-      if (!newPath) continue
+    const addShiftedCandidate = (
+      candidateSegIndex: number,
+      candidateAxis: Axis,
+      coord: number,
+    ) => {
+      const newPath = shiftSegmentOrth(
+        path,
+        candidateSegIndex,
+        candidateAxis,
+        coord,
+      )
+      if (!newPath) return
       const key = pathKey(newPath)
-      if (this.visited.has(key)) continue
+      if (this.visited.has(key)) return
       this.visited.add(key)
       const nextSet = new Set(collisionRects)
       nextSet.add(rect)
-      const len = this.pathLength(newPath)
+      const len = this.pathCost(newPath)
       newStates.push({ path: newPath, collisionRects: nextSet, len })
     }
 
+    for (const coord of candidates) {
+      addShiftedCandidate(segIndex, axis, coord)
+    }
+
+    const lastSegIndex = path.length - 2
+    const adjacentSegmentIndexes =
+      originalSegIndex === 1
+        ? [2]
+        : originalSegIndex === lastSegIndex - 1
+          ? [lastSegIndex - 2]
+          : []
+
+    for (const adjacentSegIndex of adjacentSegmentIndexes) {
+      if (adjacentSegIndex < 0 || adjacentSegIndex >= lastSegIndex) continue
+      const adjacentAxis = this.axisOfSegment(
+        path[adjacentSegIndex]!,
+        path[adjacentSegIndex + 1]!,
+      )
+      if (!adjacentAxis || adjacentAxis === axis) continue
+
+      const adjacentCandidates = [
+        ...midBetweenPointAndRect(adjacentAxis, { x: PA.x, y: PA.y }, rect),
+        ...midBetweenPointAndRect(adjacentAxis, { x: PB.x, y: PB.y }, rect),
+      ]
+      if (collisionRects.size > 0) {
+        adjacentCandidates.push(
+          ...candidateMidsFromSet(
+            adjacentAxis,
+            rect,
+            collisionRects,
+            this.aabb,
+          ),
+        )
+      }
+
+      for (const coord of [...new Set(adjacentCandidates)]) {
+        addShiftedCandidate(adjacentSegIndex, adjacentAxis, coord)
+      }
+    }
+
     newStates.sort((a, b) => a.len - b.len)
     for (const st of newStates) {
       this.queue.push({ path: st.path, collisionRects: st.collisionRects })

package/lib/testing/PipelineStageDebugRunner.ts

@@ -1,9 +1,7 @@
 import { mkdir, writeFile } from "node:fs/promises"
 import path from "node:path"
-import {
-  getPngBufferFromGraphicsObject,
-  getSvgFromGraphicsObject,
-} from "graphics-debug"
+import * as graphicsDebug from "graphics-debug"
+import { getSvgFromGraphicsObject } from "graphics-debug"
 import type { GraphicsObject } from "graphics-debug"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
@@ -262,6 +260,25 @@ export class PipelineStageDebugRunner {
   }
 
   private renderGraphicsToPng(graphics: GraphicsObject): Promise<Uint8Array> {
+    const getPngBufferFromGraphicsObject = (
+      graphicsDebug as unknown as {
+        getPngBufferFromGraphicsObject?: (
+          graphics: GraphicsObject,
+          opts: {
+            backgroundColor: string
+            pngWidth: number
+            pngHeight: number
+          },
+        ) => Promise<Uint8Array>
+      }
+    ).getPngBufferFromGraphicsObject
+
+    if (!getPngBufferFromGraphicsObject) {
+      throw new Error(
+        "graphics-debug does not provide getPngBufferFromGraphicsObject; run with --no-png --svg or upgrade graphics-debug",
+      )
+    }
+
     return getPngBufferFromGraphicsObject(graphics, {
       backgroundColor: "white",
       pngWidth: this.pngWidth,

package/package.json

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