@tscircuit/schematic-trace-solver 0.0.202 → 0.0.204

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/repros/repro-smart-lock-ble-module.test.ts

@@ -0,0 +1,69 @@
+import { expect, test } from "bun:test"
+import { isPathCollidingWithObstacles } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import { detectTraceLabelOverlap } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap"
+import type { InputProblem } from "lib/types/InputProblem"
+import "tests/fixtures/matcher"
+import input from "./assets/repro-smart-lock-ble-module.input.json"
+
+// Full ble_module sheet from imrishabh18/smart-lock v0.0.1.
+// Reconstructed from deployed Circuit JSON with current core routing defaults.
+test("repro smart-lock BLE module schematic sheet", async () => {
+  const solver = new SchematicTracePipelineSolver(
+    structuredClone(input) as unknown as InputProblem,
+    { hideRatsNet: true },
+  )
+  solver.solve()
+
+  expect(solver.solved).toBe(true)
+  expect(solver.failed).toBe(false)
+
+  const { traces, netLabelPlacements } =
+    solver.netLabelToTraceSolver!.getOutput()
+  const supplyLabel = netLabelPlacements.find((label) =>
+    label.mspConnectionPairIds.includes(
+      "schematic_port_246-schematic_port_243",
+    ),
+  )!
+  // C99, C104, C103, and C102 must share C101's labeled VDDS rail.
+  for (const traceId of [
+    "schematic_port_244-schematic_port_246",
+    "schematic_port_248-schematic_port_246",
+    "schematic_port_250-schematic_port_248",
+    "schematic_port_252-schematic_port_250",
+  ]) {
+    const trace = traces.find((trace) => trace.mspPairId === traceId)!
+    expect(trace.tracePath[1]!.y).toBeCloseTo(supplyLabel.anchorPoint.y)
+    expect(trace.tracePath[2]!.y).toBeCloseTo(supplyLabel.anchorPoint.y)
+  }
+
+  // The C92–L34 ground trace needs one offset around U1's label column.
+  const groundTrace = traces.find(
+    (trace) => trace.mspPairId === "schematic_port_291-schematic_port_297",
+  )!
+  const path = groundTrace.tracePath
+  expect(path).toHaveLength(6)
+  expect(path[2]!.x).toBeCloseTo(path[3]!.x)
+  expect(path[3]!.y).toBeCloseTo(path[4]!.y)
+  for (const [endpoint, neighbor, pin] of [
+    [path[0]!, path[1]!, groundTrace.pins[0]!],
+    [path.at(-1)!, path.at(-2)!, groundTrace.pins[1]!],
+  ] as const) {
+    expect(endpoint.x).toBeCloseTo(pin.x)
+    expect(endpoint.y).toBeCloseTo(pin.y)
+    expect(neighbor.x).toBeCloseTo(endpoint.x)
+    expect(neighbor.y).toBeLessThan(endpoint.y)
+  }
+  expect(
+    isPathCollidingWithObstacles(path, getObstacleRects(solver.inputProblem)),
+  ).toBe(false)
+  expect(
+    detectTraceLabelOverlap({
+      traces: [groundTrace],
+      netLabels: netLabelPlacements,
+    }),
+  ).toHaveLength(0)
+
+  await expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/solvers/TraceCleanupSolver/alignSameNetRails-fixed-backbone.test.ts

@@ -0,0 +1,135 @@
+import { expect, test } from "bun:test"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import { align, createTrace } from "./fixtures/alignSameNetRails"
+
+const createFixture = () => {
+  const firstPin = {
+    pinId: "C1.1",
+    chipId: "C1",
+    x: -2,
+    y: 0,
+    _facingDirection: "y+" as const,
+  }
+  const sharedPin = {
+    pinId: "C2.1",
+    chipId: "C2",
+    x: 0,
+    y: 0,
+    _facingDirection: "y+" as const,
+  }
+  const supplyPin = {
+    pinId: "F1.1",
+    chipId: "F1",
+    x: 1,
+    y: 3,
+    _facingDirection: "x-" as const,
+  }
+  const problem: InputProblem = {
+    maxMspPairDistance: 2.4,
+    chips: [
+      {
+        chipId: "C1",
+        center: { x: -2, y: -0.5 },
+        width: 0.8,
+        height: 1,
+        pins: [firstPin],
+      },
+      {
+        chipId: "C2",
+        center: { x: 0, y: -0.5 },
+        width: 0.8,
+        height: 1,
+        pins: [sharedPin],
+      },
+      {
+        chipId: "F1",
+        center: { x: 1.5, y: 3 },
+        width: 1,
+        height: 0.8,
+        pins: [supplyPin],
+      },
+    ],
+    directConnections: [],
+    netConnections: [],
+    availableNetLabelOrientations: {},
+  }
+  const branch = createTrace(
+    "branch",
+    [
+      { x: -2, y: 0 },
+      { x: -2, y: 1 },
+      { x: 0, y: 1 },
+      { x: 0, y: 0 },
+    ],
+    [firstPin, sharedPin],
+  )
+  const backbone = createTrace(
+    "backbone",
+    [
+      { x: 0, y: 0 },
+      { x: 0, y: 2 },
+      { x: 0.5, y: 2 },
+      { x: 0.5, y: 3 },
+      { x: 1, y: 3 },
+    ],
+    [sharedPin, supplyPin],
+  )
+  const label: NetLabelPlacement = {
+    globalConnNetId: "power-net",
+    netId: "POWER",
+    mspConnectionPairIds: ["backbone"],
+    pinIds: backbone.pinIds,
+    orientation: "y+",
+    anchorPoint: { x: 0, y: 2 },
+    center: { x: 0, y: 2.1 },
+    width: 0.4,
+    height: 0.2,
+  }
+  return { problem, branch, backbone, label }
+}
+
+test("aligns a branch to a labeled backbone without moving its elbows", () => {
+  const { problem, branch, backbone, label } = createFixture()
+  const result = align([branch, backbone], {
+    inputProblem: problem,
+    netLabelPlacements: [label],
+  })
+
+  expect(result.traces[0]!.tracePath).toEqual([
+    { x: -2, y: 0 },
+    { x: -2, y: 2 },
+    { x: 0, y: 2 },
+    { x: 0, y: 0 },
+  ])
+  expect(result.traces[1]).toEqual(backbone)
+})
+
+test("keeps the branch below an obstacle on the fixed backbone coordinate", () => {
+  const { problem, branch, backbone, label } = createFixture()
+  problem.chips.push({
+    chipId: "obstacle",
+    center: { x: -1, y: 2 },
+    width: 0.4,
+    height: 0.4,
+    pins: [],
+  })
+  const result = align([branch, backbone], {
+    inputProblem: problem,
+    netLabelPlacements: [label],
+  })
+
+  expect(result.traces).toEqual([branch, backbone])
+})
+
+test("does not pull a multi-turn backbone toward a label on a different coordinate", () => {
+  const { problem, branch, backbone, label } = createFixture()
+  label.anchorPoint.y = 1.5
+  label.center.y = 1.6
+  const result = align([branch, backbone], {
+    inputProblem: problem,
+    netLabelPlacements: [label],
+  })
+
+  expect(result.traces).toEqual([branch, backbone])
+})

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([])
+  },
+)

