@tscircuit/schematic-trace-solver 0.0.201 → 0.0.203

package/tests/repros/assets/repro-trace-endpoints-stop-at-component-boundary.input.json

@@ -0,0 +1,82 @@
+{
+  "chips": [
+    {
+      "chipId": "J1",
+      "center": { "x": -13, "y": 6 },
+      "width": 1.3,
+      "height": 0.4,
+      "pins": [
+        {
+          "pinId": "J1.1",
+          "x": -14.05,
+          "y": 6,
+          "_facingDirection": "x-"
+        }
+      ]
+    },
+    {
+      "chipId": "F1",
+      "symbolName": "fuse_horz",
+      "center": { "x": -10.17, "y": 6.115 },
+      "width": 0.74,
+      "height": 0.39,
+      "pins": [
+        {
+          "pinId": "F1.1",
+          "x": -10.4,
+          "y": 6,
+          "_facingDirection": "x-"
+        },
+        {
+          "pinId": "F1.2",
+          "x": -9.6,
+          "y": 6,
+          "_facingDirection": "x+"
+        }
+      ]
+    },
+    {
+      "chipId": "RV1",
+      "symbolName": "varistor_horz",
+      "center": { "x": -10.195, "y": 3.615 },
+      "width": 0.79,
+      "height": 0.47,
+      "pins": [
+        {
+          "pinId": "RV1.1",
+          "x": -10.4,
+          "y": 3.5,
+          "_facingDirection": "x-"
+        },
+        {
+          "pinId": "RV1.2",
+          "x": -9.6,
+          "y": 3.5,
+          "_facingDirection": "x+"
+        }
+      ]
+    }
+  ],
+  "directConnections": [
+    {
+      "netId": "LINE",
+      "pinIds": ["J1.1", "F1.1"]
+    },
+    {
+      "netId": "LINE_FUSED",
+      "pinIds": ["F1.2", "RV1.1"]
+    }
+  ],
+  "netConnections": [
+    {
+      "netId": "NEUTRAL",
+      "netLabelText": "NEUTRAL",
+      "netLabelWidth": 0.84,
+      "pinIds": ["RV1.2"]
+    }
+  ],
+  "availableNetLabelOrientations": {
+    "NEUTRAL": ["x+"]
+  },
+  "maxMspPairDistance": 100
+}

package/tests/repros/repro-am3352-06-boot.test.ts

