@tscircuit/schematic-trace-solver 0.0.165 → 0.0.167

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

@@ -9,5 +9,8 @@ test("board 648 ESP-12F power and boot section", () => {
 
   solver.solve()
 
+  expect(solver.sameNetJunctionAlignmentSolver?.stats.collapsedCycleCount).toBe(
+    0,
+  )
   expect(solver).toMatchSolverSnapshot(import.meta.path)
 })

package/tests/repros/repro-isolated-rs485-isow7841.test.ts

@@ -1,9 +1,18 @@
 import { expect, test } from "bun:test"
 import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
-import type { InputProblem } from "lib/types/InputProblem"
+import type { InputProblem, PinId } from "lib/types/InputProblem"
 import "tests/fixtures/matcher"
 import inputProblemJson from "./assets/repro-isolated-rs485-isow7841.input.json"
 
+const EXPECTED_D_P_RAIL_Y = 2.2
+const REDUNDANT_D_P_RAIL_Y = 2.3
+const EXPECTED_GND1_RAIL_Y = 1.76
+const GND1_RAIL_PIN_IDS = ["schematic_port_35", "schematic_port_33"] satisfies [
+  PinId,
+  PinId,
+]
+const POINT_EPSILON = 1e-6
+
 test("repro isolated RS-485 ISOW7841 schematic traces", () => {
   const inputProblem: InputProblem = JSON.parse(
     JSON.stringify(inputProblemJson),
@@ -17,5 +26,28 @@ test("repro isolated RS-485 ISOW7841 schematic traces", () => {
   expect(solver.schematicTraceLinesSolver?.failedConnectionPairs).toHaveLength(
     0,
   )
+  expect(solver.sameNetJunctionAlignmentSolver?.stats.collapsedCycleCount).toBe(
+    2,
+  )
+  const dPLabel =
+    solver.sameNetJunctionAlignmentSolver?.outputNetLabelPlacements.find(
+      (label) => label.netId === "D_P",
+    )
+  expect(dPLabel?.anchorPoint.y).toBeCloseTo(EXPECTED_D_P_RAIL_Y)
+  const dPLabelHostTrace =
+    solver.sameNetJunctionAlignmentSolver?.outputTraces.find((trace) =>
+      dPLabel?.mspConnectionPairIds.includes(trace.mspPairId),
+    )
+  expect(
+    dPLabelHostTrace?.tracePath.some(
+      (point) => Math.abs(point.y - REDUNDANT_D_P_RAIL_Y) < POINT_EPSILON,
+    ),
+  ).toBe(false)
+  const gnd1RailTrace =
+    solver.sameNetJunctionAlignmentSolver?.outputTraces.find((trace) =>
+      GND1_RAIL_PIN_IDS.every((pinId) => trace.pinIds.includes(pinId)),
+    )
+  expect(gnd1RailTrace?.tracePath[1]?.y).toBeCloseTo(EXPECTED_GND1_RAIL_Y)
+  expect(gnd1RailTrace?.tracePath[2]?.y).toBeCloseTo(EXPECTED_GND1_RAIL_Y)
   expect(solver).toMatchSolverSnapshot(import.meta.path)
 })

package/tests/repros/repro-nrf52810-clock-routing.test.ts

@@ -1,13 +1,22 @@
 import { expect, test } from "bun:test"
 import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import type { InputProblem } from "lib/types/InputProblem"
 import "tests/fixtures/matcher"
 import inputProblem from "./assets/repro-nrf52810-clock-routing.input.json"
 
+const EXPECTED_CRYSTAL_RAIL_Y_BY_TRACE_ID = new Map([
+  ["schematic_port_42-schematic_port_175", 4.99],
+  ["schematic_port_46-schematic_port_181", 5],
+])
+const REDUNDANT_UPPER_RAIL_Y = 5.1
+const POINT_EPSILON = 1e-6
+
 // Extracted from the nRF52810 clock-source schematic shown in the reproduction:
 // a four-pin 32 MHz crystal and a two-pin 32.768 kHz crystal, each connected
 // to an MCU schematic box, two load capacitors, and section-local GND labels.
 test("repro nRF52810 HF and LF crystal trace/net-label routing", () => {
-  const solver = new SchematicTracePipelineSolver(inputProblem as any)
+  const solverInput: InputProblem = JSON.parse(JSON.stringify(inputProblem))
+  const solver = new SchematicTracePipelineSolver(solverInput)
 
   solver.solve()
 
@@ -24,5 +33,21 @@ test("repro nRF52810 HF and LF crystal trace/net-label routing", () => {
   expect(
     solver.sameNetJunctionAlignmentSolver?.getOutput().netLabelPlacements,
   ).toHaveLength(10)
+  expect(solver.sameNetJunctionAlignmentSolver?.stats.collapsedCycleCount).toBe(
+    2,
+  )
+  for (const [traceId, expectedRailY] of EXPECTED_CRYSTAL_RAIL_Y_BY_TRACE_ID) {
+    const crystalLoadTrace =
+      solver.sameNetJunctionAlignmentSolver?.outputTraces.find(
+        (trace) => trace.mspPairId === traceId,
+      )
+    expect(crystalLoadTrace?.tracePath[0]?.y).toBeCloseTo(expectedRailY)
+    expect(crystalLoadTrace?.tracePath[1]?.y).toBeCloseTo(expectedRailY)
+    expect(
+      crystalLoadTrace?.tracePath.some(
+        (point) => Math.abs(point.y - REDUNDANT_UPPER_RAIL_Y) < POINT_EPSILON,
+      ),
+    ).toBe(false)
+  }
   expect(solver).toMatchSolverSnapshot(import.meta.path)
 })

package/tests/repros/repro-pga300-redundant-ground-traces.test.ts

@@ -1,4 +1,5 @@
 import { expect, test } from "bun:test"
+import { ConnectivityMap } from "connectivity-map"
 import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
 import type { InputProblem } from "lib/types/InputProblem"
 import "tests/fixtures/matcher"
@@ -12,22 +13,49 @@ const GND = "schematic_port_7"
 const C3_GND = "schematic_port_32"
 const R1_GND = "schematic_port_38"
 
-test("repro: PGA300 adds redundant ground branches at COMP", async () => {
+test("PGA300 preserves COMP to R1 without redundant ground branches", async () => {
   const solver = new SchematicTracePipelineSolver(
     inputProblem as unknown as InputProblem,
   )
   solver.solve()
 
   expect(solver.solved).toBe(true)
-  const { traces } = solver.netLabelToTraceSolver!.getOutput()
+  const { traces, netLabelPlacements } =
+    solver.netLabelToTraceSolver!.getOutput()
   const hasPair = (a: string, b: string) =>
     traces.some((trace) => trace.pinIds.includes(a) && trace.pinIds.includes(b))
 
-  // Current bug: the global GND spanning tree substitutes these two branches
-  // for the explicitly requested COMP -> R1 connection in the source circuit.
-  expect(hasPair(COMP, GND)).toBe(true)
-  expect(hasPair(COMP, C3_GND)).toBe(true)
-  expect(hasPair(COMP, R1_GND)).toBe(false)
+  // GND labels provide global connectivity; they must not replace the
+  // explicitly requested COMP -> R1 connection with unrelated ground branches.
+  expect(hasPair(COMP, GND)).toBe(false)
+  expect(hasPair(COMP, C3_GND)).toBe(false)
+  expect(hasPair(COMP, R1_GND)).toBe(true)
+
+  // Removing physical branches must leave every original GND pin connected
+  // through a routed island and a ground label, including the capacitor pins.
+  const renderedConnectivity = new ConnectivityMap({})
+  for (const trace of traces)
+    renderedConnectivity.addConnections([trace.pinIds])
+  for (const label of netLabelPlacements) {
+    if (label.netId) {
+      renderedConnectivity.addConnections([[label.netId, ...label.pinIds]])
+    }
+  }
+  const groundNet = renderedConnectivity.getNetConnectedToId("GND")
+  expect(groundNet).toBeDefined()
+  for (const pinId of inputProblem.netConnections.find((net) => net.isGround)!
+    .pinIds) {
+    expect(renderedConnectivity.getNetConnectedToId(pinId)).toBe(groundNet)
+  }
+
+  // Keep the already-fixed vertical Q1 emitter/R1 connection.
+  const emitterTrace = traces.find(
+    (trace) =>
+      trace.pinIds.includes("schematic_port_34") &&
+      trace.pinIds.includes("schematic_port_37"),
+  )!
+  expect(emitterTrace).toBeDefined()
+  for (const point of emitterTrace.tracePath) expect(point.x).toBeCloseTo(5.49)
 
   await expect(solver).toMatchSolverSnapshot(import.meta.path)
 })

package/tests/solvers/MspConnectionPairSolver/ground-direct-connection-groups.test.ts

@@ -0,0 +1,120 @@
+import { expect, test } from "bun:test"
+import { LongDistancePairSolver } from "lib/solvers/LongDistancePairSolver/LongDistancePairSolver"
+import { MspConnectionPairSolver } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import { getGroundConnectionPolicy } from "lib/solvers/MspConnectionPairSolver/getGroundConnectionPolicy"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+
+// The explicit A-B and C-D wires are farther apart than their neighbors on
+// the same named net. E is label-only, with no requested physical connection.
+const createInput = (): InputProblem => ({
+  chips: [0, 4, 1, 5, 2].map((x, index) => {
+    const chipId = "ABCDE"[index]!
+    return {
+      chipId,
+      center: { x, y: 0 },
+      width: 0.2,
+      height: 0.2,
+      pins: [{ pinId: chipId, x, y: 0.1, _facingDirection: "y+" }],
+    }
+  }),
+  directConnections: [
+    { pinIds: ["A", "B"], netId: "AGND" },
+    { pinIds: ["C", "D"], netId: "AGND" },
+  ],
+  netConnections: [
+    { netId: "AGND", pinIds: ["A", "B", "C", "D", "E"], isGround: true },
+  ],
+  availableNetLabelOrientations: { AGND: ["y+"] },
+  maxMspPairDistance: 100,
+})
+
+const pairKeys = (solver: MspConnectionPairSolver) =>
+  solver.mspConnectionPairs
+    .map((pair) =>
+      pair.pins
+        .map((pin) => pin.pinId)
+        .sort()
+        .join("-"),
+    )
+    .sort()
+
+test("marked ground nets retain explicit islands even with identical netIds", () => {
+  const inputProblem = createInput()
+  const canRoute = getGroundConnectionPolicy(inputProblem)
+  expect(canRoute("A", "B")).toBe(true)
+  expect(canRoute("C", "D")).toBe(true)
+  expect(canRoute("A", "C")).toBe(false)
+  expect(canRoute("A", "E")).toBe(false)
+
+  const solver = new MspConnectionPairSolver({ inputProblem })
+  solver.solve()
+  expect(pairKeys(solver)).toEqual(["A-B", "C-D"])
+  // Physical partitioning must not split the electrical net.
+  expect(solver.globalConnMap.getNetConnectedToId("A")).toBe(
+    solver.globalConnMap.getNetConnectedToId("E"),
+  )
+})
+
+test.each([false, undefined])(
+  "isGround=%s preserves automatic net routing",
+  (isGround) => {
+    const inputProblem = createInput()
+    inputProblem.netConnections[0]!.isGround = isGround
+    const solver = new MspConnectionPairSolver({ inputProblem })
+    solver.solve()
+    expect(getGroundConnectionPolicy(inputProblem)("A", "C")).toBe(true)
+    expect(solver.mspConnectionPairs).toHaveLength(4)
+  },
+)
+
+test("ground nets without explicit wires retain automatic shared buses", () => {
+  const inputProblem = createInput()
+  inputProblem.directConnections = []
+  const solver = new MspConnectionPairSolver({ inputProblem })
+  solver.solve()
+  expect(getGroundConnectionPolicy(inputProblem)("A", "C")).toBe(true)
+  expect(solver.mspConnectionPairs).toHaveLength(4)
+})
+
+test("long-distance recovery cannot reconnect separate ground islands", () => {
+  const inputProblem = createInput()
+  const solver = new LongDistancePairSolver({
+    inputProblem,
+    alreadySolvedTraces: [],
+    primaryMspConnectionPairs: [],
+    failedConnectionPairs: [],
+  })
+  solver.solve()
+  expect(solver.solvedLongDistanceTraces.length).toBeGreaterThan(0)
+  for (const trace of solver.solvedLongDistanceTraces) {
+    expect(["A-B", "C-D"]).toContain([...trace.pinIds].sort().join("-"))
+  }
+})
+
+test("explicit ground connections still respect distance and section limits", () => {
+  const inputProblem = createInput()
+  inputProblem.maxMspPairDistance = 0.5
+  const solver = new MspConnectionPairSolver({ inputProblem })
+  solver.solve()
+  expect(solver.mspConnectionPairs).toHaveLength(0)
+
+  inputProblem.maxMspPairDistance = 100
+  inputProblem.chips[0]!.sectionId = "left"
+  inputProblem.chips[1]!.sectionId = "right"
+  const sectionSolver = new MspConnectionPairSolver({ inputProblem })
+  sectionSolver.solve()
+  expect(pairKeys(sectionSolver)).toEqual(["C-D"])
+})
+
+test("label-only ground pins remain connected in the pipeline output", () => {
+  const solver = new SchematicTracePipelineSolver(createInput())
+  solver.solve()
+  const output = solver.netLabelToTraceSolver!.getOutput()
+  expect(solver.solved).toBe(true)
+  expect(
+    output.netLabelPlacements.some(
+      (label) => label.netId === "AGND" && label.pinIds.includes("E"),
+    ),
+  ).toBe(true)
+})

package/tests/solvers/SameNetJunctionAlignmentSolver/collapse-same-net-cycles.test.ts

@@ -0,0 +1,154 @@
+import { expect, test } from "bun:test"
+import type { Point } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { collapseSameNetCycles } from "lib/solvers/SameNetJunctionAlignmentSolver/collapseSameNetCycles"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  getVisibleTraceLength,
+  getVisibleTraceSegmentCount,
+} from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
+import type { PinId } from "lib/types/InputProblem"
+
+interface TraceFixtureInput {
+  mspPairId: string
+  pinIds: [PinId, PinId]
+  tracePath: Point[]
+}
+
+const createTraceFixture = ({
+  mspPairId,
+  pinIds,
+  tracePath,
+}: TraceFixtureInput): SolvedTracePath => ({
+  mspPairId,
+  dcConnNetId: "same-net",
+  globalConnNetId: "same-net",
+  pins: [
+    {
+      pinId: pinIds[0],
+      chipId: `chip-${pinIds[0]}`,
+      ...tracePath[0]!,
+    },
+    {
+      pinId: pinIds[1],
+      chipId: `chip-${pinIds[1]}`,
+      ...tracePath.at(-1)!,
+    },
+  ],
+  tracePath,
+  mspConnectionPairIds: [mspPairId],
+  pinIds,
+})
+
+test("collapses a same-net cycle between a shared pin and crossing", () => {
+  const traces = [
+    createTraceFixture({
+      mspPairId: "upper-to-shared",
+      pinIds: ["upper", "shared"],
+      tracePath: [
+        { x: 8, y: 2 },
+        { x: 0, y: 2 },
+        { x: 0, y: 0 },
+      ],
+    }),
+    createTraceFixture({
+      mspPairId: "shared-to-lower",
+      pinIds: ["shared", "lower"],
+      tracePath: [
+        { x: 0, y: 0 },
+        { x: 6, y: 0 },
+        { x: 6, y: 4 },
+        { x: 8, y: 4 },
+      ],
+    }),
+  ]
+  const netLabelPlacement: NetLabelPlacement = {
+    globalConnNetId: "same-net",
+    dcConnNetId: "same-net",
+    mspConnectionPairIds: ["upper-to-shared"],
+    pinIds: ["upper", "shared"],
+    orientation: "x-",
+    anchorPoint: { x: 0, y: 2 },
+    width: 0.5,
+    height: 0.2,
+    center: { x: -0.25, y: 2 },
+  }
+
+  const result = collapseSameNetCycles({
+    traces,
+    netLabelPlacements: [netLabelPlacement],
+  })
+
+  expect(result.collapsedCycleCount).toBe(1)
+  expect(getVisibleTraceLength(traces)).toBe(22)
+  expect(getVisibleTraceLength(result.traces)).toBe(14)
+  expect(getVisibleTraceSegmentCount(result.traces)).toBe(4)
+  expect(result.traces[0]?.tracePath.at(-1)).toEqual({ x: 0, y: 0 })
+  expect(result.netLabelPlacements[0]?.anchorPoint).toEqual({ x: 0, y: 0 })
+})
+
+test("keeps a valid shared same-net branch", () => {
+  const traces = [
+    createTraceFixture({
+      mspPairId: "shared-to-branch",
+      pinIds: ["shared", "branch"],
+      tracePath: [
+        { x: 0, y: 0 },
+        { x: 4, y: 0 },
+        { x: 4, y: 2 },
+      ],
+    }),
+    createTraceFixture({
+      mspPairId: "shared-to-trunk",
+      pinIds: ["shared", "trunk"],
+      tracePath: [
+        { x: 0, y: 0 },
+        { x: 4, y: 0 },
+        { x: 8, y: 0 },
+      ],
+    }),
+  ]
+
+  const result = collapseSameNetCycles({
+    traces,
+    netLabelPlacements: [],
+  })
+
+  expect(result.collapsedCycleCount).toBe(0)
+  expect(result.traces).toEqual(traces)
+})
+
+test("does not lengthen a trace to reuse shared donor geometry", () => {
+  const traces = [
+    createTraceFixture({
+      mspPairId: "short-trace",
+      pinIds: ["short-end", "shared"],
+      tracePath: [
+        { x: 0, y: 0 },
+        { x: 0, y: -1 },
+        { x: 2, y: -1 },
+        { x: 2, y: 0 },
+      ],
+    }),
+    createTraceFixture({
+      mspPairId: "long-donor",
+      pinIds: ["shared", "donor-end"],
+      tracePath: [
+        { x: 2, y: 0 },
+        { x: 2, y: -1 },
+        { x: 4, y: -1 },
+        { x: 4, y: -2 },
+        { x: 1, y: -2 },
+        { x: 1, y: 1 },
+        { x: 5, y: 1 },
+      ],
+    }),
+  ]
+
+  const result = collapseSameNetCycles({
+    traces,
+    netLabelPlacements: [],
+  })
+
+  expect(result.traces[0]).toEqual(traces[0])
+})