@tscircuit/schematic-trace-solver 0.0.173 → 0.0.175

package/tests/repros/repro-trellis-core-gnd-net-label-overlap.test.ts

@@ -0,0 +1,73 @@
+import { expect, test } from "bun:test"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import "tests/fixtures/matcher"
+import inputProblem from "./assets/repro-trellis-core-gnd-net-label-overlap.input.json"
+
+const getLabelBounds = (label: NetLabelPlacement) => ({
+  minX: label.center.x - label.width / 2,
+  maxX: label.center.x + label.width / 2,
+  minY: label.center.y - label.height / 2,
+  maxY: label.center.y + label.height / 2,
+})
+
+const getOverlapArea = (
+  first: ReturnType<typeof getLabelBounds>,
+  second: ReturnType<typeof getLabelBounds>,
+) => {
+  const width =
+    Math.min(first.maxX, second.maxX) - Math.max(first.minX, second.minX)
+  const height =
+    Math.min(first.maxY, second.maxY) - Math.max(first.minY, second.minY)
+
+  return width > 0 && height > 0 ? width * height : 0
+}
+
+// Captured from @tscircuit/core repro175. The dense T113 analog-pin column
+// forces Net_U3F_VRA2 to fall back from its requested y+ rail orientation to
+// the pin-facing x+ orientation. The fallback reports a 0.42 x 0.20 label box
+// even though the rendered text is 1.56 wide. The pipeline then finishes with
+// the U3-side GND label overlapping both VRA2 and P1V8.
+//
+// This test pins the current buggy output. A fix should change the two positive
+// overlap assertions to expect 0 and update the visual snapshot.
+test("repro Trellis Core GND label overlaps VRA2 and P1V8", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem as InputProblem)
+
+  solver.solve()
+
+  const labels =
+    solver.netLabelNetLabelCollisionSolver!.getOutput().netLabelPlacements
+  const vra2Label = labels.find(
+    (label) =>
+      label.netId === "Net_U3F_VRA2" &&
+      label.pinIds.includes("schematic_port_1"),
+  )!
+  const p1v8Label = labels.find(
+    (label) =>
+      label.netId === "P1V8" && label.pinIds.includes("schematic_port_0"),
+  )!
+  const groundLabel = labels.find(
+    (label) =>
+      label.netId === "GND" &&
+      label.pinIds.includes("schematic_port_2") &&
+      label.pinIds.includes("schematic_port_4"),
+  )!
+
+  expect(vra2Label).toBeDefined()
+  expect(p1v8Label).toBeDefined()
+  expect(groundLabel).toBeDefined()
+  expect(vra2Label).toMatchObject({
+    orientation: "x+",
+    width: 0.42,
+    height: 0.2,
+  })
+  expect(
+    getOverlapArea(getLabelBounds(groundLabel), getLabelBounds(vra2Label)),
+  ).toBeGreaterThan(0)
+  expect(
+    getOverlapArea(getLabelBounds(groundLabel), getLabelBounds(p1v8Label)),
+  ).toBeGreaterThan(0)
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/repros/repro-wireless-mouse-charger-section.test.ts

@@ -0,0 +1,16 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import inputProblem from "./assets/repro-wireless-mouse-charger-section.input.json"
+import "tests/fixtures/matcher"
+
+// Generated from @tscircuit/core 0.0.1817 at commit 45888ed648781adfd34e7078c4d4b336133cbbe9.
+// The circuit reproduces the wireless mouse's MCP73831 charger, charge LED
+// loop, programming resistor, VBAT capacitor, and protected battery connector.
+// The fixture is the solverParams payload emitted by core's solver:started event.
+test("repro wireless mouse charger section", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem as any)
+
+  solver.solve()
+
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/solvers/InlineNetLabelSolver/restore-reroutes-around-superseded-labels.test.ts