@@ -0,0 +1,43 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import { tracePathContainsPoint } from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
+import { findPerpendicularPathCrossings } from "lib/solvers/TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles"
+import "tests/fixtures/matcher"
+import input from "./assets/repro-am3352-06-boot.input.json"
+
+// Full sheet from am3352-dev-board-4layer-dogbone.json; routing uses core defaults.
+test("repro complete AM3352 06-Boot sheet", async () => {
+  const problem = structuredClone(input) as InputProblem
+  const solver = new SchematicTracePipelineSolver(problem, {
+    hideRatsNet: true,
+  })
+  solver.solve()
+  expect(solver.solved).toBe(true)
+  expect(solver.failed).toBe(false)
+  const { traces, inlineNetLabelPlacements } =
+    solver.netLabelToTraceSolver!.getOutput()
+  for (const netId of ["BOOT_SEL1", "BOOT_SEL2", "BOOT_SEL3"]) {
+    const trace = traces.find((trace) => trace.userNetId === netId)!
+    expect(trace).toBeDefined()
+    expect(trace.tracePath).toHaveLength(4)
+    expect(trace.tracePath[1]!.y).toBe(trace.tracePath[0]!.y)
+    expect(trace.tracePath[2]!.y).toBe(trace.tracePath[3]!.y)
+    const label = inlineNetLabelPlacements.find(
+      (label) => label.globalConnNetId === trace.globalConnNetId,
+    )!
+    expect(label).toBeDefined()
+    expect(tracePathContainsPoint(trace.tracePath, label.anchorPoint)).toBe(
+      true,
+    )
+    for (const otherTrace of traces) {
+      if (otherTrace.globalConnNetId === trace.globalConnNetId) continue
+      expect(
+        findPerpendicularPathCrossings(trace.tracePath, otherTrace.tracePath, {
+          includeTerminalSegments: true,
+        }),
+      ).toEqual([])
+    }
+  }
+  await expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/repros/repro-mouse-switch-ground-unnecessary-jog.test.ts

@@ -1,4 +1,5 @@
 import { expect, test } from "bun:test"
+import { getOutputLabelCollisions } from "lib/solvers/InlineNetLabelSolver/getOutputLabelCollisions"
 import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
 import "tests/fixtures/matcher"
 import inputProblem from "./assets/repro-mouse-switch-ground-unnecessary-jog.input.json"
@@ -11,5 +12,19 @@ test("repro unnecessary jog in mouse switch ground trunk", () => {
 
   solver.solve()
 
+  const inlineOutput = solver.inlineNetLabelSolver!.getOutput()
+  const groundLabel = inlineOutput.netLabelPlacements.find(
+    (label) => label.netId === "GND",
+  )
+  expect(groundLabel?.orientation).toBe("y-")
+  expect(
+    inlineOutput.inlineNetLabelPlacements.some(
+      (label) => label.netId === "RIGHT",
+    ),
+  ).toBe(true)
+  expect(
+    inlineOutput.netLabelPlacements.some((label) => label.netId === "RIGHT"),
+  ).toBe(false)
+  expect(getOutputLabelCollisions(inlineOutput)).toEqual([])
   expect(solver).toMatchSolverSnapshot(import.meta.path)
 })

package/tests/repros/repro-trace-endpoints-stop-at-component-boundary.test.ts

@@ -0,0 +1,21 @@
+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 inputProblemJson from "./assets/repro-trace-endpoints-stop-at-component-boundary.input.json"
+
+const inputProblem: InputProblem = JSON.parse(JSON.stringify(inputProblemJson))
+
+// F1 and RV1 have ports inside their text-expanded component bounds. The
+// routed traces currently stop at the lower bounds instead of reaching the
+// original left-facing port coordinates.
+test("trace endpoints stop at component boundaries before reaching target ports", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem, {
+    hideRatsNet: true,
+  })
+
+  solver.solve()
+
+  expect(solver.schematicTraceLinesSolver!.solvedTracePaths).toHaveLength(2)
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/solvers/TraceCleanupSolver/reroute-generated-net-label-connector-crossings.test.ts

@@ -158,3 +158,52 @@ test("allows crossings between generated label connectors", () => {
   expect(result.reroutedTraceCount).toBe(0)
   expect(result.traces).toEqual([connectorTrace, otherConnector])
 })
+
+test.each([false, true])(
+  "removes the old loop when rerouting a connector crossing (reversed: %s)",
+  (reversed) => {
+    let tracePath = [
+      { x: 0, y: 0 },
+      { x: 1, y: 0 },
+      { x: 1, y: 3 },
+      { x: 4, y: 3 },
+      { x: 4, y: -3 },
+      { x: 0, y: -3 },
+    ]
+    if (reversed) tracePath = tracePath.toReversed()
+    const trace = makeTrace({
+      mspPairId: "loop",
+      globalConnNetId: "signal",
+      pinIds: ["a", "b"],
+      tracePath,
+    })
+    const connector = makeTrace({
+      mspPairId: "connector",
+      globalConnNetId: "power",
+      pinIds: ["c"],
+      tracePath: [
+        { x: 0, y: 1 },
+        { x: 2, y: 1 },
+      ],
+    })
+    const result = rerouteGeneratedNetLabelConnectorCrossings({
+      inputProblem,
+      traces: [trace, connector],
+      netLabelPlacements: [],
+      mergedLabelNetIdMap: {},
+      clearance: 0.1,
+      connectorTraceIds: new Set([connector.mspPairId]),
+    })
+    const path = result.traces[0]!.tracePath
+    expect(result.reroutedTraceCount).toBe(1)
+    expect(path).toHaveLength(4)
+    expect(path[0]).toEqual(tracePath[0])
+    expect(path.at(-1)).toEqual(tracePath.at(-1))
+    expect(getPathLength(path)).toBeLessThan(getPathLength(tracePath))
+    expect(
+      findPerpendicularPathCrossings(path, connector.tracePath, {
+        includeTerminalSegments: true,
+      }),
+    ).toEqual([])
+  },
+)