@tscircuit/schematic-trace-solver 0.0.107 → 0.0.109

package/tests/repros/repro-netlabel-collision-687.test.ts

@@ -0,0 +1,59 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import inputProblem from "./assets/repro-netlabel-collision-687.input.json"
+import "tests/fixtures/matcher"
+
+const boundsOf = (label: {
+  center: { x: number; y: number }
+  width: number
+  height: number
+}) => ({
+  minX: label.center.x - label.width / 2,
+  maxX: label.center.x + label.width / 2,
+  minY: label.center.y - label.height / 2,
+  maxY: label.center.y + label.height / 2,
+})
+
+const overlapArea = (
+  a: ReturnType<typeof boundsOf>,
+  b: ReturnType<typeof boundsOf>,
+) => {
+  const w = Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX)
+  const h = Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY)
+  return w > 0 && h > 0 ? w * h : 0
+}
+
+// Reproduction for #687, minimized from bug-report-20260721T221026Z.
+//
+// U1's right-edge pin column is fully walled in: a solid column of port
+// labels (QD0..QD3, QCLK) to the east, chips C1/C2 above and below, and
+// chip U3 closing off the corridor. The V1V1 trace (U1.1 -> U1.7) wraps
+// around the label column, and its net label has NO strictly collision-free
+// candidate anywhere along the trace. NetLabelNetLabelCollisionSolver gives
+// up and leaves the V1V1 label stacked directly on top of the QD3 and QCLK
+// port labels — the same pile-up as the original board.
+//
+// This test asserts the CURRENT (buggy) behavior so the bug is pinned by CI.
+// A fix should flip the two non-zero overlap assertions to .toBe(0).
+test("repro #687: V1V1 net label left stacked on QD3/QCLK port labels", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem as any)
+  solver.solve()
+
+  const labels =
+    solver.netLabelNetLabelCollisionSolver!.outputNetLabelPlacements
+
+  const v1v1 = labels.find((l) => l.netId === "V1V1")!
+  const qd3 = labels.find((l) => l.netId === "QD3" && l.center.x < 3)!
+  const qclk = labels.find((l) => l.netId === "QCLK" && l.center.x < 3)!
+  expect(v1v1).toBeDefined()
+  expect(qd3).toBeDefined()
+  expect(qclk).toBeDefined()
+
+  // BUG: the V1V1 label still overlaps both port labels after the collision
+  // solver has run (total stacked overlap ≈ 0.16)
+  expect(overlapArea(boundsOf(v1v1), boundsOf(qd3))).toBeGreaterThan(0)
+  expect(overlapArea(boundsOf(v1v1), boundsOf(qclk))).toBeGreaterThan(0)
+
+  // visual snapshot: the V1V1 label sits on the QD3/QCLK pile-up
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/repros/repro-tps61222-trace-intersection.test.ts

@@ -1,5 +1,7 @@
 import { expect, test } from "bun:test"
+import { isPathCollidingWithObstacles } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import { getTextBoxBounds } from "lib/utils/textBoxBounds"
 import "tests/fixtures/matcher"
 import inputProblem from "./assets/repro-tps61222-trace-intersection.input.json"
 
@@ -8,7 +10,32 @@ import inputProblem from "./assets/repro-tps61222-trace-intersection.input.json"
 test("repro TPS61222 schematic trace intersection", () => {
   const solver = new SchematicTracePipelineSolver(inputProblem as any)
 
+  const manufacturerPartNumberTextBox = inputProblem.textBoxes.find(
+    (textBox) => textBox.text === "TPS61222DCKT",
+  )
+  expect(manufacturerPartNumberTextBox).toBeDefined()
+
+  const textBounds = getTextBoxBounds(manufacturerPartNumberTextBox!)
+  solver.solveUntilPhase("longDistancePairSolver")
+
+  const initialGroundTrace =
+    solver.schematicTraceLinesSolver!.solvedTracePaths.find(
+      (trace) => trace.mspPairId === "U2.3-C25.2",
+    )
+  expect(initialGroundTrace).toBeDefined()
+  expect(
+    isPathCollidingWithObstacles(initialGroundTrace!.tracePath, [textBounds]),
+  ).toBe(false)
+
   solver.solve()
 
+  const crossingTraceIds = solver
+    .netLabelTraceCollisionSolver!.getOutput()
+    .traces.filter((trace) =>
+      isPathCollidingWithObstacles(trace.tracePath, [textBounds]),
+    )
+    .map((trace) => trace.mspPairId)
+
+  expect(crossingTraceIds).toEqual([])
   expect(solver).toMatchSolverSnapshot(import.meta.path)
 })

package/tests/solvers/SchematicTraceSingleLineSolver2/generate-internal-segment-collision-detours.test.ts

