@tscircuit/schematic-trace-solver 0.0.30 → 0.0.32

package/CLAUDE.md

@@ -0,0 +1,8 @@
+- use `bunx tsc --noEmit` to type check
+- use `bun test path/to/test.ts` to run a test
+- use `bun add <package>` to add a package
+
+There are two ways the user tests the algorithm:
+
+- Running `bun test`
+- Looking at the `*.page.tsx` files in the `site` directory via a browser

package/dist/index.js

@@ -607,7 +607,8 @@ var cartesian = (arrays) => arrays.length === 0 ? [[]] : arrays.reduce(
 );
 var generateElbowVariants = ({
   baseElbow,
-  guidelines
+  guidelines,
+  maxVariants = 1e4
 }) => {
   const elbow = preprocessElbow(baseElbow);
   assertOrthogonalPolyline(elbow);
@@ -692,6 +693,9 @@ var generateElbowVariants = ({
     if (!seen.has(key)) {
       seen.add(key);
       elbowVariants.push(variant);
+      if (elbowVariants.length >= maxVariants) {
+        break;
+      }
     }
   }
   return { elbowVariants, movableSegments };
@@ -868,7 +872,8 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
     );
     const { elbowVariants, movableSegments } = generateElbowVariants({
       baseElbow: this.baseElbow,
-      guidelines: this.guidelines
+      guidelines: this.guidelines,
+      maxVariants: 1e3
     });
     this.movableSegments = movableSegments;
     const getPathLength = (pts) => {
@@ -906,6 +911,7 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
       pinIdMap: this.pinIdMap,
       chipMap: this.chipMap
     });
+    let pathIsValid = true;
     for (let i = 0; i < nextCandidatePath.length - 1; i++) {
       const start = nextCandidatePath[i];
       const end = nextCandidatePath[i + 1];
@@ -913,12 +919,19 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
       const EPS2 = 1e-9;
       for (const [, rcl] of restrictedCenterLines) {
         if (rcl.axes.has("x") && typeof rcl.x === "number") {
-          if ((start.x - rcl.x) * (end.x - rcl.x) < -EPS2) return;
+          if ((start.x - rcl.x) * (end.x - rcl.x) < -EPS2) {
+            pathIsValid = false;
+            break;
+          }
         }
         if (rcl.axes.has("y") && typeof rcl.y === "number") {
-          if ((start.y - rcl.y) * (end.y - rcl.y) < -EPS2) return;
+          if ((start.y - rcl.y) * (end.y - rcl.y) < -EPS2) {
+            pathIsValid = false;
+            break;
+          }
         }
       }
+      if (!pathIsValid) break;
       const isStartPin = this.pins.some(
         (pin) => Math.abs(pin.x - start.x) < 1e-10 && Math.abs(pin.y - start.y) < 1e-10
       );
@@ -939,12 +952,16 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
           const onBottom = Math.abs(start.y - bounds.minY) < 1e-9;
           const onTop = Math.abs(start.y - bounds.maxY) < 1e-9;
           const entersInterior = onLeft && dx > EPS3 || onRight && dx < -EPS3 || onBottom && dy > EPS3 || onTop && dy < -EPS3;
-          if (entersInterior) return;
+          if (entersInterior) {
+            pathIsValid = false;
+            break;
+          }
           if (!excludeChipIds.includes(startPin.chipId)) {
             excludeChipIds.push(startPin.chipId);
           }
         }
       }
+      if (!pathIsValid) break;
       if (isEndPin) {
         const endPin = this.pins.find(
           (pin) => Math.abs(pin.x - end.x) < 1e-10 && Math.abs(pin.y - end.y) < 1e-10
@@ -959,21 +976,30 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
           const onBottom = Math.abs(end.y - bounds.minY) < 1e-9;
           const onTop = Math.abs(end.y - bounds.maxY) < 1e-9;
           const entersInterior = onLeft && dx > EPS3 || onRight && dx < -EPS3 || onBottom && dy > EPS3 || onTop && dy < -EPS3;
-          if (entersInterior) return;
+          if (entersInterior) {
+            pathIsValid = false;
+            break;
+          }
           if (!excludeChipIds.includes(endPin.chipId)) {
             excludeChipIds.push(endPin.chipId);
           }
         }
       }
