@tscircuit/schematic-trace-solver 0.0.202 → 0.0.203

package/tests/repros/repro-am3352-06-boot.test.ts

@@ -0,0 +1,43 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import { tracePathContainsPoint } from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
+import { findPerpendicularPathCrossings } from "lib/solvers/TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles"
+import "tests/fixtures/matcher"
+import input from "./assets/repro-am3352-06-boot.input.json"
+
+// Full sheet from am3352-dev-board-4layer-dogbone.json; routing uses core defaults.
+test("repro complete AM3352 06-Boot sheet", async () => {
+  const problem = structuredClone(input) as InputProblem
+  const solver = new SchematicTracePipelineSolver(problem, {
+    hideRatsNet: true,
+  })
+  solver.solve()
+  expect(solver.solved).toBe(true)
+  expect(solver.failed).toBe(false)
+  const { traces, inlineNetLabelPlacements } =
+    solver.netLabelToTraceSolver!.getOutput()
+  for (const netId of ["BOOT_SEL1", "BOOT_SEL2", "BOOT_SEL3"]) {
+    const trace = traces.find((trace) => trace.userNetId === netId)!
+    expect(trace).toBeDefined()
+    expect(trace.tracePath).toHaveLength(4)
+    expect(trace.tracePath[1]!.y).toBe(trace.tracePath[0]!.y)
+    expect(trace.tracePath[2]!.y).toBe(trace.tracePath[3]!.y)
+    const label = inlineNetLabelPlacements.find(
+      (label) => label.globalConnNetId === trace.globalConnNetId,
+    )!
+    expect(label).toBeDefined()
+    expect(tracePathContainsPoint(trace.tracePath, label.anchorPoint)).toBe(
+      true,
+    )
+    for (const otherTrace of traces) {
+      if (otherTrace.globalConnNetId === trace.globalConnNetId) continue
+      expect(
+        findPerpendicularPathCrossings(trace.tracePath, otherTrace.tracePath, {
+          includeTerminalSegments: true,
+        }),
+      ).toEqual([])
+    }
+  }
+  await expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/solvers/TraceCleanupSolver/reroute-generated-net-label-connector-crossings.test.ts

@@ -158,3 +158,52 @@ test("allows crossings between generated label connectors", () => {
   expect(result.reroutedTraceCount).toBe(0)
   expect(result.traces).toEqual([connectorTrace, otherConnector])
 })
+
+test.each([false, true])(
+  "removes the old loop when rerouting a connector crossing (reversed: %s)",
+  (reversed) => {
+    let tracePath = [
+      { x: 0, y: 0 },
+      { x: 1, y: 0 },
+      { x: 1, y: 3 },
+      { x: 4, y: 3 },
+      { x: 4, y: -3 },
+      { x: 0, y: -3 },
+    ]
+    if (reversed) tracePath = tracePath.toReversed()
+    const trace = makeTrace({
+      mspPairId: "loop",
+      globalConnNetId: "signal",
+      pinIds: ["a", "b"],
+      tracePath,
+    })
+    const connector = makeTrace({
+      mspPairId: "connector",
+      globalConnNetId: "power",
+      pinIds: ["c"],
+      tracePath: [
+        { x: 0, y: 1 },
+        { x: 2, y: 1 },
+      ],
+    })
+    const result = rerouteGeneratedNetLabelConnectorCrossings({
+      inputProblem,
+      traces: [trace, connector],
+      netLabelPlacements: [],
+      mergedLabelNetIdMap: {},
+      clearance: 0.1,
+      connectorTraceIds: new Set([connector.mspPairId]),
+    })
+    const path = result.traces[0]!.tracePath
+    expect(result.reroutedTraceCount).toBe(1)
+    expect(path).toHaveLength(4)
+    expect(path[0]).toEqual(tracePath[0])
+    expect(path.at(-1)).toEqual(tracePath.at(-1))
+    expect(getPathLength(path)).toBeLessThan(getPathLength(tracePath))
+    expect(
+      findPerpendicularPathCrossings(path, connector.tracePath, {
+        includeTerminalSegments: true,
+      }),
+    ).toEqual([])
+  },
+)