@tscircuit/schematic-trace-solver 0.0.187 → 0.0.189

package/tests/repros/assets/rp2040-robot-controller.input.json

@@ -0,0 +1,349 @@
+{
+  "chips": [
+    {
+      "chipId": "schematic_component_39",
+      "center": {
+        "x": -30,
+        "y": 0
+      },
+      "width": 2.1000000000000014,
+      "height": 1,
+      "pins": [
+        {
+          "pinId": "schematic_port_159",
+          "x": -31.05,
+          "y": 0.4
+        },
+        {
+          "pinId": "schematic_port_160",
+          "x": -31.05,
+          "y": 0.2
+        },
+        {
+          "pinId": "schematic_port_161",
+          "x": -31.05,
+          "y": 0
+        },
+        {
+          "pinId": "schematic_port_162",
+          "x": -31.05,
+          "y": -0.20000000000000007
+        },
+        {
+          "pinId": "schematic_port_163",
+          "x": -31.05,
+          "y": -0.4
+        },
+        {
+          "pinId": "schematic_port_164",
+          "x": -28.95,
+          "y": -0.30000000000000004
+        },
+        {
+          "pinId": "schematic_port_165",
+          "x": -28.95,
+          "y": -0.10000000000000003
+        },
+        {
+          "pinId": "schematic_port_166",
+          "x": -28.95,
+          "y": 0.09999999999999998
+        },
+        {
+          "pinId": "schematic_port_167",
+          "x": -28.95,
+          "y": 0.30000000000000004
+        }
+      ],
+      "sectionId": "Motors"
+    },
+    {
+      "chipId": "schematic_component_40",
+      "center": {
+        "x": -30,
+        "y": 4
+      },
+      "width": 1.2000000000000028,
+      "height": 0.5999999999999996,
+      "pins": [
+        {
+          "pinId": "schematic_port_168",
+          "x": -29.4,
+          "y": 4.1
+        },
+        {
+          "pinId": "schematic_port_169",
+          "x": -29.4,
+          "y": 3.9
+        }
+      ],
+      "sectionId": "Motors"
+    },
+    {
+      "chipId": "schematic_component_41",
+      "center": {
+        "x": -32.8675,
+        "y": -4
+      },
+      "width": 1.1650000000000063,
+      "height": 0.7600000000000011,
+      "pins": [
+        {
+          "pinId": "schematic_port_170",
+          "x": -33,
+          "y": -3.619999999999999,
+          "_facingDirection": "y+"
+        },
+        {
+          "pinId": "schematic_port_171",
+          "x": -33,
+          "y": -4.380000000000001,
+          "_facingDirection": "y-"
+        }
+      ],
+      "sectionId": "Motors"
+    },
+    {
+      "chipId": "schematic_component_42",
+      "center": {
+        "x": -29.8075,
+        "y": -4
+      },
+      "width": 1.2849999999999966,
+      "height": 0.7600000000000011,
+      "pins": [
+        {
+          "pinId": "schematic_port_172",
+          "x": -30,
+          "y": -3.619999999999999,
+          "_facingDirection": "y+"
+        },
+        {
+          "pinId": "schematic_port_173",
+          "x": -30,
+          "y": -4.380000000000001,
+          "_facingDirection": "y-"
+        }
+      ],
+      "sectionId": "Motors"
+    }
+  ],
+  "directConnections": [],
+  "netConnections": [
+    {
+      "netId": "V3V3",
+      "netLabelWidth": 0.42,
+      "netLabelHeight": 0.6,
+      "pinIds": [
+        "schematic_port_166",
+        "schematic_port_172"
+      ]
+    },
+    {
+      "netId": "GND",
+      "netLabelWidth": 0.42,
+      "netLabelHeight": 0.48,
+      "pinIds": [
+        "schematic_port_162",
+        "schematic_port_167",
+        "schematic_port_171",
+        "schematic_port_173"
+      ]
+    },
+    {
+      "netId": "MA1",
+      "netLabelWidth": 0.48,
+      "pinIds": [
+        "schematic_port_164"
+      ]
+    },
+    {
+      "netId": "MA2",
+      "netLabelWidth": 0.48,
+      "pinIds": [
+        "schematic_port_163"
+      ]
+    },
+    {
+      "netId": "MOTOR_EN",
+      "netLabelWidth": 1.08,
+      "pinIds": [
+        "schematic_port_165"
+      ]
+    },
+    {
+      "netId": "VM",
+      "netLabelWidth": 0.42,
+      "netLabelHeight": 0.36,
+      "pinIds": [
+        "schematic_port_159",
+        "schematic_port_170"
+      ]
+    },
+    {
+      "netId": "OUT0A",
+      "netLabelWidth": 0.72,
+      "pinIds": [
+        "schematic_port_160",
+        "schematic_port_168"
+      ]
+    },
+    {
+      "netId": "OUT0B",
+      "netLabelWidth": 0.72,
+      "pinIds": [
+        "schematic_port_161",
+        "schematic_port_169"
+      ]
+    }
+  ],
+  "textBoxes": [
+    {
+      "chipId": "schematic_component_39",
+      "center": {
+        "x": -29.99,
+        "y": -0.63
+      },
+      "width": 1.3200000000000003,
+      "height": 0.17999999999999994,
+      "text": "DRV8837DSGR"
+    },
+    {
+      "chipId": "schematic_component_39",
+      "center": {
+        "x": -30.409999999999997,
+        "y": 0.615
+      },
+      "width": 0.5999999999999979,
+      "height": 0.25,
+      "text": "U_M0"
+    },
+    {
+      "chipId": "schematic_component_40",
+      "center": {
+        "x": -29.96,
+        "y": 4.414999999999999
+      },
+      "width": 0.5999999999999979,
+      "height": 0.2499999999999991,
+      "text": "J_M0"
+    }
+  ],
+  "availableNetLabelOrientations": {
+    "VM": [
+      "y+"
+    ],
+    "VSERVO": [
+      "y+"
+    ],
+    "V3V3": [
+      "y+"
+    ],
+    "VBUS": [
+      "y+"
+    ],
+    "GND": [
+      "y-"
+    ],
+    "MA1": [
+      "x-",
+      "x+"
+    ],
+    "MA2": [
+      "x-",
+      "x+"
+    ],
+    "MB1": [
+      "x-",
+      "x+"
+    ],
+    "MB2": [
+      "x-",
+      "x+"
+    ],
+    "EA": [
+      "x-",
+      "x+"
+    ],
+    "EB": [
+      "x-",
+      "x+"
+    ],
+    "EC": [
+      "x-",
+      "x+"
+    ],
+    "ED": [
+      "x-",
+      "x+"
+    ],
+    "SDA": [
+      "x-",
+      "x+"
+    ],
+    "SCL": [
+      "x-",
+      "x+"
+    ],
+    "SERVO1": [
+      "x-",
+      "x+"
+    ],
+    "SERVO2": [
+      "x-",
+      "x+"
+    ],
+    "SERVO3": [
+      "x-",
+      "x+"
+    ],
+    "MOTOR_EN": [
+      "x-",
+      "x+"
+    ],
+    "IMU_INT": [
+      "x-",
+      "x+"
+    ],
+    "GPIO15": [
+      "x-",
+      "x+"
+    ],
+    "GPIO16": [
+      "x-",
+      "x+"
+    ],
+    "GPIO17": [
+      "x-",
+      "x+"
+    ],
+    "OUT0A": [
+      "x-",
+      "x+"
+    ],
+    "OUT0B": [
+      "x-",
+      "x+"
+    ],
+    "OUT1A": [
+      "x-",
+      "x+"
+    ],
+    "OUT1B": [
+      "x-",
+      "x+"
+    ],
+    "VSYS": [
+      "y+"
+    ],
+    "ADC_VREF": [
+      "x-",
+      "x+"
+    ],
+    "V1V1": [
+      "y+"
+    ]
+  },
+  "maxMspPairDistance": 2.4,
+  "_hideRatsNet": false
+}