+      if (!pathIsValid) break;
       const obstacleOps = { excludeChipIds };
       const intersects = this.chipObstacleSpatialIndex.doesOrthogonalLineIntersectChip(
         [start, end],
         obstacleOps
       );
-      if (intersects) return;
+      if (intersects) {
+        pathIsValid = false;
+        break;
+      }
+    }
+    if (pathIsValid) {
+      this.solvedTracePath = nextCandidatePath;
+      this.solved = true;
     }
-    this.solvedTracePath = nextCandidatePath;
-    this.solved = true;
   }
   visualize() {
     const graphics = visualizeInputProblem(this.inputProblem, {
@@ -1095,11 +1121,11 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
       return;
     }
     const connectionPair = this.queuedConnectionPairs.shift();
-    this.currentConnectionPair = connectionPair;
     if (!connectionPair) {
       this.solved = true;
       return;
     }
+    this.currentConnectionPair = connectionPair;
     const { pins } = connectionPair;
     this.activeSubSolver = new SchematicTraceSingleLineSolver({
       inputProblem: this.inputProblem,
@@ -1137,6 +1163,64 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/TraceOverlapShiftSolver/TraceOverlapIssueSolver/applyJogToTrace.ts
+var applyJogToTerminalSegment = ({
+  pts,
+  segmentIndex: si,
+  offset,
+  JOG_SIZE,
+  EPS: EPS2 = 1e-6
+}) => {
+  if (si !== 0 && si !== pts.length - 2) return;
+  const start = pts[si];
+  const end = pts[si + 1];
+  const isVertical = Math.abs(start.x - end.x) < EPS2;
+  const isHorizontal = Math.abs(start.y - end.y) < EPS2;
+  if (!isVertical && !isHorizontal) return;
+  const segDir = isVertical ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
+  if (si === 0) {
+    if (isVertical) {
+      const jogY = start.y + segDir * JOG_SIZE;
+      pts.splice(
+        1,
+        1,
+        { x: start.x, y: jogY },
+        { x: start.x + offset, y: jogY },
+        { x: end.x + offset, y: end.y }
+      );
+    } else {
+      const jogX = start.x + segDir * JOG_SIZE;
+      pts.splice(
+        1,
+        1,
+        { x: jogX, y: start.y },
+        { x: jogX, y: start.y + offset },
+        { x: end.x, y: end.y + offset }
+      );
+    }
+  } else {
+    if (isVertical) {
+      const jogY = end.y - segDir * JOG_SIZE;
+      pts.splice(
+        si,
+        1,
+        { x: start.x + offset, y: start.y },
+        { x: end.x + offset, y: jogY },
+        { x: end.x, y: jogY }
+      );
+    } else {
+      const jogX = end.x - segDir * JOG_SIZE;
+      pts.splice(
+        si,
+        1,
+        { x: start.x, y: start.y + offset },
+        { x: jogX, y: end.y + offset },
+        { x: jogX, y: end.y }
+      );
+    }
+  }
+};
+
 // lib/solvers/TraceOverlapShiftSolver/TraceOverlapIssueSolver/TraceOverlapIssueSolver.ts
 var TraceOverlapIssueSolver = class extends BaseSolver {
   overlappingTraceSegments;
@@ -1180,33 +1264,30 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
         const current = this.correctedTraceMap[original.mspPairId] ?? original;
         const pts = current.tracePath.map((p) => ({ ...p }));
         const segIdxs = Array.from(segIdxSet).sort((a, b) => a - b);
-        const appliedX = /* @__PURE__ */ new Set();
-        const appliedY = /* @__PURE__ */ new Set();
-        for (const si of segIdxs) {
+        const segIdxsRev = Array.from(segIdxSet).sort((a, b) => a - b).reverse();
+        const JOG_SIZE = this.SHIFT_DISTANCE;
+        for (const si of segIdxsRev) {
           if (si < 0 || si >= pts.length - 1) continue;
-          if (si === 0 || si === pts.length - 2) continue;
-          const start = pts[si];
-          const end = pts[si + 1];
-          const isVertical = Math.abs(start.x - end.x) < EPS2;
-          const isHorizontal = Math.abs(start.y - end.y) < EPS2;
-          if (!isVertical && !isHorizontal) continue;
-          if (isVertical) {
-            if (!appliedX.has(si)) {
+          if (si === 0 || si === pts.length - 2) {
+            applyJogToTerminalSegment({
+              pts,
+              segmentIndex: si,
+              offset,
+              JOG_SIZE,
+              EPS: EPS2
+            });
+          } else {
+            const start = pts[si];
+            const end = pts[si + 1];
+            const isVertical = Math.abs(start.x - end.x) < EPS2;
+            const isHorizontal = Math.abs(start.y - end.y) < EPS2;
+            if (!isVertical && !isHorizontal) continue;
+            if (isVertical) {
               start.x += offset;
-              appliedX.add(si);
-            }
-            if (!appliedX.has(si + 1)) {
               end.x += offset;
-              appliedX.add(si + 1);
-            }
-          } else if (isHorizontal) {
-            if (!appliedY.has(si)) {
+            } else {
               start.y += offset;
-              appliedY.add(si);
-            }
-            if (!appliedY.has(si + 1)) {
               end.y += offset;
-              appliedY.add(si + 1);
             }
           }
         }
@@ -1295,7 +1376,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS2 = 1e-6;
+    const EPS2 = 2e-3;
     const netIds = Object.keys(this.traceNetIslands);
     for (let i = 0; i < netIds.length; i++) {
       for (let j = i + 1; j < netIds.length; j++) {

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver.ts

@@ -101,13 +101,14 @@ export class SchematicTraceLinesSolver extends BaseSolver {
     }
 
     const connectionPair = this.queuedConnectionPairs.shift()
-    this.currentConnectionPair = connectionPair!
 
     if (!connectionPair) {
       this.solved = true
       return
     }
 
+    this.currentConnectionPair = connectionPair
+
     const { pins } = connectionPair
 
     this.activeSubSolver = new SchematicTraceSingleLineSolver({

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver.ts

@@ -97,6 +97,7 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
     const { elbowVariants, movableSegments } = generateElbowVariants({
       baseElbow: this.baseElbow,
       guidelines: this.guidelines,
+      maxVariants: 1000,
     })
 
     this.movableSegments = movableSegments
@@ -144,6 +145,9 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
       chipMap: this.chipMap,
     })
 
+    // Check if this candidate path is valid
+    let pathIsValid = true
+
     for (let i = 0; i < nextCandidatePath.length - 1; i++) {
       const start = nextCandidatePath[i]
       const end = nextCandidatePath[i + 1]
@@ -156,14 +160,22 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
       for (const [, rcl] of restrictedCenterLines) {
         if (rcl.axes.has("x") && typeof rcl.x === "number") {
           // segment strictly crosses vertical center line
-          if ((start.x - rcl.x) * (end.x - rcl.x) < -EPS) return
+          if ((start.x - rcl.x) * (end.x - rcl.x) < -EPS) {
+            pathIsValid = false
+            break
+          }
         }
         if (rcl.axes.has("y") && typeof rcl.y === "number") {
           // segment strictly crosses horizontal center line
-          if ((start.y - rcl.y) * (end.y - rcl.y) < -EPS) return
+          if ((start.y - rcl.y) * (end.y - rcl.y) < -EPS) {
+            pathIsValid = false
+            break
+          }
         }
       }
 
+      if (!pathIsValid) break
+
       // Always exclude chips that contain the start or end points of this segment
       // if those points are actually pin locations
       const isStartPin = this.pins.some(
@@ -197,13 +209,18 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
             (onRight && dx < -EPS) ||
             (onBottom && dy > EPS) ||
             (onTop && dy < -EPS)
-          if (entersInterior) return
+          if (entersInterior) {
+            pathIsValid = false
+            break
+          }
           if (!excludeChipIds.includes(startPin.chipId)) {
             excludeChipIds.push(startPin.chipId)
           }
         }
       }
 
+      if (!pathIsValid) break
+
       if (isEndPin) {
         const endPin = this.pins.find(
           (pin) =>
@@ -224,24 +241,37 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
             (onRight && dx < -EPS) ||
             (onBottom && dy > EPS) ||
             (onTop && dy < -EPS)
-          if (entersInterior) return
+          if (entersInterior) {
+            pathIsValid = false
+            break
+          }
           if (!excludeChipIds.includes(endPin.chipId)) {
             excludeChipIds.push(endPin.chipId)
           }
         }
       }
 
+      if (!pathIsValid) break
+
       const obstacleOps = { excludeChipIds }
       const intersects =
         this.chipObstacleSpatialIndex.doesOrthogonalLineIntersectChip(
           [start, end],
           obstacleOps,
         )
-      if (intersects) return
+      if (intersects) {
+        pathIsValid = false
+        break
+      }
     }
 
-    this.solvedTracePath = nextCandidatePath
-    this.solved = true
+    // If this path is valid, use it as the solution
+    if (pathIsValid) {
+      this.solvedTracePath = nextCandidatePath
+      this.solved = true
+    }
+    // If this path is invalid, continue to next step to try the next candidate
+    // The next _step() call will try the next candidate path
   }
 
   override visualize(): GraphicsObject {

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/generateElbowVariants.ts

@@ -260,9 +260,11 @@ const cartesian = <T>(arrays: T[][]): T[][] =>
 export const generateElbowVariants = ({
   baseElbow,
   guidelines,
+  maxVariants = 10000,
 }: {
   baseElbow: Point[]
   guidelines: Guideline[]
+  maxVariants?: number
 }): {
   elbowVariants: Array<Point[]>
   movableSegments: Array<MovableSegment>
@@ -395,6 +397,11 @@ export const generateElbowVariants = ({
     if (!seen.has(key)) {
       seen.add(key)
       elbowVariants.push(variant)
+
+      // Stop if we've hit the maximum number of variants
+      if (elbowVariants.length >= maxVariants) {
+        break
+      }
     }
   }
 

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapIssueSolver/TraceOverlapIssueSolver.ts

@@ -2,6 +2,7 @@ import type { GraphicsObject } from "graphics-debug"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { applyJogToTerminalSegment } from "./applyJogToTrace"
 
 type ConnNetId = string
 
@@ -83,38 +84,39 @@ export class TraceOverlapIssueSolver extends BaseSolver {
 
         const segIdxs = Array.from(segIdxSet).sort((a, b) => a - b)
 
-        // Track per-point adjustments to avoid double-shifting shared joints
-        const appliedX = new Set<number>()
-        const appliedY = new Set<number>()
+        const segIdxsRev = Array.from(segIdxSet)
+          .sort((a, b) => a - b)
+          .reverse()
 
-        for (const si of segIdxs) {
-          if (si < 0 || si >= pts.length - 1) continue
-          // Do not move the first or last segment since they connect directly to pins
-          if (si === 0 || si === pts.length - 2) continue
-          const start = pts[si]!
-          const end = pts[si + 1]!
-          const isVertical = Math.abs(start.x - end.x) < EPS
-          const isHorizontal = Math.abs(start.y - end.y) < EPS
+        const JOG_SIZE = this.SHIFT_DISTANCE
 
-          if (!isVertical && !isHorizontal) continue
+        // Process from end to start to keep indices valid after splicing
+        for (const si of segIdxsRev) {
+          if (si < 0 || si >= pts.length - 1) continue
 
-          if (isVertical) {
-            if (!appliedX.has(si)) {
+          if (si === 0 || si === pts.length - 2) {
+            applyJogToTerminalSegment({
+              pts,
+              segmentIndex: si,
+              offset,
+              JOG_SIZE,
+              EPS,
+            })
+          } else {
+            // Internal segment - shift both points
+            const start = pts[si]!
+            const end = pts[si + 1]!
+            const isVertical = Math.abs(start.x - end.x) < EPS
+            const isHorizontal = Math.abs(start.y - end.y) < EPS
+            if (!isVertical && !isHorizontal) continue
+
+            if (isVertical) {
               start.x += offset
-              appliedX.add(si)
-            }
-            if (!appliedX.has(si + 1)) {
               end.x += offset
-              appliedX.add(si + 1)
-            }
-          } else if (isHorizontal) {
-            if (!appliedY.has(si)) {
+            } else {
+              // Horizontal
               start.y += offset
-              appliedY.add(si)
-            }
-            if (!appliedY.has(si + 1)) {
               end.y += offset
-              appliedY.add(si + 1)
             }
           }
         }

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapIssueSolver/applyJogToTrace.ts

@@ -0,0 +1,76 @@
+import type { Point } from "@tscircuit/math-utils"
+
+export const applyJogToTerminalSegment = ({
+  pts,
+  segmentIndex: si,
+  offset,
+  JOG_SIZE,
+  EPS = 1e-6,
+}: {
+  pts: Point[]
+  segmentIndex: number
+  offset: number
+  JOG_SIZE: number
+  EPS?: number
+}) => {
+  if (si !== 0 && si !== pts.length - 2) return
+
+  const start = pts[si]!
+  const end = pts[si + 1]!
+  const isVertical = Math.abs(start.x - end.x) < EPS
+  const isHorizontal = Math.abs(start.y - end.y) < EPS
+  if (!isVertical && !isHorizontal) return
+
+  const segDir = isVertical
+    ? end.y > start.y
+      ? 1
+      : -1
+    : end.x > start.x
+      ? 1
+      : -1
+
+  if (si === 0) {
+    if (isVertical) {
+      const jogY = start.y + segDir * JOG_SIZE
+      pts.splice(
+        1,
+        1,
+        { x: start.x, y: jogY },
+        { x: start.x + offset, y: jogY },
+        { x: end.x + offset, y: end.y },
+      )
+    } else {
+      // Horizontal
+      const jogX = start.x + segDir * JOG_SIZE
+      pts.splice(
+        1,
+        1,
+        { x: jogX, y: start.y },
+        { x: jogX, y: start.y + offset },
+        { x: end.x, y: end.y + offset },
+      )
+    }
+  } else {
+    // si === pts.length - 2
+    if (isVertical) {
+      const jogY = end.y - segDir * JOG_SIZE
+      pts.splice(
+        si,
+        1,
+        { x: start.x + offset, y: start.y },
+        { x: end.x + offset, y: jogY },
+        { x: end.x, y: jogY },
+      )
+    } else {
+      // Horizontal
+      const jogX = end.x - segDir * JOG_SIZE
+      pts.splice(
+        si,
+        1,
+        { x: start.x, y: start.y + offset },
+        { x: jogX, y: end.y + offset },
+        { x: jogX, y: end.y },
+      )
+    }
+  }
+}

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapShiftSolver.ts

@@ -89,7 +89,7 @@ export class TraceOverlapShiftSolver extends BaseSolver {
     overlappingTraceSegments: Array<OverlappingTraceSegmentLocator>
   } | null {
     // Detect the next set of overlapping segments between two different net islands.
-    const EPS = 1e-6
+    const EPS = 2e-3
 
     const netIds = Object.keys(this.traceNetIslands)
     // Compare each pair of different nets

package/package.json

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