@tscircuit/schematic-trace-solver 0.0.98 → 0.0.100

package/tests/repros/assets/repro5-escape-padded-text-obstacles.input.json

@@ -0,0 +1,202 @@
+{
+  "chips": [
+    {
+      "chipId": "schematic_component_0",
+      "center": {
+        "x": 0,
+        "y": 0
+      },
+      "width": 1.8,
+      "height": 5,
+      "pins": [
+        {
+          "pinId": "U1.1",
+          "x": 0.9,
+          "y": 1.2
+        },
+        {
+          "pinId": "U1.2",
+          "x": 0.9,
+          "y": 0.3999999999999999
+        },
+        {
+          "pinId": "U1.3",
+          "x": 0.9,
+          "y": 0.5999999999999999
+        },
+        {
+          "pinId": "U1.4",
+          "x": -0.9,
+          "y": 0.3999999999999999
+        },
+        {
+          "pinId": "U1.5",
+          "x": 0.9,
+          "y": 0.9999999999999998
+        },
+        {
+          "pinId": "U1.6",
+          "x": 0.9,
+          "y": -0.19999999999999996
+        },
+        {
+          "pinId": "U1.7",
+          "x": -0.9,
+          "y": -0.7999999999999998
+        },
+        {
+          "pinId": "U1.9",
+          "x": 0.9,
+          "y": 0.19999999999999996
+        },
+        {
+          "pinId": "U1.10",
+          "x": 0.9,
+          "y": 0
+        },
+        {
+          "pinId": "U1.11",
+          "x": 0.9,
+          "y": 0.7999999999999998
+        },
+        {
+          "pinId": "U1.12",
+          "x": 0.9,
+          "y": -1.2
+        },
+        {
+          "pinId": "U1.13",
+          "x": 0.9,
+          "y": -1
+        },
+        {
+          "pinId": "U1.14",
+          "x": 0.9,
+          "y": -0.7999999999999999
+        },
+        {
+          "pinId": "U1.15",
+          "x": -0.9,
+          "y": 1
+        },
+        {
+          "pinId": "U1.16",
+          "x": -0.9,
+          "y": 1.2
+        },
+        {
+          "pinId": "U1.17",
+          "x": -0.9,
+          "y": 0.5999999999999999
+        },
+        {
+          "pinId": "U1.18",
+          "x": -0.9,
+          "y": -0.9999999999999998
+        },
+        {
+          "pinId": "U1.19",
+          "x": -0.9,
+          "y": -0.19999999999999996
+        },
+        {
+          "pinId": "U1.20",
+          "x": -0.9,
+          "y": 0.7999999999999999
+        },
+        {
+          "pinId": "U1.21",
+          "x": -0.9,
+          "y": -1.2
+        },
+        {
+          "pinId": "U1.22",
+          "x": 0.9,
+          "y": -0.5999999999999999
+        },
+        {
+          "pinId": "U1.23",
+          "x": 0.9,
+          "y": -0.3999999999999999
+        },
+        {
+          "pinId": "U1.25",
+          "x": -0.9,
+          "y": -0.5999999999999999
+        },
+        {
+          "pinId": "U1.26",
+          "x": -0.9,
+          "y": -0.3999999999999999
+        },
+        {
+          "pinId": "U1.27",
+          "x": -0.9,
+          "y": 0.19999999999999996
+        },
+        {
+          "pinId": "U1.28",
+          "x": -0.9,
+          "y": 0
+        }
+      ]
+    },
+    {
+      "chipId": "schematic_component_1",
+      "center": {
+        "x": 2,
+        "y": 1.0699999999999998
+      },
+      "width": 1.04,
+      "height": 0.6799999999999999,
+      "pins": [
+        {
+          "pinId": "LED1.1",
+          "x": 1.48,
+          "y": 1,
+          "_facingDirection": "x-"
+        },
+        {
+          "pinId": "LED1.2",
+          "x": 2.52,
+          "y": 1,
+          "_facingDirection": "x+"
+        }
+      ]
+    }
+  ],
+  "directConnections": [
+    {
+      "pinIds": [
+        "LED1.2",
+        "U1.20"
+      ],
+      "netId": ".LED1 > port.right to .U1 > .pin20"
+    }
+  ],
+  "netConnections": [],
+  "textBoxes": [
+    {
+      "chipId": "schematic_component_0",
+      "center": {
+        "x": 0.15999999999999992,
+        "y": -2.63
+      },
+      "width": 1.3199999999999998,
+      "height": 0.17999999999999972,
+      "text": "part-number"
+    },
+    {
+      "chipId": "schematic_component_0",
+      "center": {
+        "x": -0.38,
+        "y": 2.615
+      },
+      "width": 0.36000000000000004,
+      "height": 0.24999999999999956,
+      "text": "U1"
+    }
+  ],
+  "availableNetLabelOrientations": {},
+  "maxMspPairDistance": 5
+}

package/tests/repros/repro129-host-custom-symbol-passives.test.ts

@@ -0,0 +1,16 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import "tests/fixtures/matcher"
+import inputProblem from "./assets/repro129-host-custom-symbol-passives.input.json"
+
+test("repro129: HOST custom symbol routes all passive connections", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem as any)
+
+  solver.solve()
+
+  expect(solver.schematicTraceLinesSolver!.solvedTracePaths).toHaveLength(4)
+  expect(solver.schematicTraceLinesSolver!.failedConnectionPairs).toHaveLength(
+    0,
+  )
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/repros/repro47-endpoint-obstacle-detour.test.ts

