@tscircuit/schematic-trace-solver 0.0.158 → 0.0.159

package/tests/repros/repro-mspm0l1306-capacitor-symmetry.test.ts

@@ -19,7 +19,8 @@ test("repro: MSPM0L1306 aligned decoupling capacitor rails", async () => {
   expect(solver.solved).toBe(true)
   expect(solver.failed).toBe(false)
 
-  const traces = solver.netLabelToTraceSolver!.getOutput().traces
+  const { traces, netLabelPlacements } =
+    solver.netLabelToTraceSolver!.getOutput()
   const getTrace = (...pinIds: string[]) => {
     const trace = traces.find((trace) =>
       pinIds.every((pinId) => trace.pinIds.includes(pinId)),
@@ -43,12 +44,44 @@ test("repro: MSPM0L1306 aligned decoupling capacitor rails", async () => {
     expect([start!.x, end!.x].sort()).toEqual([-3.5, -4.5].sort())
   }
 
-  // The lower return should continue the C1 column, not introduce a third
-  // column between C1/C2 or an extra horizontal step near VSS.
-  const returnPath = getTrace("C3.2", "C2.2").tracePath
-  expect(returnPath.some((point) => Math.abs(point.x + 4.5) < 1e-6)).toBe(true)
-  expect(returnPath.every((point) => [-4.5, -3.5].includes(point.x))).toBe(true)
-  expect(returnPath.some((point) => Math.abs(point.y - 0.65) < 1e-6)).toBe(true)
+  // C3 and C4 share the electrical GND net with the decoupling rail, but
+  // should each terminate locally instead of being wired to other capacitors.
+  for (const pinId of ["C3.2", "C4.2"]) {
+    expect(
+      traces.some(
+        (trace) => trace.pinIds.includes(pinId) && trace.pinIds.length > 1,
+      ),
+    ).toBe(false)
+    expect(
+      netLabelPlacements.some(
+        (label) =>
+          label.netId === "GND" &&
+          label.pinIds.includes(pinId) &&
+          label.orientation === "y-",
+      ),
+    ).toBe(true)
+  }
+  const railGround = netLabelPlacements.find(
+    (label) =>
+      label.netId === "GND" &&
+      label.mspConnectionPairIds.some((pairId) =>
+        traces.some(
+          (trace) =>
+            trace.mspPairId === pairId && trace.pinIds.includes("C1.2"),
+        ),
+      ),
+  )
+  expect(railGround).toBeDefined()
+  expect(railGround!.orientation).toBe("y-")
+  expect(railGround!.anchorPoint.x).toBeCloseTo(-4.5, 6)
+  expect(railGround!.anchorPoint.y).toBeCloseTo(0.65, 6)
+  const groundNetId =
+    solver.mspConnectionPairSolver!.globalConnMap.getNetConnectedToId("GND")
+  expect(
+    netLabelPlacements
+      .filter((label) => label.netId === "GND")
+      .every((label) => label.globalConnNetId === groundNetId),
+  ).toBe(true)
 
   await expect(solver).toMatchSolverSnapshot(import.meta.path)
 })

package/tests/solvers/MspConnectionPairSolver/local-ground-branches.test.ts

@@ -0,0 +1,105 @@
+import { expect, test } from "bun:test"
+import { LongDistancePairSolver } from "lib/solvers/LongDistancePairSolver/LongDistancePairSolver"
+import { getGroundConnectionPolicy } from "lib/solvers/MspConnectionPairSolver/getGroundConnectionPolicy"
+import { MspConnectionPairSolver } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import { createParallelGroundRailProblem } from "tests/fixtures/parallel-ground-rail"
+
+test("keeps a wired parallel ground rail but labels independent staggered branches", () => {
+  const inputProblem = createParallelGroundRailProblem()
+  const before = structuredClone(inputProblem)
+  const solver = new MspConnectionPairSolver({ inputProblem })
+  solver.solve()
+  expect(solver.mspConnectionPairs).toHaveLength(2)
+  const routed = new Set(
+    solver.mspConnectionPairs.flatMap((pair) =>
+      pair.pins.map((pin) => pin.pinId),
+    ),
+  )
+  expect([...routed].sort()).toEqual(["A.2", "B.2", "U.GND"])
+  expect(inputProblem).toEqual(before)
+})
+
+test("long-distance recovery does not reconnect the separated ground branches", () => {
+  const inputProblem = createParallelGroundRailProblem()
+  const primary = new MspConnectionPairSolver({ inputProblem })
+  primary.solve()
+  const solver = new LongDistancePairSolver({
+    inputProblem,
+    primaryMspConnectionPairs: primary.mspConnectionPairs,
+    alreadySolvedTraces: [],
+    failedConnectionPairs: [],
+  })
+  solver.solve()
+  expect(solver.getOutput().newTraces).toEqual([])
+})
+
+test("the branch policy is symmetric in its endpoints", () => {
+  const canRoute = getGroundConnectionPolicy(createParallelGroundRailProblem())
+  expect(canRoute("B.2", "C.2")).toBe(false)
+  expect(canRoute("C.2", "B.2")).toBe(false)
+  expect(canRoute("C.2", "D.2")).toBe(false)
+  expect(canRoute("D.2", "C.2")).toBe(false)
+})
+
+test("explicit direct wiring overrides the local-ground preference", () => {
+  const inputProblem = createParallelGroundRailProblem()
+  inputProblem.directConnections.push({ pinIds: ["B.2", "C.2"] })
+  const canRoute = getGroundConnectionPolicy(inputProblem)
+  expect(canRoute("B.2", "C.2")).toBe(true)
+  expect(canRoute("A.2", "C.2")).toBe(true)
+  expect(canRoute("C.2", "D.2")).toBe(false)
+})
+
+for (const y of [1, 0.5, 0]) {
+  test(`keeps level or nearby ground pins at y=${y} on the rail`, () => {
+    const inputProblem = createParallelGroundRailProblem()
+    inputProblem.chips[2]!.pins[1]!.y = y
+    const canRoute = getGroundConnectionPolicy(inputProblem)
+    expect(canRoute("B.2", "C.2")).toBe(true)
+  })
+}
+
+test("preserves existing behavior without an explicitly wired parallel rail", () => {
+  const inputProblem = createParallelGroundRailProblem()
+  inputProblem.directConnections = []
+  expect(getGroundConnectionPolicy(inputProblem)("B.2", "C.2")).toBe(true)
+})
+
+test("a repeated direct-connection net ID does not invent a physical rail", () => {
+  const inputProblem = createParallelGroundRailProblem()
+  inputProblem.directConnections = [
+    { netId: "GND", pinIds: ["A.2", "U.GND"] },
+    { netId: "GND", pinIds: ["B.2", "D.2"] },
+  ]
+  expect(getGroundConnectionPolicy(inputProblem)("B.2", "C.2")).toBe(true)
+})
+
+test("resolves a ground alias through global connectivity", () => {
+  const inputProblem = createParallelGroundRailProblem()
+  inputProblem.netConnections[0]!.netId = "RETURN"
+  inputProblem.netConnections.push({ netId: "GND", pinIds: ["U.GND"] })
+  expect(getGroundConnectionPolicy(inputProblem)("B.2", "C.2")).toBe(false)
+})
+
+test("does not apply the ground rule to power or signal nets", () => {
+  const inputProblem = createParallelGroundRailProblem()
+  inputProblem.netConnections[0]!.netId = "VDD"
+  expect(getGroundConnectionPolicy(inputProblem)("B.2", "C.2")).toBe(true)
+})
+
+test("infers ground-facing pins when explicit directions are absent", () => {
+  const inputProblem = createParallelGroundRailProblem()
+  for (const chip of inputProblem.chips) {
+    for (const pin of chip.pins) delete pin._facingDirection
+  }
+  expect(getGroundConnectionPolicy(inputProblem)("B.2", "C.2")).toBe(false)
+})
+
+test("does not isolate side-facing or multi-pin components", () => {
+  const inputProblem = createParallelGroundRailProblem()
+  inputProblem.chips[2]!.pins[1]!._facingDirection = "x-"
+  expect(getGroundConnectionPolicy(inputProblem)("B.2", "C.2")).toBe(true)
+  inputProblem.chips[2]!.pins[1]!._facingDirection = "y-"
+  inputProblem.chips[2]!.pins.push({ pinId: "C.3", x: 2, y: -1.6 })
+  expect(getGroundConnectionPolicy(inputProblem)("B.2", "C.2")).toBe(true)
+})

package/tests/solvers/SameNetJunctionAlignmentSolver/ground-rail-label.test.ts

@@ -0,0 +1,188 @@
+import { expect, test } from "bun:test"
+import { getConnectivityMapsFromInputProblem } from "lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { placeGroundRailLabelsAtOuterEnd } from "lib/solvers/SameNetJunctionAlignmentSolver/placeGroundRailLabelsAtOuterEnd"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { createParallelGroundRailProblem } from "tests/fixtures/parallel-ground-rail"
+
+const createFixture = () => {
+  const inputProblem = createParallelGroundRailProblem()
+  const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem)
+  const globalConnNetId = netConnMap.getNetConnectedToId("GND")!
+  const pins = new Map(
+    inputProblem.chips.flatMap((chip) =>
+      chip.pins.map(
+        (pin) => [pin.pinId, { ...pin, chipId: chip.chipId }] as const,
+      ),
+    ),
+  )
+  const trace = (
+    mspPairId: string,
+    pinIds: [string, string],
+    path: number[][],
+  ): SolvedTracePath => ({
+    mspPairId,
+    mspConnectionPairIds: [mspPairId],
+    globalConnNetId,
+    dcConnNetId: globalConnNetId,
+    userNetId: "GND",
+    pinIds,
+    pins: [pins.get(pinIds[0])!, pins.get(pinIds[1])!],
+    tracePath: path.map(([x, y]) => ({ x: x!, y: y! })),
+  })
+  const traces = [
+    trace(
+      "rail",
+      ["B.2", "A.2"],
+      [
+        [1, 1],
+        [1, 0.6],
+        [0, 0.6],
+        [0, 1],
+      ],
+    ),
+    trace(
+      "feed",
+      ["U.GND", "B.2"],
+      [
+        [2, 0.6],
+        [1, 0.6],
+        [1, 1],
+      ],
+    ),
+  ]
+  const netLabelPlacements: NetLabelPlacement[] = [
+    {
+      globalConnNetId,
+      dcConnNetId: globalConnNetId,
+      netId: "GND",
+      mspConnectionPairIds: ["feed"],
+      pinIds: ["U.GND", "B.2"],
+      orientation: "y-",
+      anchorPoint: { x: 1, y: 0.6 },
+      center: { x: 1, y: 0.4 },
+      width: 0.4,
+      height: 0.4,
+    },
+  ]
+  return { inputProblem, traces, netLabelPlacements }
+}
+
+for (const mirror of [1, -1]) {
+  test(`places the shared GND at the outer column, mirrored=${mirror}`, () => {
+    const fixture = createFixture()
+    for (const chip of fixture.inputProblem.chips) {
+      chip.center.x *= mirror
+      for (const pin of chip.pins) pin.x *= mirror
+    }
+    for (const trace of fixture.traces) {
+      for (const point of trace.tracePath) point.x *= mirror
+    }
+    const visited = new Set()
+    for (const pin of fixture.traces.flatMap((trace) => trace.pins)) {
+      if (visited.has(pin)) continue
+      pin.x *= mirror
+      visited.add(pin)
+    }
+    fixture.netLabelPlacements[0]!.anchorPoint.x *= mirror
+    fixture.netLabelPlacements[0]!.center.x *= mirror
+    const before = structuredClone(fixture)
+    const labels = placeGroundRailLabelsAtOuterEnd(fixture)
+    expect(labels[0]!.anchorPoint.x).toBeCloseTo(0, 6)
+    expect(labels[0]!.anchorPoint.y).toBeCloseTo(0.6, 6)
+    expect(labels[0]!.mspConnectionPairIds).toEqual(["rail"])
+    expect(labels[0]!.globalConnNetId).toBe(
+      before.netLabelPlacements[0]!.globalConnNetId,
+    )
+    expect(fixture).toEqual(before)
+    expect(
+      placeGroundRailLabelsAtOuterEnd({
+        ...fixture,
+        netLabelPlacements: labels,
+      }),
+    ).toEqual(labels)
+  })
+}
+
+test("label placement is independent of trace and endpoint ordering", () => {
+  const fixture = createFixture()
+  fixture.traces.reverse()
+  for (const trace of fixture.traces) {
+    trace.tracePath.reverse()
+    trace.pins.reverse()
+    trace.pinIds.reverse()
+  }
+  expect(placeGroundRailLabelsAtOuterEnd(fixture)[0]!.anchorPoint).toEqual({
+    x: 0,
+    y: 0.6,
+  })
+})
+
+for (const obstacle of [
+  "chip",
+  "text",
+  "trace",
+  "same-net-trace",
+  "label",
+  "same-net-label",
+] as const) {
+  test(`keeps the existing anchor when the outer label would hit a ${obstacle}`, () => {
+    const fixture = createFixture()
+    const rect = { center: { x: 0, y: 0.4 }, width: 0.2, height: 0.2 }
+    if (obstacle === "chip")
+      fixture.inputProblem.chips.push({ ...rect, chipId: "obstacle", pins: [] })
+    if (obstacle === "text")
+      fixture.inputProblem.textBoxes = [{ ...rect, text: "annotation" }]
+    if (obstacle === "trace" || obstacle === "same-net-trace")
+      fixture.traces.push({
+        ...fixture.traces[0]!,
+        mspPairId: "obstacle",
+        globalConnNetId:
+          obstacle === "trace" ? "foreign" : fixture.traces[0]!.globalConnNetId,
+        tracePath: [
+          { x: -0.4, y: 0.4 },
+          { x: 0.4, y: 0.4 },
+        ],
+      })
+    if (obstacle === "label" || obstacle === "same-net-label")
+      fixture.netLabelPlacements.push({
+        ...fixture.netLabelPlacements[0]!,
+        ...rect,
+        globalConnNetId:
+          obstacle === "label"
+            ? "foreign"
+            : fixture.netLabelPlacements[0]!.globalConnNetId,
+        mspConnectionPairIds: [],
+        pinIds: [],
+        anchorPoint: { x: 0, y: 0.5 },
+      })
+    expect(placeGroundRailLabelsAtOuterEnd(fixture)).toEqual(
+      fixture.netLabelPlacements,
+    )
+  })
+}
+
+test("does not move a port-only or unrelated island's GND label", () => {
+  const fixture = createFixture()
+  fixture.netLabelPlacements[0]!.mspConnectionPairIds = []
+  expect(placeGroundRailLabelsAtOuterEnd(fixture)).toEqual(
+    fixture.netLabelPlacements,
+  )
+  fixture.netLabelPlacements[0]!.mspConnectionPairIds = ["another-island"]
+  expect(placeGroundRailLabelsAtOuterEnd(fixture)).toEqual(
+    fixture.netLabelPlacements,
+  )
+})
+
+test("does not force staggered ground pins or power labels to an outer column", () => {
+  const fixture = createFixture()
+  fixture.traces[0]!.pins[0].y += 0.2
+  expect(placeGroundRailLabelsAtOuterEnd(fixture)).toEqual(
+    fixture.netLabelPlacements,
+  )
+  fixture.traces[0]!.pins[0].y -= 0.2
+  fixture.netLabelPlacements[0]!.orientation = "y+"
+  expect(placeGroundRailLabelsAtOuterEnd(fixture)).toEqual(
+    fixture.netLabelPlacements,
+  )
+})