@tscircuit/schematic-trace-solver 0.0.158 → 0.0.160

package/tests/solvers/InlineNetLabelSolver/multi-pin-connected-components.test.ts

@@ -0,0 +1,252 @@
+import { expect, test } from "bun:test"
+import { InlineNetLabelSolver } from "lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+
+test("a multi-pin net labels routed and disconnected components inline", () => {
+  const inputProblem: InputProblem = {
+    chips: [
+      {
+        chipId: "J1",
+        center: { x: 0, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [
+          {
+            pinId: "J1.1",
+            x: -0.5,
+            y: 0.2,
+            _facingDirection: "x-",
+          },
+          {
+            pinId: "J1.2",
+            x: -0.5,
+            y: -0.2,
+            _facingDirection: "x-",
+          },
+        ],
+      },
+      {
+        chipId: "U1",
+        center: { x: 2, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [
+          {
+            pinId: "U1.1",
+            x: 2.5,
+            y: 0,
+            _facingDirection: "x+",
+          },
+        ],
+      },
+    ],
+    directConnections: [],
+    netConnections: [
+      {
+        netId: "MOTOR",
+        pinIds: ["J1.1", "J1.2", "U1.1"],
+        allowInlineNetLabel: true,
+        inlineNetLabelWidth: 0.6,
+        inlineNetLabelHeight: 0.12,
+      },
+    ],
+    availableNetLabelOrientations: { MOTOR: ["x-", "x+"] },
+  }
+  const shortConnectorTrace: SolvedTracePath = {
+    mspPairId: "J1.1-J1.2",
+    mspConnectionPairIds: ["J1.1-J1.2"],
+    dcConnNetId: "MOTOR",
+    globalConnNetId: "MOTOR",
+    userNetId: "MOTOR",
+    pins: [
+      { pinId: "J1.1", chipId: "J1", x: -0.5, y: 0.2 },
+      { pinId: "J1.2", chipId: "J1", x: -0.5, y: -0.2 },
+    ],
+    pinIds: ["J1.1", "J1.2"],
+    tracePath: [
+      { x: -0.5, y: 0.2 },
+      { x: -0.8, y: 0.2 },
+      { x: -0.8, y: -0.2 },
+      { x: -0.5, y: -0.2 },
+    ],
+  }
+
+  const solver = new InlineNetLabelSolver({
+    inputProblem,
+    traces: [shortConnectorTrace],
+    netLabelPlacements: [],
+  })
+  solver.solve()
+
+  const output = solver.getOutput()
+  expect(output.inlineNetLabelPlacements).toHaveLength(3)
+  expect(
+    output.inlineNetLabelPlacements.every(
+      (placement) => placement.stubTracePath !== undefined,
+    ),
+  ).toBe(true)
+  expect(output.traces).toHaveLength(0)
+  expect(output.netLabelPlacements).toHaveLength(0)
+})
+
+test("a short routed component is retained when replacing it would strand an intermediate pin", () => {
+  const inputProblem: InputProblem = {
+    chips: [
+      {
+        chipId: "J1",
+        center: { x: 0, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [
+          { pinId: "J1.1", x: -0.5, y: 0.2, _facingDirection: "x-" },
+          { pinId: "J1.2", x: -0.5, y: -0.2, _facingDirection: "x-" },
+        ],
+      },
+      {
+        chipId: "U1",
+        center: { x: 2, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [{ pinId: "U1.1", x: 2.5, y: 0, _facingDirection: "x+" }],
+      },
+    ],
+    directConnections: [{ pinIds: ["J1.1", "J1.2"] }],
+    netConnections: [
+      {
+        netId: "MOTOR",
+        pinIds: ["J1.1", "U1.1"],
+        allowInlineNetLabel: true,
+        inlineNetLabelWidth: 0.6,
+        inlineNetLabelHeight: 0.12,
+      },
+    ],
+    availableNetLabelOrientations: { MOTOR: ["x-", "x+"] },
+  }
+  const shortTrace: SolvedTracePath = {
+    mspPairId: "J1.1-J1.2",
+    mspConnectionPairIds: ["J1.1-J1.2"],
+    dcConnNetId: "MOTOR",
+    globalConnNetId: "MOTOR",
+    userNetId: "MOTOR",
+    pins: [
+      { pinId: "J1.1", chipId: "J1", x: -0.5, y: 0.2 },
+      { pinId: "J1.2", chipId: "J1", x: -0.5, y: -0.2 },
+    ],
+    pinIds: ["J1.1", "J1.2"],
+    tracePath: [
+      { x: -0.5, y: 0.2 },
+      { x: -0.8, y: 0.2 },
+      { x: -0.8, y: -0.2 },
+      { x: -0.5, y: -0.2 },
+    ],
+  }
+  const anchoredLabels: NetLabelPlacement[] = [
+    {
+      globalConnNetId: "MOTOR",
+      netId: "MOTOR",
+      mspConnectionPairIds: ["J1.1-J1.2"],
+      pinIds: ["J1.1", "J1.2"],
+      orientation: "x-",
+      anchorPoint: { x: -0.8, y: 0 },
+      center: { x: -1.2, y: 0 },
+      width: 0.6,
+      height: 0.12,
+    },
+    {
+      globalConnNetId: "MOTOR",
+      netId: "MOTOR",
+      mspConnectionPairIds: [],
+      pinIds: ["U1.1"],
+      orientation: "x+",
+      anchorPoint: { x: 2.5, y: 0 },
+      center: { x: 2.9, y: 0 },
+      width: 0.6,
+      height: 0.12,
+    },
+  ]
+
+  const solver = new InlineNetLabelSolver({
+    inputProblem,
+    traces: [shortTrace],
+    netLabelPlacements: anchoredLabels,
+  })
+  solver.solve()
+
+  const output = solver.getOutput()
+  expect(output.inlineNetLabelPlacements).toHaveLength(0)
+  expect(output.traces).toEqual([shortTrace])
+  expect(output.netLabelPlacements).toEqual(anchoredLabels)
+})
+
+test("a generated anchored-label connector becomes an inline terminal stub", () => {
+  const inputProblem: InputProblem = {
+    chips: [
+      {
+        chipId: "U1",
+        center: { x: 0, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [{ pinId: "U1.1", x: -0.5, y: 0, _facingDirection: "x-" }],
+      },
+      {
+        chipId: "U2",
+        center: { x: 3, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [{ pinId: "U2.1", x: 2.5, y: 0, _facingDirection: "x-" }],
+      },
+      {
+        chipId: "U3",
+        center: { x: 6, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [{ pinId: "U3.1", x: 5.5, y: 0, _facingDirection: "x-" }],
+      },
+    ],
+    directConnections: [],
+    netConnections: [
+      {
+        netId: "SIGNAL",
+        pinIds: ["U1.1", "U2.1", "U3.1"],
+        allowInlineNetLabel: true,
+        inlineNetLabelWidth: 0.6,
+        inlineNetLabelHeight: 0.12,
+      },
+    ],
+    availableNetLabelOrientations: { SIGNAL: ["x-"] },
+  }
+  const generatedLabelConnector: SolvedTracePath = {
+    mspPairId: "available-net-orientation-0-SIGNAL",
+    mspConnectionPairIds: ["available-net-orientation-0-SIGNAL"],
+    dcConnNetId: "SIGNAL",
+    globalConnNetId: "SIGNAL",
+    userNetId: "SIGNAL",
+    pins: [
+      { pinId: "U1.1", chipId: "U1", x: -0.5, y: 0 },
+      { pinId: "U1.1", chipId: "U1", x: -0.5, y: 0 },
+    ],
+    pinIds: ["U1.1"],
+    tracePath: [
+      { x: -0.5, y: 0 },
+      { x: -1.5, y: 0 },
+    ],
+  }
+
+  const solver = new InlineNetLabelSolver({
+    inputProblem,
+    traces: [generatedLabelConnector],
+    netLabelPlacements: [],
+  })
+  solver.solve()
+
+  const output = solver.getOutput()
+  expect(output.inlineNetLabelPlacements).toHaveLength(3)
+  expect(
+    output.inlineNetLabelPlacements.every(
+      (placement) => placement.stubTracePath !== undefined,
+    ),
+  ).toBe(true)
+  expect(output.traces).toHaveLength(0)
+})

package/tests/solvers/InlineNetLabelSolver/opposite-side-placement.test.ts

@@ -0,0 +1,71 @@
+import { expect, test } from "bun:test"
+import { InlineNetLabelSolver } from "lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+
+test("an inline label tries the opposite side when the preferred side is blocked", () => {
+  const inputProblem: InputProblem = {
+    chips: [
+      {
+        chipId: "U1",
+        center: { x: -2, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [{ pinId: "U1.1", x: -1.5, y: 0 }],
+      },
+      {
+        chipId: "U2",
+        center: { x: 2, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [{ pinId: "U2.1", x: 1.5, y: 0 }],
+      },
+    ],
+    directConnections: [
+      {
+        netId: "SIGNAL",
+        pinIds: ["U1.1", "U2.1"],
+        allowInlineNetLabel: true,
+        inlineNetLabelWidth: 0.8,
+        inlineNetLabelHeight: 0.12,
+      },
+    ],
+    netConnections: [],
+    textBoxes: [
+      {
+        center: { x: 0, y: 0.11 },
+        width: 3,
+        height: 0.12,
+        text: "preferred-side obstacle",
+      },
+    ],
+    availableNetLabelOrientations: { SIGNAL: ["x-", "x+"] },
+  }
+  const trace: SolvedTracePath = {
+    mspPairId: "U1.1-U2.1",
+    mspConnectionPairIds: ["U1.1-U2.1"],
+    dcConnNetId: "SIGNAL",
+    globalConnNetId: "SIGNAL",
+    userNetId: "SIGNAL",
+    pins: [
+      { pinId: "U1.1", chipId: "U1", x: -1.5, y: 0 },
+      { pinId: "U2.1", chipId: "U2", x: 1.5, y: 0 },
+    ],
+    pinIds: ["U1.1", "U2.1"],
+    tracePath: [
+      { x: -1.5, y: 0 },
+      { x: 1.5, y: 0 },
+    ],
+  }
+
+  const solver = new InlineNetLabelSolver({
+    inputProblem,
+    traces: [trace],
+    netLabelPlacements: [],
+  })
+  solver.solve()
+
+  expect(solver.inlineNetLabelPlacements).toHaveLength(1)
+  expect(solver.inlineNetLabelPlacements[0]!.side).toBe("y-")
+  expect(solver.inlineNetLabelPlacements[0]!.center.y).toBeLessThan(0)
+})

package/tests/solvers/InlineNetLabelSolver/push-anchored-net-labels-away.test.ts

@@ -11,9 +11,15 @@ test("pushes a regular endpoint label and its wick past nearby inline text", ()
       {
         chipId: "U1",
         center: { x: 0, y: 0 },
-        width: 1,
+        // The routing box includes component text, so the real pins can sit
+        // inside it. A generated connector may legitimately cross that
+        // expanded owner box on its way out from the pin.
+        width: 2,
         height: 1,
-        pins: [],
+        pins: [
+          { pinId: "U1.1", x: -0.5, y: 0.2, _facingDirection: "x-" },
+          { pinId: "U1.2", x: -0.5, y: 0, _facingDirection: "x-" },
+        ],
       },
     ],
     directConnections: [],

package/tests/solvers/InlineNetLabelSolver/push-inline-terminal-labels-away.test.ts

@@ -0,0 +1,91 @@
+import { expect, test } from "bun:test"
+import type { InlineNetLabelPlacement } from "lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver"
+import { pushInlineTerminalLabelsAwayFromAnchoredLabels } from "lib/solvers/InlineNetLabelSolver/pushInlineTerminalLabelsAwayFromAnchoredLabels"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+
+test("moves an inline terminal row outward past a retained anchored label", () => {
+  const inputProblem: InputProblem = {
+    chips: [
+      {
+        chipId: "J1",
+        center: { x: 0, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [
+          { pinId: "J1.A0", x: -0.5, y: 0.2, _facingDirection: "x-" },
+          { pinId: "J1.SCLK", x: -0.5, y: 0, _facingDirection: "x-" },
+          { pinId: "J1.MISO", x: -0.5, y: -0.2, _facingDirection: "x-" },
+        ],
+      },
+    ],
+    directConnections: [],
+    netConnections: [],
+    availableNetLabelOrientations: {},
+  }
+  const anchoredNetLabelPlacements: NetLabelPlacement[] = [
+    {
+      globalConnNetId: "A0",
+      netId: "A0",
+      mspConnectionPairIds: [],
+      pinIds: ["J1.A0"],
+      orientation: "x-",
+      anchorPoint: { x: -0.5, y: 0.2 },
+      center: { x: -0.75, y: 0.2 },
+      width: 0.5,
+      height: 0.2,
+    },
+  ]
+  const inlineNetLabelPlacements: InlineNetLabelPlacement[] = [
+    {
+      globalConnNetId: "SCLK",
+      netId: "SCLK",
+      pinIds: ["J1.SCLK"],
+      stubTracePath: [
+        { x: -0.5, y: 0 },
+        { x: -1.1, y: 0 },
+      ],
+      axis: "x",
+      anchorPoint: { x: -0.8, y: 0 },
+      center: { x: -0.8, y: 0.11 },
+      width: 0.4,
+      height: 0.12,
+      side: "y+",
+    },
+    {
+      globalConnNetId: "MISO",
+      netId: "MISO",
+      pinIds: ["J1.MISO"],
+      stubTracePath: [
+        { x: -0.5, y: -0.2 },
+        { x: -1.1, y: -0.2 },
+      ],
+      axis: "x",
+      anchorPoint: { x: -0.8, y: -0.2 },
+      center: { x: -0.8, y: -0.09 },
+      width: 0.4,
+      height: 0.12,
+      side: "y+",
+    },
+  ]
+
+  const output = pushInlineTerminalLabelsAwayFromAnchoredLabels({
+    inputProblem,
+    traces: [],
+    anchoredNetLabelPlacements,
+    inlineNetLabelPlacements,
+  })
+
+  expect(output.movedGroupCount).toBe(1)
+  expect(output.inlineNetLabelPlacements[0]!.center.x).toBeLessThan(-0.8)
+  expect(output.inlineNetLabelPlacements[1]!.center.x).toBe(
+    output.inlineNetLabelPlacements[0]!.center.x,
+  )
+  expect(output.inlineNetLabelPlacements[0]!.stubTracePath![0]).toEqual({
+    x: -0.5,
+    y: 0,
+  })
+  expect(output.inlineNetLabelPlacements[0]!.stubTracePath![1]!.x).toBeLessThan(
+    -1.1,
+  )
+})

package/tests/solvers/InlineNetLabelSolver/two-pin-terminal-stubs-atomic.test.ts

@@ -36,7 +36,13 @@ test("two-pin terminal stubs fall back atomically when one endpoint is obstructe
         center: { x: -0.85, y: 0.11 },
         width: 1.1,
         height: 0.12,
-        text: "obstacle",
+        text: "upper obstacle",
+      },
+      {
+        center: { x: -0.85, y: -0.11 },
+        width: 1.1,
+        height: 0.12,
+        text: "lower obstacle",
       },
     ],
     availableNetLabelOrientations: { NET_SIGNAL: ["x-", "x+"] },

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