@tscircuit/schematic-trace-solver 0.0.8 → 0.0.10

package/README.md

@@ -4,6 +4,8 @@ Solve for the correct positions and routing for schematic traces and net labels.
 
 [Online Playground](https://schematic-trace-solver.vercel.app) ・ [tscircuit](https://github.com/tscircuit/tscircuit) ・ [@tscircuit/core](https://github.com/tscircuit/core)
 
+<img width="1740" height="896" alt="image" src="https://github.com/user-attachments/assets/53032b97-d7b5-4a00-9eab-58b58e3adecc" />
+
 ## Overview
 
 The Schematic Trace Solver is a pipeline that figures out how to route schematic traces

package/dist/index.d.ts

@@ -191,6 +191,9 @@ declare class SchematicTraceLinesSolver extends BaseSolver {
     chipMap: Record<string, InputChip>;
     currentConnectionPair: MspConnectionPair | null;
     solvedTracePaths: Array<SolvedTracePath>;
+    failedConnectionPairs: Array<MspConnectionPair & {
+        error?: string;
+    }>;
     activeSubSolver: SchematicTraceSingleLineSolver | null;
     constructor(params: {
         mspConnectionPairs: MspConnectionPair[];
@@ -370,6 +373,8 @@ declare class NetLabelPlacementSolver extends BaseSolver {
     queuedOverlappingSameNetTraceGroups: Array<OverlappingSameNetTraceGroup>;
     activeSubSolver: SingleNetLabelPlacementSolver | null;
     netLabelPlacements: Array<NetLabelPlacement>;
+    currentGroup: OverlappingSameNetTraceGroup | null;
+    triedAnyOrientationFallbackForCurrentGroup: boolean;
     constructor(params: {
         inputProblem: InputProblem;
         inputTraceMap: Record<MspConnectionPairId, SolvedTracePath>;

package/dist/index.js

@@ -6694,12 +6694,33 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
       return;
     }
     const nextCandidatePath = this.queuedCandidatePaths.shift();
-    const obstacleOps = {
-      excludeChipIds: [this.pins[0].chipId, this.pins[1].chipId]
-    };
     for (let i = 0; i < nextCandidatePath.length - 1; i++) {
       const start = nextCandidatePath[i];
       const end = nextCandidatePath[i + 1];
+      let excludeChipIds = [];
+      const isStartPin = this.pins.some(
+        (pin) => Math.abs(pin.x - start.x) < 1e-10 && Math.abs(pin.y - start.y) < 1e-10
+      );
+      const isEndPin = this.pins.some(
+        (pin) => Math.abs(pin.x - end.x) < 1e-10 && Math.abs(pin.y - end.y) < 1e-10
+      );
+      if (isStartPin) {
+        const startPin = this.pins.find(
+          (pin) => Math.abs(pin.x - start.x) < 1e-10 && Math.abs(pin.y - start.y) < 1e-10
+        );
+        if (startPin && !excludeChipIds.includes(startPin.chipId)) {
+          excludeChipIds.push(startPin.chipId);
+        }
+      }
+      if (isEndPin) {
+        const endPin = this.pins.find(
+          (pin) => Math.abs(pin.x - end.x) < 1e-10 && Math.abs(pin.y - end.y) < 1e-10
+        );
+        if (endPin && !excludeChipIds.includes(endPin.chipId)) {
+          excludeChipIds.push(endPin.chipId);
+        }
+      }
+      const obstacleOps = { excludeChipIds };
       const intersects = this.chipObstacleSpatialIndex.doesOrthogonalLineIntersectChip(
         [start, end],
         obstacleOps
@@ -6780,6 +6801,7 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
   chipMap;
   currentConnectionPair = null;
   solvedTracePaths = [];
+  failedConnectionPairs = [];
   constructor(params) {
     super();
     this.inputProblem = params.inputProblem;
@@ -6810,9 +6832,14 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
       this.currentConnectionPair = null;
     }
     if (this.activeSubSolver?.failed) {
-      this.failed = true;
-      this.error = this.activeSubSolver.error;
-      return;
+      if (this.currentConnectionPair) {
+        this.failedConnectionPairs.push({
+          ...this.currentConnectionPair,
+          error: this.activeSubSolver.error || void 0
+        });
+      }
+      this.activeSubSolver = null;
+      this.currentConnectionPair = null;
     }
     if (this.activeSubSolver) {
       this.activeSubSolver.step();
@@ -6848,6 +6875,17 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
         strokeColor: "green"
       });
     }
+    for (const pair of this.failedConnectionPairs) {
+      graphics.lines.push({
+        points: [
+          { x: pair.pins[0].x, y: pair.pins[0].y },
+          { x: pair.pins[1].x, y: pair.pins[1].y }
+        ],
+        strokeColor: "red",
+        strokeDash: "4 2",
+        strokeWidth: 4e-3
+      });
+    }
     return graphics;
   }
 };
@@ -7642,6 +7680,8 @@ var NetLabelPlacementSolver = class extends BaseSolver {
   overlappingSameNetTraceGroups;
   queuedOverlappingSameNetTraceGroups;
   netLabelPlacements = [];
+  currentGroup = null;
+  triedAnyOrientationFallbackForCurrentGroup = false;
   constructor(params) {
     super();
     this.inputProblem = params.inputProblem;
@@ -7759,9 +7799,24 @@ var NetLabelPlacementSolver = class extends BaseSolver {
     if (this.activeSubSolver?.solved) {
       this.netLabelPlacements.push(this.activeSubSolver.netLabelPlacement);
       this.activeSubSolver = null;
+      this.currentGroup = null;
+      this.triedAnyOrientationFallbackForCurrentGroup = false;
       return;
     }
     if (this.activeSubSolver?.failed) {
+      const fullOrients = ["x+", "x-", "y+", "y-"];
+      const currOrients = this.activeSubSolver.availableOrientations;
+      const isAlreadyFull = currOrients.length === 4 && fullOrients.every((o) => currOrients.includes(o));
+      if (!this.triedAnyOrientationFallbackForCurrentGroup && !isAlreadyFull && this.currentGroup) {
+        this.triedAnyOrientationFallbackForCurrentGroup = true;
+        this.activeSubSolver = new SingleNetLabelPlacementSolver({
+          inputProblem: this.inputProblem,
+          inputTraceMap: this.inputTraceMap,
+          overlappingSameNetTraceGroup: this.currentGroup,
+          availableOrientations: fullOrients
+        });
+        return;
+      }
       this.failed = true;
       this.error = this.activeSubSolver.error;
       return;
@@ -7776,6 +7831,8 @@ var NetLabelPlacementSolver = class extends BaseSolver {
       return;
     }
     const netId = nextOverlappingSameNetTraceGroup.netId ?? nextOverlappingSameNetTraceGroup.globalConnNetId;
+    this.currentGroup = nextOverlappingSameNetTraceGroup;
+    this.triedAnyOrientationFallbackForCurrentGroup = false;
     this.activeSubSolver = new SingleNetLabelPlacementSolver({
       inputProblem: this.inputProblem,
       inputTraceMap: this.inputTraceMap,

package/lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver.ts

@@ -60,6 +60,8 @@ export class NetLabelPlacementSolver extends BaseSolver {
   declare activeSubSolver: SingleNetLabelPlacementSolver | null
 
   netLabelPlacements: Array<NetLabelPlacement> = []
+  currentGroup: OverlappingSameNetTraceGroup | null = null
+  triedAnyOrientationFallbackForCurrentGroup = false
 
   constructor(params: {
     inputProblem: InputProblem
@@ -209,10 +211,34 @@ export class NetLabelPlacementSolver extends BaseSolver {
     if (this.activeSubSolver?.solved) {
       this.netLabelPlacements.push(this.activeSubSolver.netLabelPlacement!)
       this.activeSubSolver = null
+      this.currentGroup = null
+      this.triedAnyOrientationFallbackForCurrentGroup = false
       return
     }
 
     if (this.activeSubSolver?.failed) {
+      // Retry once with all orientations as a fallback before failing
+      const fullOrients: FacingDirection[] = ["x+", "x-", "y+", "y-"]
+      const currOrients = this.activeSubSolver.availableOrientations
+      const isAlreadyFull =
+        currOrients.length === 4 &&
+        fullOrients.every((o) => currOrients.includes(o))
+
+      if (
+        !this.triedAnyOrientationFallbackForCurrentGroup &&
+        !isAlreadyFull &&
+        this.currentGroup
+      ) {
+        this.triedAnyOrientationFallbackForCurrentGroup = true
+        this.activeSubSolver = new SingleNetLabelPlacementSolver({
+          inputProblem: this.inputProblem,
+          inputTraceMap: this.inputTraceMap,
+          overlappingSameNetTraceGroup: this.currentGroup,
+          availableOrientations: fullOrients,
+        })
+        return
+      }
+
       this.failed = true
       this.error = this.activeSubSolver.error
       return
@@ -235,6 +261,9 @@ export class NetLabelPlacementSolver extends BaseSolver {
       nextOverlappingSameNetTraceGroup.netId ??
       nextOverlappingSameNetTraceGroup.globalConnNetId
 
+    this.currentGroup = nextOverlappingSameNetTraceGroup
+    this.triedAnyOrientationFallbackForCurrentGroup = false
+
     this.activeSubSolver = new SingleNetLabelPlacementSolver({
       inputProblem: this.inputProblem,
       inputTraceMap: this.inputTraceMap,

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver.ts

@@ -30,6 +30,7 @@ export class SchematicTraceLinesSolver extends BaseSolver {
   currentConnectionPair: MspConnectionPair | null = null
 
   solvedTracePaths: Array<SolvedTracePath> = []
+  failedConnectionPairs: Array<MspConnectionPair & { error?: string }> = []
 
   declare activeSubSolver: SchematicTraceSingleLineSolver | null
 
@@ -75,9 +76,16 @@ export class SchematicTraceLinesSolver extends BaseSolver {
       this.currentConnectionPair = null
     }
     if (this.activeSubSolver?.failed) {
-      this.failed = true
-      this.error = this.activeSubSolver.error
-      return
+      // Record the failure for this connection and continue to the next pair
+      if (this.currentConnectionPair) {
+        this.failedConnectionPairs.push({
+          ...this.currentConnectionPair,
+          error: this.activeSubSolver.error || undefined,
+        })
+      }
+      this.activeSubSolver = null
+      this.currentConnectionPair = null
+      // Do not fail the whole solver; proceed to schedule the next pair
     }
 
     if (this.activeSubSolver) {
@@ -122,6 +130,19 @@ export class SchematicTraceLinesSolver extends BaseSolver {
       })
     }
 
+    // Indicate failed connection pairs with dashed red lines between their pins
+    for (const pair of this.failedConnectionPairs) {
+      graphics.lines!.push({
+        points: [
+          { x: pair.pins[0].x, y: pair.pins[0].y },
+          { x: pair.pins[1].x, y: pair.pins[1].y },
+        ],
+        strokeColor: "red",
+        strokeDash: "4 2",
+        strokeWidth: 0.004,
+      })
+    }
+
     return graphics
   }
 }

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

@@ -103,12 +103,47 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
 
     const nextCandidatePath = this.queuedCandidatePaths.shift()!
 
-    const obstacleOps = {
-      excludeChipIds: [this.pins[0].chipId, this.pins[1].chipId],
-    }
     for (let i = 0; i < nextCandidatePath.length - 1; i++) {
       const start = nextCandidatePath[i]
       const end = nextCandidatePath[i + 1]
+
+      // Determine which chips to exclude for this specific segment
+      let excludeChipIds: string[] = []
+
+      // 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(
+        (pin) =>
+          Math.abs(pin.x - start.x) < 1e-10 &&
+          Math.abs(pin.y - start.y) < 1e-10,
+      )
+      const isEndPin = this.pins.some(
+        (pin) =>
+          Math.abs(pin.x - end.x) < 1e-10 && Math.abs(pin.y - end.y) < 1e-10,
+      )
+
+      if (isStartPin) {
+        const startPin = this.pins.find(
+          (pin) =>
+            Math.abs(pin.x - start.x) < 1e-10 &&
+            Math.abs(pin.y - start.y) < 1e-10,
+        )
+        if (startPin && !excludeChipIds.includes(startPin.chipId)) {
+          excludeChipIds.push(startPin.chipId)
+        }
+      }
+
+      if (isEndPin) {
+        const endPin = this.pins.find(
+          (pin) =>
+            Math.abs(pin.x - end.x) < 1e-10 && Math.abs(pin.y - end.y) < 1e-10,
+        )
+        if (endPin && !excludeChipIds.includes(endPin.chipId)) {
+          excludeChipIds.push(endPin.chipId)
+        }
+      }
+
+      const obstacleOps = { excludeChipIds }
       const intersects =
         this.chipObstacleSpatialIndex.doesOrthogonalLineIntersectChip(
           [start, end],

package/package.json

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

package/site/SchematicTraceLinesSolver/SchematicTraceLinesSolver01.page.tsx

@@ -0,0 +1,122 @@
+import { useMemo } from "react"
+import { GenericSolverDebugger } from "../components/GenericSolverDebugger"
+import { SchematicTraceLinesSolver } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+
+const input = {
+  mspConnectionPairs: [
+    {
+      mspPairId: "Q1.1-Q1.2",
+      dcConnNetId: "connectivity_net0",
+      globalConnNetId: "connectivity_net0",
+      userNetId: "V3_3",
+      pins: [
+        {
+          pinId: "Q1.1",
+          x: 0.30397715550000004,
+          y: 0.5800832909999993,
+          _facingDirection: "y+",
+          chipId: "schematic_component_0",
+        },
+        {
+          pinId: "Q1.2",
+          x: 0.31067575550000137,
+          y: -0.5800832909999993,
+          _facingDirection: "y-",
+          chipId: "schematic_component_0",
+        },
+      ],
+    },
+  ],
+  dcConnMap: {
+    netMap: {
+      connectivity_net0: ["Q1.1", "Q1.2"],
+    },
+    idToNetMap: {},
+  },
+  globalConnMap: {
+    netMap: {
+      connectivity_net0: ["Q1.1", "Q1.2"],
+    },
+    idToNetMap: {
+      "Q1.1": "connectivity_net0",
+      "Q1.2": "connectivity_net0",
+    },
+  },
+  inputProblem: {
+    chips: [
+      {
+        chipId: "schematic_component_0",
+        center: {
+          x: 0,
+          y: 0,
+        },
+        width: 0.8935117710000002,
+        height: 1.1601665819999987,
+        pins: [
+          {
+            pinId: "Q1.1",
+            x: 0.30397715550000004,
+            y: 0.5800832909999993,
+          },
+          {
+            pinId: "Q1.2",
+            x: 0.31067575550000137,
+            y: -0.5800832909999993,
+          },
+          {
+            pinId: "Q1.3",
+            x: -0.4467558855000001,
+            y: -0.10250625000000019,
+          },
+        ],
+      },
+    ],
+    directConnections: [],
+    netConnections: [
+      {
+        netId: "V3_3",
+        pinIds: ["Q1.1", "Q1.2"],
+      },
+    ],
+    availableNetLabelOrientations: {
+      V3_3: ["y+"],
+    },
+    maxMspPairDistance: 2,
+  },
+  guidelines: [],
+  chipMap: {
+    schematic_component_0: {
+      chipId: "schematic_component_0",
+      center: {
+        x: 0,
+        y: 0,
+      },
+      width: 0.8935117710000002,
+      height: 1.1601665819999987,
+      pins: [
+        {
+          pinId: "Q1.1",
+          x: 0.30397715550000004,
+          y: 0.5800832909999993,
+        },
+        {
+          pinId: "Q1.2",
+          x: 0.31067575550000137,
+          y: -0.5800832909999993,
+        },
+        {
+          pinId: "Q1.3",
+          x: -0.4467558855000001,
+          y: -0.10250625000000019,
+        },
+      ],
+    },
+  },
+}
+
+export default () => {
+  const solver = useMemo(() => {
+    return new SchematicTraceLinesSolver(input as any)
+  }, [])
+  return <GenericSolverDebugger solver={solver} />
+}

package/site/components/GenericSolverDebugger.tsx

@@ -0,0 +1,16 @@
+import type { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import { useMemo, useReducer } from "react"
+import { InteractiveGraphics } from "graphics-debug/react"
+import { SolverToolbar } from "./SolverToolbar"
+
+export const GenericSolverDebugger = ({ solver }: { solver: BaseSolver }) => {
+  const [, incRenderCount] = useReducer((x) => x + 1, 0)
+
+  return (
+    <div>
+      <SolverToolbar triggerRender={() => incRenderCount()} solver={solver} />
+      <InteractiveGraphics graphics={solver.visualize()} />
+    </div>
+  )
+}

package/site/examples/example04-single-symbol.page.tsx

@@ -0,0 +1,46 @@
+import { PipelineDebugger } from "../components/PipelineDebugger"
+import type { InputProblem } from "lib/types/InputProblem"
+
+const inputProblem: InputProblem = {
+  chips: [
+    {
+      chipId: "schematic_component_0",
+      center: {
+        x: 0,
+        y: 0,
+      },
+      width: 0.8935117710000002,
+      height: 1.1601665819999987,
+      pins: [
+        {
+          pinId: "Q1.1",
+          x: 0.30397715550000004,
+          y: 0.5519248499999994,
+        },
+        {
+          pinId: "Q1.2",
+          x: 0.31067575550000137,
+          y: -0.5519248499999994,
+        },
+        {
+          pinId: "Q1.3",
+          x: -0.41859744450000014,
+          y: -0.10250625000000019,
+        },
+      ],
+    },
+  ],
+  directConnections: [],
+  netConnections: [
+    {
+      netId: "V3_3",
+      pinIds: ["Q1.1", "Q1.2"],
+    },
+  ],
+  availableNetLabelOrientations: {
+    V3_3: ["y+"],
+  },
+  maxMspPairDistance: 2,
+}
+
+export default () => <PipelineDebugger inputProblem={inputProblem} />

package/tests/solvers/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver_repro01.json

@@ -0,0 +1,88 @@
+{
+  "chipMap": {
+    "schematic_component_0": {
+      "chipId": "schematic_component_0",
+      "center": {
+        "x": 0,
+        "y": 0
+      },
+      "width": 0.8935117710000002,
+      "height": 1.1601665819999987,
+      "pins": [
+        {
+          "pinId": "Q1.1",
+          "x": 0.30397715550000004,
+          "y": 0.5800832909999993
+        },
+        {
+          "pinId": "Q1.2",
+          "x": 0.31067575550000137,
+          "y": -0.5800832909999993
+        },
+        {
+          "pinId": "Q1.3",
+          "x": -0.4467558855000001,
+          "y": -0.10250625000000019
+        }
+      ]
+    }
+  },
+  "pins": [
+    {
+      "pinId": "Q1.1",
+      "x": 0.30397715550000004,
+      "y": 0.5800832909999993,
+      "_facingDirection": "y+",
+      "chipId": "schematic_component_0"
+    },
+    {
+      "pinId": "Q1.2",
+      "x": 0.31067575550000137,
+      "y": -0.5800832909999993,
+      "_facingDirection": "y-",
+      "chipId": "schematic_component_0"
+    }
+  ],
+  "guidelines": [],
+  "inputProblem": {
+    "chips": [
+      {
+        "chipId": "schematic_component_0",
+        "center": {
+          "x": 0,
+          "y": 0
+        },
+        "width": 0.8935117710000002,
+        "height": 1.1601665819999987,
+        "pins": [
+          {
+            "pinId": "Q1.1",
+            "x": 0.30397715550000004,
+            "y": 0.5800832909999993
+          },
+          {
+            "pinId": "Q1.2",
+            "x": 0.31067575550000137,
+            "y": -0.5800832909999993
+          },
+          {
+            "pinId": "Q1.3",
+            "x": -0.4467558855000001,
+            "y": -0.10250625000000019
+          }
+        ]
+      }
+    ],
+    "directConnections": [],
+    "netConnections": [
+      {
+        "netId": "V3_3",
+        "pinIds": ["Q1.1", "Q1.2"]
+      }
+    ],
+    "availableNetLabelOrientations": {
+      "V3_3": ["y+"]
+    },
+    "maxMspPairDistance": 2
+  }
+}

package/tests/solvers/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver_repro01.test.ts

@@ -0,0 +1,16 @@
+import { test, expect } from "bun:test"
+import input from "./SchematicTraceSingleLineSolver_repro01.json"
+import { SchematicTraceSingleLineSolver } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver"
+
+test("SchematicTraceSingleLineSolver_repro01", () => {
+  const solver = new SchematicTraceSingleLineSolver(input as any)
+  solver.solve()
+
+  // The solver should fail because it cannot find a path around the chip
+  // without guidelines to help navigate around it
+  expect(solver.failed).toBe(true)
+  expect(solver.error).toBe(
+    "No more candidate elbows, everything had collisions",
+  )
+  expect(solver.solvedTracePath).toBe(null)
+})