@tscircuit/schematic-trace-solver 0.0.188 → 0.0.190

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-repeated-power-rail-junctions.test.ts

@@ -0,0 +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-repeated-power-rail-junctions.input.json"
+
+// Reduced from the DS1 area of a Core clock schematic. Three repeated
+// controller/decoupling pairs are the minimum input that preserves the local
+// rectangular branches and multiple junctions beside U_DS1 pins 2 and 3.
+test("collapses repeated junctions around adjacent power rails", () => {
+  const solver = new SchematicTracePipelineSolver(
+    inputProblem as unknown as InputProblem,
+  )
+
+  solver.solve()
+
+  expect(solver.solved).toBe(true)
+  expect(solver.sameNetJunctionAlignmentSolver?.stats.collapsedCycleCount).toBe(
+    2,
+  )
+  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/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({}),

package/tests/solvers/SameNetJunctionAlignmentSolver/collapse-same-net-cycles.test.ts

@@ -87,6 +87,36 @@ test("collapses a same-net cycle between a shared pin and crossing", () => {
   expect(result.netLabelPlacements[0]?.anchorPoint).toEqual({ x: 0, y: 0 })
 })
 
+test("collapses a cycle within one same-net trace", () => {
+  const traces = [
+    createTraceFixture({
+      mspPairId: "self-crossing-trace",
+      pinIds: ["start", "end"],
+      tracePath: [
+        { x: 0, y: 4 },
+        { x: 0, y: 0 },
+        { x: 4, y: 0 },
+        { x: 4, y: 2 },
+        { x: 1, y: 2 },
+        { x: 1, y: -1 },
+      ],
+    }),
+  ]
+
+  const result = collapseSameNetCycles({
+    traces,
+    netLabelPlacements: [],
+  })
+
+  expect(result.collapsedCycleCount).toBe(1)
+  expect(result.traces[0]?.tracePath).toEqual([
+    { x: 0, y: 4 },
+    { x: 0, y: 0 },
+    { x: 1, y: 0 },
+    { x: 1, y: -1 },
+  ])
+})
+
 test("keeps a valid shared same-net branch", () => {
   const traces = [
     createTraceFixture({

package/tests/solvers/TraceCleanupSolver/perpendicular-detours-preserve-endpoints.test.ts

@@ -0,0 +1,60 @@
+import { expect, test } from "bun:test"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { generatePerpendicularTraceDetours } from "lib/solvers/TraceCleanupSolver/sub-solver/generateLShapeRerouteCandidates"
+
+test("perpendicular detours keep both terminals for horizontal and vertical crossings", () => {
+  const crossings = [
+    {
+      path: [
+        { x: 0, y: 0 },
+        { x: 4, y: 0 },
+      ],
+      obstacleStart: { x: 2, y: -1 },
+      obstacleEnd: { x: 2, y: 1 },
+    },
+    {
+      path: [
+        { x: 0, y: 0 },
+        { x: 0, y: 4 },
+      ],
+      obstacleStart: { x: -1, y: 2 },
+      obstacleEnd: { x: 1, y: 2 },
+    },
+  ]
+
+  for (const crossing of crossings) {
+    const start = crossing.path[0]!
+    const end = crossing.path[1]!
+    const trace: SolvedTracePath = {
+      mspPairId: "signal",
+      dcConnNetId: "signal",
+      globalConnNetId: "signal",
+      pins: [
+        { ...start, pinId: "source", chipId: "source-chip" },
+        { ...end, pinId: "destination", chipId: "destination-chip" },
+      ],
+      pinIds: ["source", "destination"],
+      mspConnectionPairIds: ["signal"],
+      tracePath: crossing.path,
+    }
+    const candidates = generatePerpendicularTraceDetours({
+      trace,
+      segmentIndex: 0,
+      obstacleStart: crossing.obstacleStart,
+      obstacleEnd: crossing.obstacleEnd,
+      chipBounds: [],
+      clearance: 0.1,
+    })
+
+    expect(candidates).toHaveLength(4)
+    for (const candidate of candidates) {
+      expect(candidate.path[0]).toEqual(start)
+      expect(candidate.path.at(-1)).toEqual(end)
+      for (let index = 1; index < candidate.path.length; index++) {
+        const previous = candidate.path[index - 1]!
+        const current = candidate.path[index]!
+        expect(previous.x === current.x || previous.y === current.y).toBe(true)
+      }
+    }
+  }
+})