@@ -0,0 +1,19 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import "tests/fixtures/matcher"
+import inputProblem from "./assets/repro47-endpoint-obstacle-detour.input.json"
+
+test("repro47: endpoint obstacle detours fall back to net labels", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem as any)
+
+  solver.solve()
+
+  expect(
+    solver
+      .schematicTraceLinesSolver!.failedConnectionPairs.map(
+        (pair) => pair.mspPairId,
+      )
+      .sort(),
+  ).toEqual(["J1.1-R1.1", "J1.3-R1.2"])
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/repros/repro5-escape-padded-text-obstacles.test.ts

@@ -0,0 +1,17 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import "tests/fixtures/matcher"
+import inputProblem from "./assets/repro5-escape-padded-text-obstacles.input.json"
+
+test("repro5: route escapes past padded text obstacles", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem as any)
+
+  solver.solve()
+
+  expect(
+    solver.schematicTraceLinesSolver!.failedConnectionPairs.map(
+      (pair) => pair.mspPairId,
+    ),
+  ).toEqual([])
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/solvers/MspConnectionPairSolver/msp-connection-pair-solver-direct-connection-distance.test.ts

@@ -0,0 +1,46 @@
+import { expect, test } from "bun:test"
+import { MspConnectionPairSolver } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+
+const createInputProblem = (): InputProblem => ({
+  chips: [
+    {
+      chipId: "U1",
+      center: { x: 0, y: 0 },
+      width: 1,
+      height: 1,
+      pins: [{ pinId: "U1.1", x: 0, y: 0, _facingDirection: "x+" }],
+    },
+    {
+      chipId: "U2",
+      center: { x: 2, y: 2 },
+      width: 1,
+      height: 1,
+      pins: [{ pinId: "U2.1", x: 2, y: 2, _facingDirection: "x-" }],
+    },
+  ],
+  directConnections: [{ pinIds: ["U1.1", "U2.1"] }],
+  netConnections: [],
+  availableNetLabelOrientations: {},
+  maxMspPairDistance: 3,
+})
+
+test("two-pin direct connections use Euclidean max distance", () => {
+  const directConnectionSolver = new MspConnectionPairSolver({
+    inputProblem: createInputProblem(),
+  })
+  directConnectionSolver.solve()
+
+  const netConnectionProblem = createInputProblem()
+  netConnectionProblem.directConnections = []
+  netConnectionProblem.netConnections = [
+    { pinIds: ["U1.1", "U2.1"], netId: "SIG" },
+  ]
+  const netConnectionSolver = new MspConnectionPairSolver({
+    inputProblem: netConnectionProblem,
+  })
+  netConnectionSolver.solve()
+
+  expect(directConnectionSolver.mspConnectionPairs).toHaveLength(1)
+  expect(netConnectionSolver.mspConnectionPairs).toHaveLength(0)
+})

package/tests/solvers/SchematicTraceSingleLineSolver2/candidate-mids-from-set.test.ts

@@ -0,0 +1,39 @@
+import { expect, test } from "bun:test"
+import { candidateMidsFromSet } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/mid"
+import type { ObstacleRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+
+test("candidate mids include clearance beyond an open obstacle side", () => {
+  const previousObstacle: ObstacleRect = {
+    kind: "chip",
+    chipId: "U1",
+    minX: -0.9,
+    maxX: 0.9,
+    minY: -2.5,
+    maxY: 2.5,
+  }
+  const collidingObstacle: ObstacleRect = {
+    kind: "text_box",
+    textBox: {
+      center: { x: -0.38, y: 2.615 },
+      width: 0.36,
+      height: 0.25,
+      text: "U1",
+    },
+    minX: -1.01,
+    maxX: 0.25,
+    minY: 2.04,
+    maxY: 3.19,
+  }
+  const aabb = { minX: -0.9, maxX: 2.52, minY: 0.8, maxY: 1 }
+  const collisionRects = new Set([previousObstacle])
+
+  expect(
+    candidateMidsFromSet("y", collidingObstacle, collisionRects, aabb),
+  ).toEqual([1.42])
+
+  expect(
+    candidateMidsFromSet("y", collidingObstacle, collisionRects, aabb, {
+      allowOpenSideCandidates: true,
+    }),
+  ).toEqual([1.42, 3.39])
+})

package/tests/solvers/SchematicTraceSingleLineSolver2/generate-endpoint-collision-detours.test.ts

@@ -0,0 +1,38 @@
+import { expect, test } from "bun:test"
+import { generateEndpointCollisionDetours } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/generateEndpointCollisionDetours"
+
+test("endpoint collision detours preserve both endpoint anchors", () => {
+  const path = [
+    { x: 0, y: 1 },
+    { x: 2, y: 1 },
+    { x: 2, y: -1 },
+  ]
+
+  const obstacle = {
+    minX: 1,
+    maxX: 3,
+    minY: 0,
+    maxY: 2,
+    kind: "chip" as const,
+    chipId: "U1",
+  }
+
+  const detours = [0, 1].flatMap((collidingSegmentIndex) =>
+    generateEndpointCollisionDetours({
+      path,
+      collidingSegmentIndex,
+      obstacle,
+    }),
+  )
+
+  expect(detours.length).toBeGreaterThan(0)
+  expect(
+    detours.every(
+      (detour) =>
+        detour[0]?.x === path[0]?.x &&
+        detour[0]?.y === path[0]?.y &&
+        detour.at(-1)?.x === path.at(-1)?.x &&
+        detour.at(-1)?.y === path.at(-1)?.y,
+    ),
+  ).toBe(true)
+})