@tscircuit/schematic-trace-solver 0.0.176 → 0.0.178

package/tests/repros/repro-smartwatch-power-sheet.test.ts

@@ -0,0 +1,27 @@
+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-smartwatch-power-sheet.input.json"
+
+test("smartwatch power sheet", () => {
+  const solver = new SchematicTracePipelineSolver(
+    inputProblem as unknown as InputProblem,
+    {
+      hideRatsNet: true,
+    },
+  )
+  solver.solve()
+
+  const connectorGroundPinIds = new Set([
+    "schematic_port_0",
+    "schematic_port_11",
+  ])
+  const connectorGroundLabels = solver
+    .netLabelToTraceSolver!.getOutput()
+    .netLabelPlacements.filter((label) =>
+      label.pinIds.some((pinId) => connectorGroundPinIds.has(pinId)),
+    )
+  expect(connectorGroundLabels).toHaveLength(1)
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/solvers/MspConnectionPairSolver/ground-direct-connection-groups.test.ts

@@ -56,6 +56,17 @@ test("marked ground nets retain explicit islands even with identical netIds", ()
   )
 })
 
+test("unwired same-component ground pins share a local connection", () => {
+  const inputProblem = createInput()
+  inputProblem.chips[4]!.pins.push({ pinId: "F", x: 2.2, y: 0.1 })
+  inputProblem.netConnections[0]!.pinIds.push("F")
+
+  const solver = new MspConnectionPairSolver({ inputProblem })
+  solver.solve()
+
+  expect(pairKeys(solver)).toEqual(["A-B", "C-D", "E-F"])
+})
+
 test.each([false, undefined])(
   "isGround=%s preserves automatic net routing",
   (isGround) => {

package/tests/solvers/TraceCleanupSolver/alignSameNetRails-pipeline-label-connector.test.ts

@@ -35,8 +35,10 @@ test("pipeline does not stretch a real loop toward a generated label connector",
 
   const traces = solver.traceCleanupSolver2!.getOutput().traces
   const realTrace = traces.find((trace) => trace.mspPairId === "U3.3-U3.7")!
-  const labelConnector = traces.find((trace) =>
-    trace.mspPairId.startsWith("available-net-orientation-"),
+  const [labelConnectorTraceId] =
+    solver.availableNetOrientationSolver!.netLabelConnectorTraceIds
+  const labelConnector = traces.find(
+    (trace) => trace.mspPairId === labelConnectorTraceId,
   )!
   expect(realTrace.tracePath).toEqual([
     { x: 1.4, y: -0.3 },

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

@@ -0,0 +1,160 @@
+import { expect, test } from "bun:test"
+import { getPathLength } from "lib/solvers/Example28Solver/geometry"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { rerouteGeneratedNetLabelConnectorCrossings } from "lib/solvers/TraceCleanupSolver/rerouteGeneratedNetLabelConnectorCrossings"
+import { findPerpendicularPathCrossings } from "lib/solvers/TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles"
+
+const makeTrace = ({
+  mspPairId,
+  globalConnNetId,
+  tracePath,
+  pinIds,
+}: {
+  mspPairId: string
+  globalConnNetId: string
+  tracePath: Array<{ x: number; y: number }>
+  pinIds: string[]
+}): SolvedTracePath => {
+  const firstPoint = tracePath[0]!
+  const lastPoint = tracePath.at(-1)!
+  return {
+    mspPairId,
+    dcConnNetId: globalConnNetId,
+    globalConnNetId,
+    pins: [
+      {
+        pinId: pinIds[0]!,
+        chipId: `${mspPairId}-start-chip`,
+        ...firstPoint,
+      },
+      {
+        pinId: pinIds[1] ?? pinIds[0]!,
+        chipId: `${mspPairId}-end-chip`,
+        ...lastPoint,
+      },
+    ],
+    pinIds,
+    mspConnectionPairIds: [mspPairId],
+    tracePath,
+  }
+}
+
+const signalTrace = makeTrace({
+  mspPairId: "signal-trace",
+  globalConnNetId: "signal-net",
+  pinIds: ["signal-a", "signal-b"],
+  tracePath: [
+    { x: 1, y: 3 },
+    { x: 2, y: 3 },
+    { x: 2, y: 0 },
+    { x: -6, y: 0 },
+  ],
+})
+
+const connectorTrace = makeTrace({
+  mspPairId: "vbat-label-connector",
+  globalConnNetId: "vbat-net",
+  pinIds: ["vbat"],
+  tracePath: [
+    { x: 3, y: 1 },
+    { x: 1.5, y: 1 },
+    { x: 1.5, y: 1.5 },
+  ],
+})
+
+const vbatLabel = {
+  globalConnNetId: "vbat-net",
+  pinIds: ["vbat"],
+  anchorPoint: { x: 1.5, y: 1.5 },
+  center: { x: 1.5, y: 1.7 },
+  width: 1,
+  height: 0.4,
+}
+
+const inputProblem = { chips: [], textBoxes: [] } as any
+
+test("reroutes a component trace through an equally short clean corridor", () => {
+  const result = rerouteGeneratedNetLabelConnectorCrossings({
+    inputProblem,
+    traces: [signalTrace, connectorTrace],
+    netLabelPlacements: [vbatLabel as any],
+    mergedLabelNetIdMap: {},
+    clearance: 0.1,
+    eligibleTraceIds: new Set([signalTrace.mspPairId]),
+    connectorTraceIds: new Set([connectorTrace.mspPairId]),
+  })
+
+  expect(result.reroutedTraceCount).toBe(1)
+  expect(result.traces[1]!.tracePath).toEqual(connectorTrace.tracePath)
+  expect(getPathLength(result.traces[0]!.tracePath)).toBeLessThanOrEqual(
+    getPathLength(signalTrace.tracePath),
+  )
+  expect(
+    findPerpendicularPathCrossings(
+      result.traces[0]!.tracePath,
+      result.traces[1]!.tracePath,
+      { includeTerminalSegments: true },
+    ),
+  ).toEqual([])
+})
+
+test("preserves a crossing when avoiding it would lengthen the routed trace", () => {
+  const straightSignal = makeTrace({
+    mspPairId: "straight-signal",
+    globalConnNetId: "signal-net",
+    pinIds: ["signal-a", "signal-b"],
+    tracePath: [
+      { x: -2, y: 0 },
+      { x: 2, y: 0 },
+    ],
+  })
+  const verticalConnector = makeTrace({
+    mspPairId: "vertical-label-connector",
+    globalConnNetId: "label-net",
+    pinIds: ["label-pin"],
+    tracePath: [
+      { x: 0, y: -1 },
+      { x: 0, y: 1 },
+    ],
+  })
+
+  const result = rerouteGeneratedNetLabelConnectorCrossings({
+    inputProblem,
+    traces: [straightSignal, verticalConnector],
+    netLabelPlacements: [],
+    mergedLabelNetIdMap: {},
+    clearance: 0.1,
+    eligibleTraceIds: new Set([straightSignal.mspPairId]),
+    connectorTraceIds: new Set([verticalConnector.mspPairId]),
+  })
+
+  expect(result.reroutedTraceCount).toBe(0)
+  expect(result.traces[0]!.tracePath).toEqual(straightSignal.tracePath)
+})
+
+test("allows crossings between generated label connectors", () => {
+  const otherConnector = makeTrace({
+    mspPairId: "other-label-connector",
+    globalConnNetId: "other-label-net",
+    pinIds: ["other-label-pin"],
+    tracePath: [
+      { x: 2, y: 0 },
+      { x: 2, y: 2 },
+    ],
+  })
+
+  const result = rerouteGeneratedNetLabelConnectorCrossings({
+    inputProblem,
+    traces: [connectorTrace, otherConnector],
+    netLabelPlacements: [vbatLabel as any],
+    mergedLabelNetIdMap: {},
+    clearance: 0.1,
+    connectorTraceIds: new Set([
+      connectorTrace.mspPairId,
+      otherConnector.mspPairId,
+    ]),
+  })
+
+  expect(result.reroutedTraceCount).toBe(0)
+  expect(result.traces).toEqual([connectorTrace, otherConnector])
+})