@@ -0,0 +1,49 @@
+import { expect, test } from "bun:test"
+import { isPathCollidingWithObstacles } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { generateInternalSegmentCollisionDetours } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/generateInternalSegmentCollisionDetours"
+
+test("internal segment detours preserve endpoint legs and clear the obstacle", () => {
+  const path = [
+    { x: 0, y: 0 },
+    { x: 1, y: 0 },
+    { x: 9, y: 0 },
+    { x: 10, y: 0 },
+  ]
+  const obstacle = { minX: 4, minY: -0.5, maxX: 6, maxY: 0.5 }
+
+  const detours = generateInternalSegmentCollisionDetours({
+    path,
+    collidingSegmentIndex: 1,
+    obstacle,
+  })
+
+  expect(detours).toHaveLength(2)
+  for (const detour of detours) {
+    expect(detour.slice(0, 2)).toEqual(path.slice(0, 2))
+    expect(detour.slice(-2)).toEqual(path.slice(-2))
+    expect(isPathCollidingWithObstacles(detour, [obstacle])).toBe(false)
+  }
+})
+
+test("internal segment detours support vertical paths", () => {
+  const path = [
+    { x: 0, y: 0 },
+    { x: 0, y: 1 },
+    { x: 0, y: 9 },
+    { x: 0, y: 10 },
+  ]
+  const obstacle = { minX: -0.5, minY: 4, maxX: 0.5, maxY: 6 }
+
+  const detours = generateInternalSegmentCollisionDetours({
+    path,
+    collidingSegmentIndex: 1,
+    obstacle,
+  })
+
+  expect(detours).toHaveLength(2)
+  expect(
+    detours.every(
+      (detour) => !isPathCollidingWithObstacles(detour, [obstacle]),
+    ),
+  ).toBe(true)
+})

package/tests/solvers/UnroutedTraceRecoverySolver/paired-junction-recovery.test.ts

@@ -0,0 +1,49 @@
+import { expect, test } from "bun:test"
+import { countPathIntersections } from "lib/solvers/Example28Solver/geometry"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import { segmentOverlapsRectBoundary } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { chipToRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import inputProblem from "tests/bug-reports/bug-report-20260724T175257Z/bug-report-20260724T175257Z.json"
+
+test("recovers paired connections through clear same-net junctions", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem as any)
+
+  solver.solve()
+
+  const recoveredTraces =
+    solver.unroutedTraceRecoverySolver!.solvedUnroutedTraces
+  const alreadySolvedTraces =
+    solver.longDistancePairSolver!.getOutput().allTracesMerged
+
+  expect(recoveredTraces.map((trace) => trace.mspPairId)).toEqual([
+    "R1.1-C1.1",
+    "R1.2-C1.2",
+  ])
+
+  for (const recoveredTrace of recoveredTraces) {
+    for (
+      let pointIndex = 0;
+      pointIndex < recoveredTrace.tracePath.length - 1;
+      pointIndex++
+    ) {
+      const startPoint = recoveredTrace.tracePath[pointIndex]!
+      const endPoint = recoveredTrace.tracePath[pointIndex + 1]!
+      for (const chip of solver.inputProblem.chips) {
+        expect(
+          segmentOverlapsRectBoundary(startPoint, endPoint, chipToRect(chip)),
+        ).toBe(false)
+      }
+    }
+    for (const existingTrace of alreadySolvedTraces) {
+      const intersectionCount = countPathIntersections(
+        recoveredTrace.tracePath,
+        existingTrace.tracePath,
+      )
+      if (recoveredTrace.globalConnNetId === existingTrace.globalConnNetId) {
+        expect(intersectionCount).toBeGreaterThan(0)
+        continue
+      }
+      expect(intersectionCount).toBe(0)
+    }
+  }
+})

package/tests/solvers/UnroutedTraceRecoverySolver/skip-ground.test.ts

@@ -0,0 +1,30 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import { UnroutedTraceRecoverySolver } from "lib/solvers/UnroutedTraceRecoverySolver/UnroutedTraceRecoverySolver"
+import inputProblem from "tests/assets/example12.json"
+
+test("does not recover the canonical ground connectivity net", () => {
+  const pipelineSolver = new SchematicTracePipelineSolver(inputProblem as any)
+  pipelineSolver.solveUntilPhase("unroutedTraceRecoverySolver")
+
+  const failedConnectionPairs =
+    pipelineSolver.schematicTraceLinesSolver!.failedConnectionPairs.map(
+      (connectionPair) => {
+        return {
+          ...connectionPair,
+          userNetId: undefined,
+        }
+      },
+    )
+  const recoverySolver = new UnroutedTraceRecoverySolver({
+    inputProblem: pipelineSolver.inputProblem,
+    failedConnectionPairs,
+    alreadySolvedTraces:
+      pipelineSolver.longDistancePairSolver!.getOutput().allTracesMerged,
+  })
+
+  recoverySolver.solve()
+
+  expect(failedConnectionPairs).not.toHaveLength(0)
+  expect(recoverySolver.solvedUnroutedTraces).toHaveLength(0)
+})

package/tests/solvers/UnroutedTraceRecoverySolver/skip-long-connection.test.ts

@@ -0,0 +1,24 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import { UnroutedTraceRecoverySolver } from "lib/solvers/UnroutedTraceRecoverySolver/UnroutedTraceRecoverySolver"
+import inputProblem from "tests/bug-reports/bug-report-20260724T175257Z/bug-report-20260724T175257Z.json"
+
+test("does not recover connection pairs beyond maxMspPairDistance", () => {
+  const pipelineSolver = new SchematicTracePipelineSolver(inputProblem as any)
+  pipelineSolver.solveUntilPhase("unroutedTraceRecoverySolver")
+
+  const recoverySolver = new UnroutedTraceRecoverySolver({
+    inputProblem: {
+      ...pipelineSolver.inputProblem,
+      maxMspPairDistance: 1,
+    },
+    failedConnectionPairs:
+      pipelineSolver.schematicTraceLinesSolver!.failedConnectionPairs,
+    alreadySolvedTraces:
+      pipelineSolver.longDistancePairSolver!.getOutput().allTracesMerged,
+  })
+
+  recoverySolver.solve()
+
+  expect(recoverySolver.solvedUnroutedTraces).toHaveLength(0)
+})