@tscircuit/schematic-trace-solver 0.0.156 → 0.0.157

package/tests/repros/board-1273-trace-overlap-cycle.test.ts

@@ -24,7 +24,7 @@ test("board 1273 solves within the trace overlap iteration limit", async () => {
 
   expect(solver.solved).toBe(true)
   expect(solver.failed).toBe(false)
-  expect(solver.traceOverlapShiftSolver?.iterations).toBe(21)
+  expect(solver.traceOverlapShiftSolver?.iterations).toBe(27)
   expect(solver.postLabelTraceOverlapShiftSolver?.iterations).toBe(1)
   await expect(solver).toMatchSolverSnapshot(import.meta.path)
 })

package/tests/repros/repro-dc-power-isolated-routing.test.ts

@@ -0,0 +1,13 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import "tests/fixtures/matcher"
+import inputProblem from "./assets/repro-dc-power-isolated-routing.input.json"
+
+test("isolated DC power regulator trace routing", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem as any)
+
+  solver.solve()
+
+  expect(solver.failed).toBe(false)
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

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

@@ -0,0 +1,77 @@
+import { expect, test } from "bun:test"
+import { MspConnectionPairSolver } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import "tests/fixtures/matcher"
+import inputProblemJson from "./assets/repro-pmp11282-isolated-dcdc.input.json"
+
+const cloneInputProblem = (): InputProblem =>
+  JSON.parse(JSON.stringify(inputProblemJson))
+
+test("repro PMP11282 isolated DC/DC traces and endpoint net labels", () => {
+  const inputProblem = cloneInputProblem()
+  const pairSolver = new MspConnectionPairSolver({ inputProblem })
+
+  pairSolver.solve()
+
+  const uniquePairIds = new Set(
+    pairSolver.mspConnectionPairs.map((pair) => pair.mspPairId),
+  )
+  expect(inputProblem.chips).toHaveLength(112)
+  expect(inputProblem.directConnections).toHaveLength(163)
+  expect(pairSolver.solved).toBe(true)
+  expect(pairSolver.mspConnectionPairs).toHaveLength(203)
+  expect(uniquePairIds.size).toBe(203)
+
+  const defaultPipeline = new SchematicTracePipelineSolver(
+    cloneInputProblem(),
+    { hideRatsNet: true },
+  )
+  defaultPipeline.solve()
+
+  const defaultTraceSolver = defaultPipeline.schematicTraceLinesSolver!
+  expect(defaultPipeline.solved).toBe(false)
+  expect(defaultPipeline.failed).toBe(true)
+  expect(defaultPipeline.error).toBe(
+    "SchematicTraceLinesSolver ran out of iterations",
+  )
+  expect(defaultTraceSolver.solvedTracePaths).toHaveLength(72)
+  expect(defaultTraceSolver.failedConnectionPairs).toHaveLength(35)
+  expect(defaultTraceSolver.queuedConnectionPairs).toHaveLength(95)
+
+  // Let the same unmodified production pipeline reach its downstream stages
+  // by increasing only this test instance's nested-solver budget. This keeps
+  // the reproduction production-code-free while exposing the resulting labels.
+  const diagnosticPipeline = new SchematicTracePipelineSolver(
+    cloneInputProblem(),
+    { hideRatsNet: true },
+  )
+  diagnosticPipeline.solveUntilPhase("schematicTraceLinesSolver")
+  diagnosticPipeline.step()
+  diagnosticPipeline.schematicTraceLinesSolver!.MAX_ITERATIONS *=
+    diagnosticPipeline.mspConnectionPairSolver!.mspConnectionPairs.length
+  diagnosticPipeline.solve()
+
+  const finalOutput = diagnosticPipeline.inlineNetLabelSolver!.getOutput()
+  const endpointPairLabels = finalOutput.netLabelPlacements.filter((label) =>
+    label.netId?.includes(" to "),
+  )
+  const endpointPairNetIds = new Set(
+    endpointPairLabels.map((label) => label.netId!),
+  )
+
+  expect(diagnosticPipeline.solved).toBe(true)
+  expect(diagnosticPipeline.failed).toBe(false)
+  expect(
+    diagnosticPipeline.schematicTraceLinesSolver!.solvedTracePaths,
+  ).toHaveLength(145)
+  expect(
+    diagnosticPipeline.schematicTraceLinesSolver!.failedConnectionPairs,
+  ).toHaveLength(58)
+  expect(finalOutput.netLabelPlacements).toHaveLength(106)
+  expect(endpointPairLabels).toHaveLength(80)
+  expect(endpointPairNetIds.size).toBe(62)
+  expect(endpointPairNetIds).toContain("U500.pin8 to C501.pin1")
+  expect(endpointPairNetIds).toContain("L500.pin1 to L500.pin2")
+  expect(diagnosticPipeline).toMatchSolverSnapshot(import.meta.path)
+}, 30_000)