package/tests/repros/repro-battery-management-bq24073.test.ts

@@ -71,7 +71,19 @@ test("repro BatteryManagement_BQ24073 schematic traces", () => {
     )
     .sort((first, second) => first.anchorPoint.y - second.anchorPoint.y)[0]!
 
-  expect(solver.inlineNetLabelSolver!.stats.pushedAnchoredNetLabelCount).toBe(1)
+  // An inline label farther down the same column must not pull this ground
+  // label off its existing trace and create an unnecessary dangling branch.
+  const upperGroundLabel = output.netLabelPlacements.find(
+    (label) =>
+      label.pinIds.includes("schematic_port_1") &&
+      label.pinIds.includes("schematic_port_8"),
+  )!
+  expect(upperGroundLabel.anchorPoint.y).toBeCloseTo(0.1)
+  expect(
+    output.traces.some(
+      (trace) => trace.mspPairId === "inline-net-label-clearance-0-GND",
+    ),
+  ).toBe(false)
   expect(bottomGroundLabel.anchorPoint.x).toBeCloseTo(
     EXPECTED_BOTTOM_GROUND_LABEL_X,
   )

package/tests/repros/repro-hub-usb-sheet.test.ts

@@ -1,4 +1,5 @@
 import { expect, test } from "bun:test"
+import { getOutputLabelCollisions } from "lib/solvers/InlineNetLabelSolver/getOutputLabelCollisions"
 import { tracePathContainsPoint } from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
 import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
 import { isVertical } from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
@@ -52,5 +53,29 @@ test("repro hub USB sheet schematic trace routing", () => {
   expect(sameChipGroundLabel.orientation).toBe("y-")
   expect(sameChipGroundLabel.anchorPoint.x).toBeCloseTo(verticalHostPoint.x)
   expect(tracesAtSameChipGroundLabel).toHaveLength(1)
+  const txLabel = solver
+    .inlineNetLabelSolver!.getOutput()
+    .inlineNetLabelPlacements.find((label) =>
+      label.pinIds.includes("schematic_port_434"),
+    )
+  expect(txLabel?.axis).toBe("y")
+  expect(txLabel?.side).toBe("x+")
+  expect(
+    solver
+      .inlineNetLabelSolver!.getOutput()
+      .netLabelPlacements.some((label) =>
+        label.pinIds.includes("schematic_port_434"),
+      ),
+  ).toBe(false)
+  expect(
+    [
+      ...getOutputLabelCollisions(solver.inlineNetLabelSolver!.getOutput()),
+    ].filter(
+      (collision) =>
+        collision.kind === "trace-label" &&
+        collision.trace.kind === "routed" &&
+        collision.trace.id === "schematic_port_375-schematic_port_373",
+    ),
+  ).toEqual([])
   expect(solver).toMatchSolverSnapshot(import.meta.path)
 })

package/tests/repros/repro-robot-controller-imu-tof.test.ts

@@ -0,0 +1,83 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import {
+  EPS,
+  tracePathContainsPoint,
+} from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
+import type { InputProblem } from "lib/types/InputProblem"
+import { convertSolverOutputToCircuitJson } from "tests/fixtures/convertSolverOutputToCircuitJson"
+import "tests/fixtures/matcher"
+import inputProblem from "./assets/repro-robot-controller-imu-tof.input.json"
+
+// IMU/ToF section from ROVER, captured with @tscircuit/core 0.0.1861.
+// Other sections are removed; retained placement and routing options are unchanged.
+test("repro robot controller IMU and ToF trace routing", async () => {
+  expect([
+    ...new Set(inputProblem.chips.map((chip) => chip.sectionId)),
+  ]).toEqual(["07_IMU_AND_TOF"])
+
+  const solver = new SchematicTracePipelineSolver(
+    inputProblem as InputProblem,
+    { hideRatsNet: true },
+  )
+
+  solver.solve()
+
+  expect(solver.solved).toBe(true)
+  expect(solver.failed).toBe(false)
+  const sclConnection = inputProblem.netConnections.find(
+    (connection) => connection.netId === "I2C_SCL",
+  )!
+  const sclTrace = solver
+    .netLabelToTraceSolver!.getOutput()
+    .traces.find(
+      (trace) =>
+        trace.pinIds.includes("schematic_port_275") &&
+        trace.pinIds.includes("schematic_port_288"),
+    )!
+  const connectedSclPins = inputProblem.chips.flatMap((chip) =>
+    chip.pins.filter(
+      (pin) =>
+        sclConnection.pinIds.includes(pin.pinId) &&
+        tracePathContainsPoint(sclTrace.tracePath, pin),
+    ),
+  )
+  expect(connectedSclPins).toHaveLength(2)
+  const sdaLabel = solver
+    .inlineNetLabelSolver!.getOutput()
+    .inlineNetLabelPlacements.find((label) =>
+      label.pinIds.includes("schematic_port_276"),
+    )!
+  expect(sdaLabel.side).toBe("y+")
+  expect(sdaLabel.center.y).toBeGreaterThan(sdaLabel.anchorPoint.y)
+  const output = solver.netLabelToTraceSolver!.getOutput()
+  const connectorIds =
+    solver.inlineNetLabelSolver!.getOutput().netLabelConnectorTraceIds!
+  const connectorTraces = output.traces.filter((trace) =>
+    connectorIds.has(trace.mspPairId),
+  )
+  expect(connectorTraces).toHaveLength(4)
+  for (const trace of connectorTraces) {
+    const endpoint = trace.tracePath.at(-1)!
+    expect(
+      output.netLabelPlacements.some(
+        (label) =>
+          label.globalConnNetId === trace.globalConnNetId &&
+          Math.abs(label.anchorPoint.x - endpoint.x) < EPS &&
+          Math.abs(label.anchorPoint.y - endpoint.y) < EPS,
+      ),
+    ).toBe(true)
+  }
+  const circuitJson = convertSolverOutputToCircuitJson(solver)
+  expect(
+    circuitJson
+      .filter((element) => element.type === "schematic_text")
+      .map((element) => element.text),
+  ).toContain("I2C_SDA")
+  expect(
+    circuitJson
+      .filter((element) => element.type === "schematic_net_label")
+      .map((element) => element.text),
+  ).toContain("V3V3_IMU")
+  await expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

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

@@ -1,3 +1,4 @@
+import { getOutputLabelCollisions } from "lib/solvers/InlineNetLabelSolver/getOutputLabelCollisions"
 import { expect, test } from "bun:test"
 import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
 import type { InputProblem } from "lib/types/InputProblem"
@@ -6,7 +7,7 @@ import inputProblemJson from "./assets/repro-usb-power-vbus-label-detour.input.j
 
 const VBUS_PIN_IDS = new Set(["schematic_port_224", "schematic_port_226"])
 
-test("routes the usb power vbus connection without a label detour", () => {
+test("keeps the compact VBUS route and USB labels clear of neighboring wires", () => {
   const inputProblem: InputProblem = JSON.parse(
     JSON.stringify(inputProblemJson),
   )
@@ -14,11 +15,13 @@ test("routes the usb power vbus connection without a label detour", () => {
 
   solver.solve()
 
-  const vbusTrace = solver.sameNetJunctionAlignmentSolver!.outputTraces.find(
-    (trace) =>
-      trace.pins.length === VBUS_PIN_IDS.size &&
-      trace.pins.every((pin) => VBUS_PIN_IDS.has(pin.pinId)),
-  )
+  const vbusTrace = solver
+    .inlineNetLabelSolver!.getOutput()
+    .traces.find(
+      (trace) =>
+        trace.pins.length === VBUS_PIN_IDS.size &&
+        trace.pins.every((pin) => VBUS_PIN_IDS.has(pin.pinId)),
+    )
   const gndLabel =
     solver.availableNetOrientationSolver!.outputNetLabelPlacements.find(
       (label) =>
@@ -27,7 +30,9 @@ test("routes the usb power vbus connection without a label detour", () => {
     )
   const gndLabelConnector = solver.availableNetOrientationSolver!.traces.find(
     (trace) =>
-      trace.mspPairId.startsWith("available-net-orientation-") &&
+      solver.availableNetOrientationSolver!.netLabelConnectorTraceIds.has(
+        trace.mspPairId,
+      ) &&
       trace.pinIds.includes("schematic_port_37") &&
       trace.pinIds.includes("schematic_port_46"),
   )
@@ -60,12 +65,53 @@ 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).toEqual([])
+  expect(usbHighSpeedInlineLabels).toHaveLength(4)
+  expect(usbHighSpeedInlineLabels.every((label) => label.side === "y+")).toBe(
+    true,
+  )
+  const dm = usbHighSpeedInlineLabels.find((label) =>
+    label.pinIds.includes("schematic_port_191"),
+  )!
+  const vbusConnector = inlineOutput.traces.find((trace) =>
+    trace.pinIds.includes("schematic_port_192"),
+  )!
+  expect(dm.center.y - dm.height / 2).toBeGreaterThan(dm.stubTracePath![0].y)
+  expect(dm.center.y + dm.height / 2).toBeLessThan(
+    vbusConnector.tracePath[0]!.y,
+  )
+  for (const pinId of ["schematic_port_188", "schematic_port_190"]) {
+    expect(
+      inputProblem.directConnections
+        .filter((connection) => connection.pinIds.includes(pinId))
+        .every((connection) => !connection.allowInlineNetLabel),
+    ).toBe(true)
+    expect(
+      inlineOutput.netLabelPlacements.some((label) =>
+        label.pinIds.includes(pinId),
+      ),
+    ).toBe(true)
+  }
   expect(
-    usbHighSpeedAnchoredLabels.map((placement) => placement.netId).sort(),
-  ).toEqual(["USB_HS_DM", "USB_HS_DM", "USB_HS_DP", "USB_HS_DP"])
+    getOutputLabelCollisions(inlineOutput).filter((collision) => {
+      const labels =
+        collision.kind === "label-label" ? collision.labels : [collision.label]
+      return labels.some((label) =>
+        usbHighSpeedInlineLabels.some((usb) => usb === label),
+      )
+    }),
+  ).toEqual([])
+  for (const pinId of [
+    "schematic_port_83",
+    "schematic_port_84",
+    "schematic_port_191",
+    "schematic_port_193",
+  ]) {
+    expect(
+      [...usbHighSpeedInlineLabels, ...usbHighSpeedAnchoredLabels].filter(
+        (label) => label.pinIds.includes(pinId),
+      ),
+    ).toHaveLength(1)
+  }
   expect(solver).toMatchSolverSnapshot(import.meta.path)
 })

package/tests/repros/rp2040-robot-controller-disconnected-gnd.test.ts

@@ -0,0 +1,59 @@
+import { expect, test } from "bun:test"
+import { convertCircuitJsonToSchematicSvg } from "circuit-to-svg"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import { tracePathContainsPoint } from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
+import type { InputProblem } from "lib/types/InputProblem"
+import { convertSolverOutputToCircuitJson } from "tests/fixtures/convertSolverOutputToCircuitJson"
+import { readFileSync } from "node:fs"
+
+const inputProblem: InputProblem = JSON.parse(
+  readFileSync(
+    new URL("./assets/rp2040-robot-controller.input.json", import.meta.url),
+    "utf8",
+  ),
+)
+
+// Captured from core rendering https://tscircuit.com/mohan-bee/rp2040-robot-controller.
+// U_M0 pin4 (GND) and pin9 (EP) share a generated ground-label connector.
+test("rp2040 robot controller keeps GND connected after junction alignment", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem)
+  solver.solve()
+  expect(solver.solved).toBe(true)
+  expect(solver.failed).toBe(false)
+
+  const before = solver.netLabelNetLabelCollisionSolver!
+  const after = solver.inlineNetLabelSolver!.getOutput()
+  const groundLabel = after.netLabelPlacements.find((label) =>
+    label.pinIds.includes("schematic_port_162"),
+  )!
+  const beforeConnector = before.traces.find(
+    (trace) =>
+      solver.availableNetOrientationSolver!.netLabelConnectorTraceIds.has(
+        trace.mspPairId,
+      ) && trace.pinIds.includes("schematic_port_162"),
+  )!
+  const afterConnector = after.traces.find(
+    (trace) => trace.mspPairId === beforeConnector.mspPairId,
+  )!
+  const beforeGroundLabel = before
+    .getOutput()
+    .netLabelPlacements.find((label) =>
+      label.pinIds.includes("schematic_port_162"),
+    )!
+  expect(
+    tracePathContainsPoint(
+      beforeConnector.tracePath,
+      beforeGroundLabel.anchorPoint,
+    ),
+  ).toBe(true)
+  expect(
+    tracePathContainsPoint(afterConnector.tracePath, groundLabel.anchorPoint),
+  ).toBe(true)
+
+  expect(
+    convertCircuitJsonToSchematicSvg(convertSolverOutputToCircuitJson(solver), {
+      width: 1000,
+      height: 800,
+    }).replace(/[ \t]+$/gm, ""),
+  ).toMatchSvgSnapshot(import.meta.path)
+})

package/tests/solvers/InlineNetLabelSolver/get-anchored-net-label-rendered-bounds.test.ts

@@ -16,6 +16,30 @@ const createPlacement = (
   ...overrides,
 })
 
+test("orients named vertical tags while preserving width-only placeholders", () => {
+  for (const orientation of ["y+", "y-"] as const) {
+    const placement = createPlacement({
+      orientation,
+      width: 1.2,
+      height: 0.42,
+      center: { x: 2, y: 3 },
+    })
+    const placeholderBounds = getAnchoredNetLabelRenderedBounds(placement)
+    expect(placeholderBounds.maxX - placeholderBounds.minX).toBeCloseTo(1.2)
+    expect(placeholderBounds.maxY - placeholderBounds.minY).toBeCloseTo(0.42)
+
+    const namedBounds = getAnchoredNetLabelRenderedBounds({
+      ...placement,
+      netLabelText: "SUPPLY",
+    })
+    expect(namedBounds.minX).toBeCloseTo(1.79)
+    expect(namedBounds.maxX).toBeCloseTo(2.21)
+    expect(namedBounds.maxY - namedBounds.minY).toBeCloseTo(1.2)
+    if (orientation === "y+") expect(namedBounds.minY).toBeCloseTo(3)
+    else expect(namedBounds.maxY).toBeCloseTo(3)
+  }
+})
+
 test("uses the horizontal renderer envelope for x-facing labels", () => {
   const horizontalBounds = getAnchoredNetLabelRenderedBounds(
     createPlacement({}),