@tscircuit/schematic-trace-solver 0.0.164 → 0.0.166

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/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])
+})