@tscircuit/schematic-trace-solver 0.0.192 → 0.0.194

package/tests/repros/repro-manual-placement-detour.test.ts

@@ -0,0 +1,39 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import { findFirstCollision } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import type { InputProblem } from "lib/types/InputProblem"
+import "tests/fixtures/matcher"
+import inputJson from "./repro-manual-placement-detour.input.json"
+
+// Captured from core/tests/components/primitive-components/schematic-section-manual-placement-5.test.tsx.
+// R2 pin1 and C3 pin1 face upward, with C3 obstructing the initial U-shaped route.
+test("routes R2 to C3 locally in manually placed schematic sections", async () => {
+  const inputProblem: InputProblem = JSON.parse(JSON.stringify(inputJson))
+  const solver = new SchematicTracePipelineSolver(inputProblem)
+  solver.solve()
+
+  const trace = solver
+    .netLabelToTraceSolver!.getOutput()
+    .traces.find(
+      (trace) =>
+        trace.pinIds.includes("schematic_port_31") &&
+        trace.pinIds.includes("schematic_port_29"),
+    )!
+  let routeLength = 0
+  for (let pointIndex = 1; pointIndex < trace.tracePath.length; pointIndex++) {
+    const previousPoint = trace.tracePath[pointIndex - 1]!
+    const point = trace.tracePath[pointIndex]!
+    routeLength +=
+      Math.abs(point.x - previousPoint.x) + Math.abs(point.y - previousPoint.y)
+  }
+  expect(solver.solved).toBe(true)
+  expect(
+    findFirstCollision(trace.tracePath, getObstacleRects(inputProblem)),
+  ).toBeNull()
+  expect(routeLength).toBeCloseTo(3.06)
+  expect(Math.min(...trace.tracePath.map((point) => point.x))).toBeGreaterThan(
+    -3.5,
+  )
+  await expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/repros/repro-pmp11282-isolated-dcdc.test.ts

@@ -68,9 +68,16 @@ test("repro PMP11282 isolated DC/DC traces and endpoint net labels", () => {
   expect(
     diagnosticPipeline.schematicTraceLinesSolver!.failedConnectionPairs,
   ).toHaveLength(60)
-  expect(finalOutput.netLabelPlacements).toHaveLength(108)
-  expect(endpointPairLabels).toHaveLength(80)
-  expect(endpointPairNetIds.size).toBe(62)
+  expect(finalOutput.netLabelPlacements).toHaveLength(107)
+  expect(endpointPairLabels).toHaveLength(79)
+  expect(endpointPairNetIds.size).toBe(61)
+  expect(
+    finalOutput.traces.some(
+      (trace) =>
+        trace.pinIds.includes("schematic_port_20") &&
+        trace.pinIds.includes("schematic_port_34"),
+    ),
+  ).toBe(true)
   expect(endpointPairNetIds).toContain("U500.pin8 to C501.pin1")
   expect(endpointPairNetIds).toContain("L500.pin1 to L500.pin2")
   expect(diagnosticPipeline).toMatchSolverSnapshot(import.meta.path)

package/tests/repros/repro173-boost-drv8711-ground-label-overlap.test.ts

@@ -0,0 +1,41 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import { pathIntersectsRenderedLabel } from "lib/utils/pathIntersectsRenderedLabel"
+import "tests/fixtures/matcher"
+import inputProblem from "./assets/repro173-boost-drv8711-ground-label-overlap.input.json"
+
+// Power stage solver input captured via solver:started from core's
+// tests/repros/repro173-boost-drv8711-cross-sheet-netlabel-overlap.test.tsx
+// at 2ad5cd0a, after https://github.com/tscircuit/core/pull/3794.
+// Only symbolName and netLabelText were added for readable snapshots; routing
+// geometry, pin order, and all eight cross-sheet U1 gate-drive labels are intact.
+// The controller sheet is solved independently, so its input is not needed.
+test("repro173 BOOST-DRV8711 ground trace overlaps the R1 GND label", async () => {
+  const solver = new SchematicTracePipelineSolver(
+    inputProblem as unknown as InputProblem,
+    { hideRatsNet: true },
+  )
+  solver.solve()
+
+  expect(solver.solved).toBe(true)
+
+  const { traces, netLabelPlacements } =
+    solver.netLabelToTraceSolver!.getOutput()
+  const r1GroundLabel = netLabelPlacements.find(
+    (label) =>
+      label.netId === "GND" && label.pinIds.includes("schematic_port_83"),
+  )!
+  const c1ToR2GroundTrace = traces.find(
+    (trace) =>
+      trace.pinIds.includes("schematic_port_78") &&
+      trace.pinIds.includes("schematic_port_85"),
+  )!
+
+  // Current bug: the C1-to-R2 ground rail crosses the rendered GND label below
+  // R1. Record the observed failure; update this assertion and snapshot when fixed.
+  expect(
+    pathIntersectsRenderedLabel(c1ToR2GroundTrace.tracePath, r1GroundLabel),
+  ).toBe(true)
+  await expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/repros/rtc-imu-microsd-section.test.ts

@@ -0,0 +1,28 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import inputProblem from "./assets/rtc-imu-microsd-section.input.json"
+import "tests/fixtures/matcher"
+import type { InputProblem } from "lib/types/InputProblem"
+import { getPathLength } from "lib/solvers/Example28Solver/geometry"
+
+test("RTC IMU microSD section trace routing", () => {
+  const problem: InputProblem = JSON.parse(JSON.stringify(inputProblem))
+  const solver = new SchematicTracePipelineSolver(problem)
+  solver.solve()
+  const recoveredTrace = solver
+    .unroutedTraceRecoverySolver!.getOutput()
+    .newTraces.find(
+      (trace) =>
+        trace.pinIds.includes("schematic_port_53") &&
+        trace.pinIds.includes("schematic_port_32"),
+    )!
+  expect(recoveredTrace).toBeDefined()
+  expect(getPathLength(recoveredTrace.tracePath)).toBeLessThan(4)
+  expect(recoveredTrace.tracePath[0]).toMatchObject(recoveredTrace.pins[0])
+  expect(recoveredTrace.tracePath.at(-1)).toMatchObject(recoveredTrace.pins[1])
+  const finalTrace = solver
+    .inlineNetLabelSolver!.getOutput()
+    .traces.find((trace) => trace.mspPairId === recoveredTrace.mspPairId)!
+  expect(getPathLength(finalTrace.tracePath)).toBeLessThan(3.5)
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/solvers/UnroutedTraceRecoverySolver/local-elbow-obstacles.test.ts

@@ -67,7 +67,7 @@ test.each(["chip", "text", "trace"] as const)(
     expect(recovery.solved).toBe(true)
     expect(recovery.solvedUnroutedTraces).toHaveLength(1)
     const recoveredPath = recovery.solvedUnroutedTraces[0]!.tracePath
-    expect(getPathLength(recoveredPath)).toBeGreaterThan(0.8)
+    expect(getPathLength(recoveredPath)).toBeCloseTo(0.8)
     expect(findFirstCollision(recoveredPath, [blockingBounds])).toBeNull()
     expect(countPathIntersections(recoveredPath, blockingPath)).toBe(0)
   },