@tscircuit/schematic-trace-solver 0.0.147 → 0.0.149

package/tests/repros/repro-core-555-power-cross-net-overlap.test.ts

@@ -0,0 +1,136 @@
+import { expect, test } from "bun:test"
+import { doSegmentsIntersect } from "@tscircuit/math-utils"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import "tests/fixtures/matcher"
+
+// Reduced from @tscircuit/core's schematic-section-2 fixture. The BTN_IN trace
+// crosses the GND trace immediately below SW1.
+const inputProblem: InputProblem = {
+  chips: [
+    {
+      chipId: "schematic_component_0",
+      center: { x: -4, y: 3 },
+      width: 1,
+      height: 0.65,
+      pins: [
+        {
+          pinId: "schematic_port_0",
+          x: -4.5,
+          y: 3,
+          _facingDirection: "x-",
+        },
+        {
+          pinId: "schematic_port_1",
+          x: -3.5,
+          y: 3,
+          _facingDirection: "x+",
+        },
+      ],
+      sectionId: "power",
+    },
+    {
+      chipId: "schematic_component_1",
+      center: { x: -2, y: 3 },
+      width: 0.76,
+      height: 0.5,
+      pins: [
+        {
+          pinId: "schematic_port_2",
+          x: -2.38,
+          y: 3,
+          _facingDirection: "x-",
+        },
+        {
+          pinId: "schematic_port_3",
+          x: -1.62,
+          y: 3,
+          _facingDirection: "x+",
+        },
+      ],
+      sectionId: "power",
+    },
+    {
+      chipId: "schematic_component_2",
+      center: { x: -3, y: 1.5 },
+      width: 0.6,
+      height: 0.84,
+      pins: [
+        {
+          pinId: "schematic_port_4",
+          x: -3.3,
+          y: 1.5,
+          _facingDirection: "x-",
+        },
+        {
+          pinId: "schematic_port_5",
+          x: -2.7,
+          y: 1.5,
+          _facingDirection: "x+",
+        },
+      ],
+      sectionId: "power",
+    },
+  ],
+  directConnections: [
+    {
+      netId: ".B1 > .pin1 to .SW1 > .pin1",
+      allowInlineNetLabel: true,
+      inlineNetLabelHeight: 0.12,
+      inlineNetLabelWidth: 0.56,
+      pinIds: ["schematic_port_0", "schematic_port_2"],
+    },
+  ],
+  netConnections: [
+    {
+      netId: "GND",
+      netLabelWidth: 0.42,
+      netLabelHeight: 0.48,
+      pinIds: ["schematic_port_1", "schematic_port_5"],
+    },
+    {
+      netId: "VCC",
+      netLabelWidth: 0.42,
+      netLabelHeight: 0.48,
+      pinIds: ["schematic_port_3", "schematic_port_4"],
+    },
+  ],
+  textBoxes: [],
+  availableNetLabelOrientations: {
+    VCC: ["y+"],
+    GND: ["y-"],
+  },
+  maxMspPairDistance: 2.4,
+  _hideRatsNet: false,
+}
+
+test("core 555 power section avoids a cross-net overlap below SW1", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem)
+
+  solver.solve()
+
+  const traces = solver.sameNetJunctionAlignmentSolver!.outputTraces
+  const btnTrace = traces.find(
+    (trace) => trace.mspPairId === "schematic_port_0-schematic_port_2",
+  )!
+  const groundTrace = traces.find(
+    (trace) => trace.mspPairId === "schematic_port_1-schematic_port_5",
+  )!
+  const hasIntersection = btnTrace.tracePath
+    .slice(0, -1)
+    .some((start, index) =>
+      groundTrace.tracePath
+        .slice(0, -1)
+        .some((otherStart, otherIndex) =>
+          doSegmentsIntersect(
+            start,
+            btnTrace.tracePath[index + 1]!,
+            otherStart,
+            groundTrace.tracePath[otherIndex + 1]!,
+          ),
+        ),
+    )
+
+  expect(hasIntersection).toBeFalse()
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/repros/repro-core-tb67s579ftg-inline-label-routing.test.ts

