@tscircuit/schematic-trace-solver 0.0.159 → 0.0.160

package/tests/bug-reports/bug-report-20260826T072956Z/bug-report-20260826T072956Z.test.ts

@@ -1,12 +1,77 @@
 import { expect, test } from "bun:test"
+import { estimateInlineNetLabelWidth } from "lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver"
 import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import type { InputProblem } from "lib/types/InputProblem"
 import inputProblem from "./bug-report-20260826T072956Z.json"
 import "tests/fixtures/matcher"
 
+const multiPinSignalNetIds = [
+  "ISNS_A",
+  "ISNS_B",
+  "ISNS_C",
+  "MOT_A",
+  "MOT_B",
+  "MOT_C",
+  "S1_N",
+  "S1_P",
+  "S2_N",
+  "S2_P",
+  "S3_N",
+  "S3_P",
+  "SL_A",
+  "SL_B",
+  "SL_C",
+]
+
 test("bug-report-20260826T072956Z", () => {
-  const solver = new SchematicTracePipelineSolver(inputProblem as any)
+  const problem = structuredClone(inputProblem) as unknown as InputProblem
+  for (const connection of problem.netConnections) {
+    if (!multiPinSignalNetIds.includes(connection.netId)) continue
+    connection.allowInlineNetLabel = true
+    connection.inlineNetLabelHeight = 0.12
+    connection.inlineNetLabelWidth = estimateInlineNetLabelWidth(
+      connection.netId,
+      connection.inlineNetLabelHeight,
+    )
+  }
+
+  const solver = new SchematicTracePipelineSolver(problem, {
+    hideRatsNet: true,
+  })
 
   solver.solve()
 
+  const output = solver.inlineNetLabelSolver!.getOutput()
+  const expectedInlineNetIds = ["GH_B", ...multiPinSignalNetIds]
+  expect(
+    new Set(
+      output.inlineNetLabelPlacements
+        .filter((placement) =>
+          expectedInlineNetIds.includes(placement.netId ?? ""),
+        )
+        .map((placement) => placement.netId),
+    ),
+  ).toEqual(new Set(expectedInlineNetIds))
+  expect(
+    output.netLabelPlacements.filter((placement) =>
+      expectedInlineNetIds.includes(placement.netId ?? ""),
+    ),
+  ).toHaveLength(0)
+  expect(
+    output.inlineNetLabelPlacements.some(
+      (placement) => placement.netId === "GH_B" && placement.side === "y-",
+    ),
+  ).toBe(true)
+  for (const supersededConnectorTraceId of [
+    "schematic_port_152-schematic_port_150",
+    "schematic_port_151-schematic_port_148",
+    "schematic_port_149-schematic_port_147",
+  ]) {
+    expect(
+      output.traces.some(
+        (trace) => trace.mspPairId === supersededConnectorTraceId,
+      ),
+    ).toBe(false)
+  }
   expect(solver).toMatchSolverSnapshot(import.meta.path)
 })

package/tests/repros/repro-usb-power-vbus-label-detour.test.ts

@@ -37,6 +37,13 @@ test("routes the usb power vbus connection without a label detour", () => {
         label.pinIds.includes("schematic_port_54") &&
         label.pinIds.includes("schematic_port_162"),
     )
+  const inlineOutput = solver.inlineNetLabelSolver!.getOutput()
+  const usbHighSpeedInlineLabels = inlineOutput.inlineNetLabelPlacements.filter(
+    (placement) => placement.netId?.startsWith("USB_HS_"),
+  )
+  const usbHighSpeedAnchoredLabels = inlineOutput.netLabelPlacements.filter(
+    (placement) => placement.netId?.startsWith("USB_HS_"),
+  )
 
   expect(gndLabel?.orientation).toBe("y-")
   expect(gndLabel?.anchorPoint.x).toBeCloseTo(-2.34)
@@ -53,5 +60,12 @@ test("routes the usb power vbus connection without a label detour", () => {
     { x: 12.8, y: -5.8 },
     { x: 13, y: -5.8 },
   ])
+  // The available inline side of USB_HS_DM overlaps the retained USB_HS_DP
+  // tag. Keep both differential-pair nets anchored instead of producing a
+  // mixed, overlapping representation.
+  expect(usbHighSpeedInlineLabels).toHaveLength(0)
+  expect(
+    usbHighSpeedAnchoredLabels.map((placement) => placement.netId).sort(),
+  ).toEqual(["USB_HS_DM", "USB_HS_DM", "USB_HS_DP", "USB_HS_DP"])
   expect(solver).toMatchSolverSnapshot(import.meta.path)
 })

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+"] },