@@ -0,0 +1,186 @@
+import { expect, test } from "bun:test"
+import type { InlineNetLabelPlacement } from "lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver"
+import { restoreReroutesAroundSupersededLabels } from "lib/solvers/InlineNetLabelSolver/restoreReroutesAroundSupersededLabels"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { CompletedTraceReroute } from "lib/solvers/TraceElbowTransitionSimplificationSolver/types"
+import type { InputProblem } from "lib/types/InputProblem"
+
+const inputProblem: InputProblem = {
+  chips: [],
+  directConnections: [],
+  netConnections: [],
+  availableNetLabelOrientations: {},
+  textBoxes: [],
+}
+
+const initialPath = [
+  { x: 0, y: 0 },
+  { x: 4, y: 0 },
+]
+
+const reroutedPath = [
+  { x: 0, y: 0 },
+  { x: 1.8, y: 0 },
+  { x: 1.8, y: 0.5 },
+  { x: 2.2, y: 0.5 },
+  { x: 2.2, y: 0 },
+  { x: 4, y: 0 },
+]
+
+const initialTrace: SolvedTracePath = {
+  mspPairId: "ground-trace",
+  dcConnNetId: "ground-global",
+  globalConnNetId: "ground-global",
+  userNetId: "GND",
+  pins: [
+    { pinId: "ground-pin-1", chipId: "left", x: 0, y: 0 },
+    { pinId: "ground-pin-2", chipId: "right", x: 4, y: 0 },
+  ],
+  tracePath: initialPath,
+  mspConnectionPairIds: ["ground-trace"],
+  pinIds: ["ground-pin-1", "ground-pin-2"],
+}
+
+const supersededLabel: NetLabelPlacement = {
+  globalConnNetId: "label-global",
+  dcConnNetId: "label-global",
+  netId: "CC2",
+  mspConnectionPairIds: ["label-host"],
+  pinIds: ["label-pin-1", "label-pin-2"],
+  orientation: "y+",
+  anchorPoint: { x: 2, y: -0.2 },
+  center: { x: 2, y: 0 },
+  width: 0.2,
+  height: 0.4,
+}
+
+const clearInlineLabel: InlineNetLabelPlacement = {
+  globalConnNetId: "label-global",
+  netId: "CC2",
+  mspPairId: "label-host",
+  pinIds: ["label-pin-1", "label-pin-2"],
+  axis: "x",
+  anchorPoint: { x: 2, y: -0.5 },
+  center: { x: 2, y: -0.6 },
+  width: 0.4,
+  height: 0.1,
+  side: "y-",
+}
+
+const completedReroute: CompletedTraceReroute = {
+  initialTrace,
+  reroutedTracePath: reroutedPath,
+  label: supersededLabel,
+  detourCount: 0,
+}
+
+const makeReroutedTrace = (tracePath = reroutedPath): SolvedTracePath => ({
+  ...initialTrace,
+  tracePath,
+})
+
+const restore = ({
+  traces = [makeReroutedTrace()],
+  netLabelPlacements = [],
+  inlineNetLabelPlacements = [clearInlineLabel],
+}: {
+  traces?: SolvedTracePath[]
+  netLabelPlacements?: NetLabelPlacement[]
+  inlineNetLabelPlacements?: InlineNetLabelPlacement[]
+} = {}) =>
+  restoreReroutesAroundSupersededLabels({
+    inputProblem,
+    traces,
+    netLabelPlacements,
+    inlineNetLabelPlacements,
+    completedReroutes: [completedReroute],
+  })
+
+test("restores the exact route after its blocking label is superseded", () => {
+  const result = restore()
+
+  expect(result.restoredTraceCount).toBe(1)
+  expect(result.traces[0]!.tracePath).toEqual(initialPath)
+})
+
+test("keeps the detour when inline conversion did not supersede the label", () => {
+  const result = restore({ inlineNetLabelPlacements: [] })
+
+  expect(result.restoredTraceCount).toBe(0)
+  expect(result.traces[0]!.tracePath).toEqual(reroutedPath)
+})
+
+test("keeps the detour when the final inline label occupies the old route", () => {
+  const result = restore({
+    inlineNetLabelPlacements: [
+      {
+        ...clearInlineLabel,
+        anchorPoint: { x: 2, y: 0 },
+        center: { x: 2, y: 0 },
+      },
+    ],
+  })
+
+  expect(result.restoredTraceCount).toBe(0)
+  expect(result.traces[0]!.tracePath).toEqual(reroutedPath)
+})
+
+test("keeps the detour when another trace crosses the old route", () => {
+  const blockingTrace: SolvedTracePath = {
+    ...initialTrace,
+    mspPairId: "blocking-trace",
+    dcConnNetId: "blocking-global",
+    globalConnNetId: "blocking-global",
+    userNetId: "BLOCKING",
+    tracePath: [
+      { x: 2, y: -1 },
+      { x: 2, y: 1 },
+    ],
+  }
+  const result = restore({ traces: [makeReroutedTrace(), blockingTrace] })
+
+  expect(result.restoredTraceCount).toBe(0)
+  expect(result.traces[0]!.tracePath).toEqual(reroutedPath)
+})
+
+test("allows an unchanged pre-existing trace crossing", () => {
+  const existingCrossing: SolvedTracePath = {
+    ...initialTrace,
+    mspPairId: "existing-crossing",
+    dcConnNetId: "existing-crossing-global",
+    globalConnNetId: "existing-crossing-global",
+    userNetId: "EXISTING_CROSSING",
+    tracePath: [
+      { x: 1, y: -1 },
+      { x: 1, y: 1 },
+    ],
+  }
+  const result = restore({ traces: [makeReroutedTrace(), existingCrossing] })
+
+  expect(result.restoredTraceCount).toBe(1)
+  expect(result.traces[0]!.tracePath).toEqual(initialPath)
+})
+
+test("keeps the detour when a retained anchored label occupies the old route", () => {
+  const retainedLabel: NetLabelPlacement = {
+    ...supersededLabel,
+    globalConnNetId: "retained-label-global",
+    dcConnNetId: "retained-label-global",
+    netId: "RETAINED",
+  }
+  const result = restore({ netLabelPlacements: [retainedLabel] })
+
+  expect(result.restoredTraceCount).toBe(0)
+  expect(result.traces[0]!.tracePath).toEqual(reroutedPath)
+})
+
+test("does not overwrite a trace changed after the recorded reroute", () => {
+  const changedPath = reroutedPath.map((point) => ({ ...point }))
+  changedPath[2]!.y = 0.6
+  changedPath[3]!.y = 0.6
+  const result = restore({ traces: [makeReroutedTrace(changedPath)] })
+
+  expect(result.restoredTraceCount).toBe(0)
+  expect(result.traces[0]!.tracePath).toEqual(changedPath)
+})