package/tests/repros/repro-tida00553-j4-cell-divider.test.ts

@@ -0,0 +1,111 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import "tests/fixtures/matcher"
+
+const horizontalResistor = (name: string, x: number) => ({
+  chipId: name,
+  center: { x, y: 2 },
+  width: 0.72,
+  height: 0.68,
+  pins: [
+    {
+      pinId: `${name}.1`,
+      displayName: "1",
+      x: x - 0.36,
+      y: 2,
+      _facingDirection: "x-" as const,
+    },
+    {
+      pinId: `${name}.2`,
+      displayName: "2",
+      x: x + 0.36,
+      y: 2,
+      _facingDirection: "x+" as const,
+    },
+  ],
+})
+
+// Isolated from the TIDA-00553 battery-pack cell-count selector. R26-R29
+// form the VFB divider, J4 pins 1/3/5 tap its intermediate nodes, and J4 pins
+// 2/4/6 share the ground end of the divider.
+const inputProblem: InputProblem = {
+  chips: [
+    horizontalResistor("R26", 7.2),
+    horizontalResistor("R27", 8.2),
+    horizontalResistor("R28", 9.2),
+    horizontalResistor("R29", 10.2),
+    {
+      chipId: "J4",
+      center: { x: 10.4, y: 0.6 },
+      width: 1.6,
+      height: 0.8,
+      pins: [
+        { pinId: "J4.1", displayName: "1", x: 9.6, y: 0.8 },
+        { pinId: "J4.2", displayName: "2", x: 11.2, y: 0.8 },
+        { pinId: "J4.3", displayName: "3", x: 9.6, y: 0.6 },
+        { pinId: "J4.4", displayName: "4", x: 11.2, y: 0.6 },
+        { pinId: "J4.5", displayName: "5", x: 9.6, y: 0.4 },
+        { pinId: "J4.6", displayName: "6", x: 11.2, y: 0.4 },
+      ],
+    },
+  ],
+  directConnections: [
+    {
+      netId: "4-Cell/J4-R26",
+      netLabelText: "J4_5",
+      netLabelWidth: 0.6,
+      pinIds: ["J4.5", "R26.2"],
+    },
+    { netId: "4-Cell/J4-R27", pinIds: ["J4.5", "R27.1"] },
+    { netId: "3-Cell/J4-R27", pinIds: ["J4.3", "R27.2"] },
+    { netId: "3-Cell/J4-R28", pinIds: ["J4.3", "R28.1"] },
+    { netId: "2-Cell/J4-R28", pinIds: ["J4.1", "R28.2"] },
+    { netId: "2-Cell/J4-R29", pinIds: ["J4.1", "R29.1"] },
+  ],
+  netConnections: [
+    {
+      netId: "U2_VFB",
+      netLabelText: "U2_VFB",
+      netLabelWidth: 1.12,
+      pinIds: ["R26.1"],
+    },
+    {
+      netId: "GND",
+      netLabelText: "GND",
+      netLabelWidth: 0.42,
+      netLabelHeight: 0.48,
+      pinIds: ["R29.2", "J4.2", "J4.4", "J4.6"],
+    },
+  ],
+  textBoxes: [
+    {
+      chipId: "J4",
+      center: { x: 10.12, y: 0.07 },
+      width: 0.24,
+      height: 0.18,
+      text: "J4",
+    },
+    {
+      chipId: "J4",
+      center: { x: 10.12, y: 1.115 },
+      width: 0.36,
+      height: 0.25,
+      text: "J4",
+    },
+  ],
+  availableNetLabelOrientations: {
+    U2_VFB: ["x-"],
+    "4-Cell/J4-R26": ["x-"],
+    "4-Cell/J4-R27": ["x-"],
+    GND: ["y-"],
+  },
+  maxMspPairDistance: 2.4,
+}
+
+test("repro TIDA-00553 J4 cell divider routing", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem)
+
+  solver.solve()
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})