@tscircuit/schematic-trace-solver 0.0.183 → 0.0.185

package/tests/repros/repro-esp12f-section.test.ts

@@ -0,0 +1,12 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import inputProblem from "./assets/repro-esp12f-status-section.input.json"
+import "tests/fixtures/matcher"
+
+test("reproduces ESP-12F schematic section routing", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem as any)
+
+  solver.solve()
+
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/solvers/SameNetJunctionAlignmentSolver/collapse-redundant-shared-endpoint-stubs.test.ts

@@ -0,0 +1,101 @@
+import { expect, test } from "bun:test"
+import type { Point } from "@tscircuit/math-utils"
+import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import { collapseRedundantSharedEndpointStubs } from "lib/solvers/SameNetJunctionAlignmentSolver/collapseRedundantSharedEndpointStubs"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { PinId } from "lib/types/InputProblem"
+
+const createTrace = ({
+  mspPairId,
+  pinIds,
+  tracePath,
+}: {
+  mspPairId: MspConnectionPairId
+  pinIds: [PinId, PinId]
+  tracePath: Point[]
+}): SolvedTracePath => ({
+  mspPairId,
+  dcConnNetId: "gnd",
+  globalConnNetId: "gnd",
+  pins: [
+    { pinId: pinIds[0], chipId: "first-chip", ...tracePath[0]! },
+    { pinId: pinIds[1], chipId: "second-chip", ...tracePath.at(-1)! },
+  ],
+  tracePath,
+  mspConnectionPairIds: [mspPairId],
+  pinIds,
+})
+
+test("collapses one duplicate stub at a shared same-net endpoint", () => {
+  const traces = [
+    createTrace({
+      mspPairId: "upper-shared",
+      pinIds: ["upper", "shared"],
+      tracePath: [
+        { x: 0, y: 0 },
+        { x: 2, y: 0 },
+        { x: 2, y: 2 },
+        { x: 1, y: 2 },
+      ],
+    }),
+    createTrace({
+      mspPairId: "lower-shared",
+      pinIds: ["lower", "shared"],
+      tracePath: [
+        { x: 0, y: 5 },
+        { x: 0, y: 4 },
+        { x: 2, y: 4 },
+        { x: 2, y: 2 },
+        { x: 1, y: 2 },
+      ],
+    }),
+  ]
+
+  const result = collapseRedundantSharedEndpointStubs({
+    traces,
+    netLabelPlacements: [],
+    netLabelConnectorTraceIds: new Set<MspConnectionPairId>(),
+    multiPinNetPinIds: new Set(["shared"]),
+  })
+
+  expect(result.map((trace) => trace.tracePath.length)).toEqual([4, 4])
+  expect(result[1]?.tracePath.at(-1)).toEqual({ x: 2, y: 2 })
+})
+
+test("collapses a shared stub and partial rail overlap", () => {
+  const traces = [
+    createTrace({
+      mspPairId: "shared-trunk",
+      pinIds: ["shared", "trunk"],
+      tracePath: [
+        { x: 0, y: 0 },
+        { x: 0, y: -1 },
+        { x: -4, y: -1 },
+        { x: -4, y: 0 },
+      ],
+    }),
+    createTrace({
+      mspPairId: "feed-shared",
+      pinIds: ["feed", "shared"],
+      tracePath: [
+        { x: -1, y: 3 },
+        { x: -1, y: -1 },
+        { x: 0, y: -1 },
+        { x: 0, y: 0 },
+      ],
+    }),
+  ]
+
+  const result = collapseRedundantSharedEndpointStubs({
+    traces,
+    netLabelPlacements: [],
+    netLabelConnectorTraceIds: new Set<MspConnectionPairId>(),
+    multiPinNetPinIds: new Set(["shared"]),
+  })
+
+  expect(result[0]?.tracePath).toEqual(traces[0]?.tracePath)
+  expect(result[1]?.tracePath).toEqual([
+    { x: -1, y: 3 },
+    { x: -1, y: -1 },
+  ])
+})

package/tests/solvers/UnroutedTraceRecoverySolver/local-elbow-obstacles.test.ts

@@ -0,0 +1,74 @@
+import { expect, test } from "bun:test"
+import {
+  countPathIntersections,
+  getPathLength,
+} from "lib/solvers/Example28Solver/geometry"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import { findFirstCollision } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { UnroutedTraceRecoverySolver } from "lib/solvers/UnroutedTraceRecoverySolver/UnroutedTraceRecoverySolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import inputProblem from "tests/bug-reports/bug-report-20260905T041712Z/bug-report-20260905T041712Z.json"
+
+test.each(["chip", "text", "trace"] as const)(
+  "rejects a local recovery elbow blocked by a %s",
+  (obstacleKind) => {
+    const pipeline = new SchematicTracePipelineSolver(
+      structuredClone(inputProblem) as InputProblem,
+    )
+    pipeline.solveUntilPhase("unroutedTraceRecoverySolver")
+
+    const connectionPair =
+      pipeline.schematicTraceLinesSolver!.failedConnectionPairs.find(
+        (pair) => pair.mspPairId === "schematic_port_101-schematic_port_125",
+      )!
+    const problem = pipeline.inputProblem
+    const existingTraces = [
+      ...pipeline.longDistancePairSolver!.getOutput().allTracesMerged,
+    ]
+    const blockingBounds = { minX: 3.6, maxX: 3.7, minY: -8.96, maxY: -8.94 }
+    const blockingPath = [
+      { x: 3.6, y: -8.95 },
+      { x: 3.7, y: -8.95 },
+    ]
+
+    if (obstacleKind === "chip") {
+      problem.chips.push({
+        chipId: "blocking-chip",
+        center: { x: 3.65, y: -8.95 },
+        width: 0.1,
+        height: 0.02,
+        pins: [],
+      })
+    }
+    if (obstacleKind === "text") {
+      problem.textBoxes!.push({
+        center: { x: 3.65, y: -8.95 },
+        width: 0.1,
+        height: 0.02,
+      })
+    }
+    if (obstacleKind === "trace") {
+      const otherNetTrace = existingTraces.find(
+        (trace) => trace.globalConnNetId !== connectionPair.globalConnNetId,
+      )!
+      existingTraces.splice(existingTraces.indexOf(otherNetTrace), 1, {
+        ...otherNetTrace,
+        tracePath: blockingPath,
+      })
+    }
+
+    const recovery = new UnroutedTraceRecoverySolver({
+      inputProblem: problem,
+      failedConnectionPairs: [connectionPair],
+      alreadySolvedTraces: existingTraces,
+    })
+    recovery.solve()
+
+    expect(recovery.solved).toBe(true)
+    expect(recovery.solvedUnroutedTraces).toHaveLength(1)
+    const recoveredPath = recovery.solvedUnroutedTraces[0]!.tracePath
+    expect(getPathLength(recoveredPath)).toBeGreaterThan(0.8)
+    expect(findFirstCollision(recoveredPath, [blockingBounds])).toBeNull()
+    expect(countPathIntersections(recoveredPath, blockingPath)).toBe(0)
+  },
+)