package/tests/solvers/TraceElbowTransitionSimplificationSolver/interior-staircase.test.ts

@@ -0,0 +1,146 @@
+import { expect, test } from "bun:test"
+import { getPathLength } from "lib/solvers/Example28Solver/geometry"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { TraceElbowTransitionSimplificationSolver } from "lib/solvers/TraceElbowTransitionSimplificationSolver/TraceElbowTransitionSimplificationSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import { createTrace } from "../TraceCleanupSolver/fixtures/alignSameNetRails"
+
+const createFixture = () => {
+  const path = [
+    { x: 5, y: 0 },
+    { x: 5, y: -1 },
+    { x: 2.5, y: -1 },
+    { x: 2.5, y: 2 },
+    { x: 2, y: 2 },
+    { x: 2, y: 3 },
+    { x: 1, y: 3 },
+    { x: 1, y: 4 },
+  ]
+  const trace = createTrace("rerouted", path, [
+    { pinId: "C1.1", chipId: "C1", x: 5, y: 0, _facingDirection: "y-" },
+    { pinId: "L1.1", chipId: "L1", x: 1, y: 4, _facingDirection: "y-" },
+  ])
+  const labels: NetLabelPlacement[] = [
+    {
+      globalConnNetId: "signal",
+      netId: "SIGNAL",
+      mspConnectionPairIds: [],
+      pinIds: [],
+      orientation: "x+",
+      anchorPoint: { x: 0.5, y: 0.7 },
+      center: { x: 1.45, y: 0.7 },
+      width: 1.9,
+      height: 2.4,
+    },
+    {
+      globalConnNetId: "signal2",
+      netId: "SIGNAL2",
+      mspConnectionPairIds: [],
+      pinIds: [],
+      orientation: "x+",
+      anchorPoint: { x: 0.5, y: 2.45 },
+      center: { x: 1.2, y: 2.45 },
+      width: 1.4,
+      height: 0.9,
+    },
+  ]
+  const problem: InputProblem = {
+    chips: [],
+    directConnections: [],
+    netConnections: [],
+    availableNetLabelOrientations: {},
+  }
+  return {
+    inputProblem: problem,
+    traces: [trace],
+    completedReroutes: [
+      {
+        initialTrace: trace,
+        reroutedTracePath: path,
+        label: labels[0]!,
+        detourCount: 0,
+      },
+    ],
+    netLabelPlacements: labels,
+    paddingBuffer: 0.1,
+  }
+}
+
+test("merges successive label detours without changing length or terminal directions", () => {
+  const input = createFixture()
+  const solver = new TraceElbowTransitionSimplificationSolver(input)
+  solver.solve()
+  const path = solver.getOutput().traces[0]!.tracePath
+
+  expect(path).toEqual([
+    { x: 5, y: 0 },
+    { x: 5, y: -1 },
+    { x: 2.5, y: -1 },
+    { x: 2.5, y: 3 },
+    { x: 1, y: 3 },
+    { x: 1, y: 4 },
+  ])
+  expect(getPathLength(path)).toBeCloseTo(
+    getPathLength(input.traces[0]!.tracePath),
+  )
+})
+
+test.each([
+  "component",
+  "label",
+  "parallel_trace",
+  "crossing_trace",
+  "anchor",
+] as const)("preserves a necessary staircase blocked by %s", (blocker) => {
+  const input = createFixture()
+  if (blocker === "component") {
+    input.inputProblem.chips.push({
+      chipId: "obstacle",
+      center: { x: 2.5, y: 2.5 },
+      width: 0.2,
+      height: 0.4,
+      pins: [],
+    })
+  } else if (blocker === "parallel_trace" || blocker === "crossing_trace") {
+    const path =
+      blocker === "parallel_trace"
+        ? [
+            { x: 2.5, y: 2.2 },
+            { x: 2.5, y: 2.8 },
+          ]
+        : [
+            { x: 2.3, y: 2.5 },
+            { x: 2.7, y: 2.5 },
+          ]
+    input.traces.push(
+      createTrace(
+        "foreign",
+        path,
+        [
+          { pinId: "X1.1", chipId: "X1", ...path[0]! },
+          { pinId: "X2.1", chipId: "X2", ...path[1]! },
+        ],
+        "foreign",
+      ),
+    )
+  } else {
+    const x = blocker === "anchor" ? 2 : 2.5
+    input.netLabelPlacements.push({
+      globalConnNetId: blocker === "anchor" ? "power-net" : "foreign",
+      netId: "BLOCKER",
+      mspConnectionPairIds: ["rerouted"],
+      pinIds: [],
+      orientation: "x+",
+      anchorPoint: { x, y: 2.5 },
+      center: { x: x + 0.1, y: 2.5 },
+      width: 0.2,
+      height: 0.4,
+    })
+  }
+  const solver = new TraceElbowTransitionSimplificationSolver(input)
+  solver.solve()
+
+  expect(solver.getOutput().traces[0]!.tracePath).toEqual(
+    input.traces[0]!.tracePath,
+  )
+})