@@ -0,0 +1,40 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import inputProblem from "./assets/repro-core-tb67s579ftg-inline-label-routing.input.json"
+import "tests/fixtures/matcher"
+
+const getPinPair = (pinIds: string[]): [string, string] => {
+  if (pinIds.length !== 2) {
+    throw new Error(`Expected two pin IDs, received ${pinIds.length}`)
+  }
+
+  return [pinIds[0]!, pinIds[1]!]
+}
+
+// Captured from @tscircuit/core@12b2ef60's TB67S579FTG breakout repro. The
+// fallback widths supplied for inline labels affect the routed traces beside J4.
+test("core TB67S579FTG inline label routing", () => {
+  const solverInput: InputProblem = {
+    ...inputProblem,
+    directConnections: inputProblem.directConnections.map((connection) => ({
+      ...connection,
+      pinIds: getPinPair(connection.pinIds),
+    })),
+  }
+  const solver = new SchematicTracePipelineSolver(solverInput)
+
+  solver.solve()
+
+  expect(
+    solver.schematicTraceLinesSolver!.failedConnectionPairs.map(
+      (connection) => connection.userNetId,
+    ),
+  ).toEqual(["AGC_OUT"])
+  expect(
+    inputProblem.directConnections.find(
+      (connection) => connection.netId === "AGC_OUT",
+    )?.fallbackNetLabelWidth,
+  ).toBe(0.96)
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/solvers/InlineNetLabelSolver/__snapshots__/terminal-stub-trace-clearance.snap.svg

@@ -0,0 +1,53 @@
+<svg width="640" height="640" viewBox="0 0 640 640" xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" fill="white"/><g><polyline data-points="0.5,-0.1 1,-0.1 1,0.5" data-type="line" data-label="" points="413.33333333333337,394.66666666666663 600,394.66666666666663 600,170.66666666666666" fill="none" stroke="purple" stroke-width="1px"/></g><g><polyline data-points="0.5,0.3 0.95,0.3" data-type="line" data-label="" points="413.33333333333337,245.33333333333331 581.3333333333333,245.33333333333331" fill="none" stroke="purple" stroke-width="1px"/></g><g><polyline data-points="0.5,0.1 0.95,0.1" data-type="line" data-label="" points="413.33333333333337,320 581.3333333333333,320" fill="none" stroke="purple" stroke-width="1px"/></g><g><rect data-type="rect" data-label="U1" data-x="0" data-y="0.1" x="40" y="170.66666666666669" width="373.33333333333337" height="298.66666666666663" fill="hsl(164, 100%, 50%, 0.8)" stroke="black" stroke-width="0.0026785714285714286"/></g><g><rect data-type="rect" data-label="INLINE netId: SCL
+axis: x
+side: y+" data-x="0.725" data-y="0.41" x="441.33333333333337" y="181.86666666666667" width="111.99999999999994" height="44.79999999999998" fill="hsl(196, 100%, 50%, 0.35)" stroke="black" stroke-width="0.0026785714285714286"/></g><g><rect data-type="rect" data-label="INLINE netId: SDA
+axis: x
+side: y+" data-x="0.725" data-y="0.21000000000000002" x="441.33333333333337" y="256.5333333333333" width="111.99999999999994" height="44.80000000000001" fill="hsl(216, 100%, 50%, 0.35)" stroke="black" stroke-width="0.0026785714285714286"/></g><text data-type="text" data-label="SCL" data-x="0.575" data-y="0.41" x="441.3333333333333" y="204.26666666666665" fill="green" font-size="44.8" font-family="sans-serif" text-anchor="start" dominant-baseline="central">SCL</text><text data-type="text" data-label="SDA" data-x="0.575" data-y="0.21000000000000002" x="441.3333333333333" y="278.9333333333333" fill="green" font-size="44.8" font-family="sans-serif" text-anchor="start" dominant-baseline="central">SDA</text><g><circle data-type="point" data-label="U1.scl
+x+" data-x="0.5" data-y="0.3" cx="413.33333333333337" cy="245.33333333333331" r="3" fill="hsl(202, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="U1.sda
+x+" data-x="0.5" data-y="0.1" cx="413.33333333333337" cy="320" r="3" fill="hsl(222, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="U1.vcc
+x+" data-x="0.5" data-y="-0.1" cx="413.33333333333337" cy="394.66666666666663" r="3" fill="hsl(196, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="inline anchor
+SCL" data-x="0.725" data-y="0.3" cx="497.3333333333333" cy="245.33333333333331" r="3" fill="green"/></g><g><circle data-type="point" data-label="inline anchor
+SDA" data-x="0.725" data-y="0.1" cx="497.3333333333333" cy="320" r="3" fill="green"/></g><g id="crosshair" style="display: none"><line id="crosshair-h" y1="0" y2="640" stroke="#666" stroke-width="0.5"/><line id="crosshair-v" x1="0" x2="640" stroke="#666" stroke-width="0.5"/><text id="coordinates" font-family="monospace" font-size="12" fill="#666"></text></g><script><![CDATA[
+              document.currentScript.parentElement.addEventListener('mousemove', (e) => {
+                const svg = e.currentTarget;
+                const rect = svg.getBoundingClientRect();
+                const x = e.clientX - rect.left;
+                const y = e.clientY - rect.top;
+                const crosshair = svg.getElementById('crosshair');
+                const h = svg.getElementById('crosshair-h');
+                const v = svg.getElementById('crosshair-v');
+                const coords = svg.getElementById('coordinates');
+                
+                crosshair.style.display = 'block';
+                h.setAttribute('x1', '0');
+                h.setAttribute('x2', '640');
+                h.setAttribute('y1', y);
+                h.setAttribute('y2', y);
+                v.setAttribute('x1', x);
+                v.setAttribute('x2', x);
+                v.setAttribute('y1', '0');
+                v.setAttribute('y2', '640');
+
+                // Calculate real coordinates using inverse transformation
+                const matrix = {"a":373.3333333333333,"c":0,"e":226.66666666666669,"b":0,"d":-373.3333333333333,"f":357.3333333333333};
+                // Manually invert and apply the affine transform
+                // Since we only use translate and scale, we can directly compute:
+                // x' = (x - tx) / sx
+                // y' = (y - ty) / sy
+                const sx = matrix.a;
+                const sy = matrix.d;
+                const tx = matrix.e; 
+                const ty = matrix.f;
+                const realPoint = {
+                  x: (x - tx) / sx,
+                  y: (y - ty) / sy // Flip y back since we used negative scale
+                }
+                
+                coords.textContent = `(${realPoint.x.toFixed(2)}, ${realPoint.y.toFixed(2)})`;
+                coords.setAttribute('x', (x + 5).toString());
+                coords.setAttribute('y', (y - 5).toString());
+              });
+              document.currentScript.parentElement.addEventListener('mouseleave', () => {
+                document.currentScript.parentElement.getElementById('crosshair').style.display = 'none';
+              });
+            ]]></script></svg>

package/tests/solvers/InlineNetLabelSolver/terminal-stub-trace-clearance.test.ts

@@ -0,0 +1,102 @@
+import { expect, test } from "bun:test"
+import { InlineNetLabelSolver } from "lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import "tests/fixtures/matcher"
+
+test("terminal inline-label stubs stop before an unrelated trace", () => {
+  const inputProblem: InputProblem = {
+    chips: [
+      {
+        chipId: "U1",
+        center: { x: 0, y: 0.1 },
+        width: 1,
+        height: 0.8,
+        pins: [
+          { pinId: "U1.scl", x: 0.5, y: 0.3, _facingDirection: "x+" },
+          { pinId: "U1.sda", x: 0.5, y: 0.1, _facingDirection: "x+" },
+          { pinId: "U1.vcc", x: 0.5, y: -0.1, _facingDirection: "x+" },
+        ],
+      },
+    ],
+    directConnections: [],
+    netConnections: [
+      {
+        netId: "SCL",
+        pinIds: ["U1.scl"],
+        allowInlineNetLabel: true,
+        inlineNetLabelWidth: 0.3,
+        inlineNetLabelHeight: 0.12,
+      },
+      {
+        netId: "SDA",
+        pinIds: ["U1.sda"],
+        allowInlineNetLabel: true,
+        inlineNetLabelWidth: 0.3,
+        inlineNetLabelHeight: 0.12,
+      },
+    ],
+    availableNetLabelOrientations: {
+      SCL: ["x+"],
+      SDA: ["x+"],
+    },
+  }
+  const netLabelPlacements: NetLabelPlacement[] = [
+    {
+      globalConnNetId: "SCL",
+      netId: "SCL",
+      mspConnectionPairIds: [],
+      pinIds: ["U1.scl"],
+      orientation: "x+",
+      anchorPoint: { x: 0.5, y: 0.3 },
+      center: { x: 0.8, y: 0.3 },
+      width: 0.3,
+      height: 0.12,
+    },
+    {
+      globalConnNetId: "SDA",
+      netId: "SDA",
+      mspConnectionPairIds: [],
+      pinIds: ["U1.sda"],
+      orientation: "x+",
+      anchorPoint: { x: 0.5, y: 0.1 },
+      center: { x: 0.8, y: 0.1 },
+      width: 0.3,
+      height: 0.12,
+    },
+  ]
+  const traces: SolvedTracePath[] = [
+    {
+      mspPairId: "available-net-orientation-VCC",
+      dcConnNetId: "VCC",
+      globalConnNetId: "VCC",
+      pins: [] as any,
+      tracePath: [
+        { x: 0.5, y: -0.1 },
+        { x: 1, y: -0.1 },
+        { x: 1, y: 0.5 },
+      ],
+      mspConnectionPairIds: [],
+      pinIds: ["U1.vcc"],
+    },
+  ]
+
+  const solver = new InlineNetLabelSolver({
+    inputProblem,
+    traces,
+    netLabelPlacements,
+  })
+  solver.solve()
+
+  const placements = solver.getOutput().inlineNetLabelPlacements
+  expect(placements).toHaveLength(2)
+  for (const placement of placements) {
+    const [start, end] = placement.stubTracePath!
+    expect(end.x).toBeCloseTo(0.95)
+    expect(end.x).toBeLessThan(1)
+    expect(end.x - start.x).toBeGreaterThanOrEqual(placement.width + 0.1)
+  }
+
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})