@tscircuit/schematic-trace-solver 0.0.29 → 0.0.31

package/dist/index.js

@@ -1137,6 +1137,64 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/TraceOverlapShiftSolver/TraceOverlapIssueSolver/applyJogToTrace.ts
+var applyJogToTerminalSegment = ({
+  pts,
+  segmentIndex: si,
+  offset,
+  JOG_SIZE,
+  EPS: EPS2 = 1e-6
+}) => {
+  if (si !== 0 && si !== pts.length - 2) return;
+  const start = pts[si];
+  const end = pts[si + 1];
+  const isVertical = Math.abs(start.x - end.x) < EPS2;
+  const isHorizontal = Math.abs(start.y - end.y) < EPS2;
+  if (!isVertical && !isHorizontal) return;
+  const segDir = isVertical ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
+  if (si === 0) {
+    if (isVertical) {
+      const jogY = start.y + segDir * JOG_SIZE;
+      pts.splice(
+        1,
+        1,
+        { x: start.x, y: jogY },
+        { x: start.x + offset, y: jogY },
+        { x: end.x + offset, y: end.y }
+      );
+    } else {
+      const jogX = start.x + segDir * JOG_SIZE;
+      pts.splice(
+        1,
+        1,
+        { x: jogX, y: start.y },
+        { x: jogX, y: start.y + offset },
+        { x: end.x, y: end.y + offset }
+      );
+    }
+  } else {
+    if (isVertical) {
+      const jogY = end.y - segDir * JOG_SIZE;
+      pts.splice(
+        si,
+        1,
+        { x: start.x + offset, y: start.y },
+        { x: end.x + offset, y: jogY },
+        { x: end.x, y: jogY }
+      );
+    } else {
+      const jogX = end.x - segDir * JOG_SIZE;
+      pts.splice(
+        si,
+        1,
+        { x: start.x, y: start.y + offset },
+        { x: jogX, y: end.y + offset },
+        { x: jogX, y: end.y }
+      );
+    }
+  }
+};
+
 // lib/solvers/TraceOverlapShiftSolver/TraceOverlapIssueSolver/TraceOverlapIssueSolver.ts
 var TraceOverlapIssueSolver = class extends BaseSolver {
   overlappingTraceSegments;
@@ -1180,33 +1238,30 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
         const current = this.correctedTraceMap[original.mspPairId] ?? original;
         const pts = current.tracePath.map((p) => ({ ...p }));
         const segIdxs = Array.from(segIdxSet).sort((a, b) => a - b);
-        const appliedX = /* @__PURE__ */ new Set();
-        const appliedY = /* @__PURE__ */ new Set();
-        for (const si of segIdxs) {
+        const segIdxsRev = Array.from(segIdxSet).sort((a, b) => a - b).reverse();
+        const JOG_SIZE = this.SHIFT_DISTANCE;
+        for (const si of segIdxsRev) {
           if (si < 0 || si >= pts.length - 1) continue;
-          if (si === 0 || si === pts.length - 2) continue;
-          const start = pts[si];
-          const end = pts[si + 1];
-          const isVertical = Math.abs(start.x - end.x) < EPS2;
-          const isHorizontal = Math.abs(start.y - end.y) < EPS2;
-          if (!isVertical && !isHorizontal) continue;
-          if (isVertical) {
-            if (!appliedX.has(si)) {
+          if (si === 0 || si === pts.length - 2) {
+            applyJogToTerminalSegment({
+              pts,
+              segmentIndex: si,
+              offset,
+              JOG_SIZE,
+              EPS: EPS2
+            });
+          } else {
+            const start = pts[si];
+            const end = pts[si + 1];
+            const isVertical = Math.abs(start.x - end.x) < EPS2;
+            const isHorizontal = Math.abs(start.y - end.y) < EPS2;
+            if (!isVertical && !isHorizontal) continue;
+            if (isVertical) {
               start.x += offset;
-              appliedX.add(si);
-            }
-            if (!appliedX.has(si + 1)) {
               end.x += offset;
-              appliedX.add(si + 1);
-            }
-          } else if (isHorizontal) {
-            if (!appliedY.has(si)) {
+            } else {
               start.y += offset;
-              appliedY.add(si);
-            }
-            if (!appliedY.has(si + 1)) {
               end.y += offset;
-              appliedY.add(si + 1);
             }
           }
         }
@@ -1295,7 +1350,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS2 = 1e-6;
+    const EPS2 = 2e-3;
     const netIds = Object.keys(this.traceNetIslands);
     for (let i = 0; i < netIds.length; i++) {
       for (let j = i + 1; j < netIds.length; j++) {
@@ -1494,10 +1549,11 @@ function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex)
     const pts = solved.tracePath;
     for (let i = 0; i < pts.length - 1; i++) {
       if (pairId === hostPathId && i === hostSegIndex) continue;
-      if (segmentIntersectsRect(pts[i], pts[i + 1], bounds)) return true;
+      if (segmentIntersectsRect(pts[i], pts[i + 1], bounds))
+        return { hasIntersection: true, mspPairId: pairId, segIndex: i };
     }
   }
-  return false;
+  return { hasIntersection: false };
 }
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/host.ts
@@ -1582,14 +1638,16 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
     };
   }
   let pin = null;
+  let pinFacingDirection = null;
   for (const chip of inputProblem.chips) {
     const p = chip.pins.find((pp) => pp.pinId === pinId);
     if (p) {
       pin = { x: p.x, y: p.y };
+      pinFacingDirection = p._facingDirection || getPinDirection(p, chip);
       break;
     }
   }
-  if (!pin) {
+  if (!pin || !pinFacingDirection) {
     return {
       placement: null,
       testedCandidates: [],
@@ -1601,21 +1659,21 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
   const outwardOf = (o) => o === "x+" ? { x: 1, y: 0 } : o === "x-" ? { x: -1, y: 0 } : o === "y+" ? { x: 0, y: 1 } : { x: 0, y: -1 };
   const testedCandidates = [];
   for (const orientation of orientations) {
-    const { width, height } = getDimsForOrientation(orientation);
-    const baseCenter = getCenterFromAnchor(anchor, orientation, width, height);
-    const outward = outwardOf(orientation);
-    const offset = 1e-3;
+    const { width: width2, height: height2 } = getDimsForOrientation(orientation);
+    const baseCenter2 = getCenterFromAnchor(anchor, orientation, width2, height2);
+    const outward2 = outwardOf(orientation);
+    const offset2 = 1e-3;
     const center = {
-      x: baseCenter.x + outward.x * offset,
-      y: baseCenter.y + outward.y * offset
+      x: baseCenter2.x + outward2.x * offset2,
+      y: baseCenter2.y + outward2.y * offset2
     };
-    const bounds = getRectBounds(center, width, height);
+    const bounds = getRectBounds(center, width2, height2);
     const chips = chipObstacleSpatialIndex.getChipsInBounds(bounds);
     if (chips.length > 0) {
       testedCandidates.push({
         center,
-        width,
-        height,
+        width: width2,
+        height: height2,
         bounds,
         anchor,
         orientation,
@@ -1624,16 +1682,17 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
       });
       continue;
     }
-    if (rectIntersectsAnyTrace(
+    const traceIntersectionResult = rectIntersectsAnyTrace(
       bounds,
       inputTraceMap,
       "",
       -1
-    )) {
+    );
+    if (traceIntersectionResult.hasIntersection) {
       testedCandidates.push({
         center,
-        width,
-        height,
+        width: width2,
+        height: height2,
         bounds,
         anchor,
         orientation,
@@ -1644,8 +1703,8 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
     }
     testedCandidates.push({
       center,
-      width,
-      height,
+      width: width2,
+      height: height2,
       bounds,
       anchor,
       orientation,
@@ -1660,17 +1719,39 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
       pinIds: [pinId],
       orientation,
       anchorPoint: anchor,
-      width,
-      height,
+      width: width2,
+      height: height2,
       center
     };
     return { placement, testedCandidates };
   }
-  return {
-    placement: null,
-    testedCandidates,
-    error: "Could not place net label at port without collisions"
+  const fallbackOrientation = pinFacingDirection;
+  const { width, height } = getDimsForOrientation(fallbackOrientation);
+  const baseCenter = getCenterFromAnchor(
+    anchor,
+    fallbackOrientation,
+    width,
+    height
+  );
+  const outward = outwardOf(fallbackOrientation);
+  const offset = 1e-3;
+  const fallbackCenter = {
+    x: baseCenter.x + outward.x * offset,
+    y: baseCenter.y + outward.y * offset
+  };
+  const fallbackPlacement = {
+    globalConnNetId: overlappingSameNetTraceGroup.globalConnNetId,
+    dcConnNetId: void 0,
+    netId: overlappingSameNetTraceGroup.netId,
+    mspConnectionPairIds: [],
+    pinIds: [pinId],
+    orientation: fallbackOrientation,
+    anchorPoint: anchor,
+    width,
+    height,
+    center: fallbackCenter
   };
+  return { placement: fallbackPlacement, testedCandidates };
 }
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver_visualize.ts
@@ -1686,12 +1767,11 @@ function visualizeSingleNetLabelPlacementSolver(solver) {
   const groupStroke = getColorFromString(groupId, 0.9);
   const groupFill = getColorFromString(groupId, 0.5);
   for (const trace of Object.values(solver.inputTraceMap)) {
-    if (trace.globalConnNetId !== groupId) continue;
     const isHost = host ? trace.mspPairId === host.mspPairId : false;
     graphics.lines.push({
-      points: trace.tracePath,
-      strokeColor: isHost ? groupStroke : groupFill,
-      strokeDash: isHost ? void 0 : "4 2"
+      points: trace.tracePath
+      // strokeColor: isHost ? groupStroke : groupFill,
+      // strokeDash: isHost ? undefined : "4 2",
     });
   }
   for (const c of solver.testedCandidates) {
@@ -1863,12 +1943,13 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
               });
               continue;
             }
-            if (rectIntersectsAnyTrace(
+            const traceIntersectionResult = rectIntersectsAnyTrace(
               bounds,
               this.inputTraceMap,
               curr.mspPairId,
               si
-            )) {
+            );
+            if (traceIntersectionResult.hasIntersection) {
               this.testedCandidates.push({
                 center: testCenter,
                 width,

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver.ts

@@ -261,14 +261,13 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
             }
 
             // Trace collision check (ignore the host segment)
-            if (
-              rectIntersectsAnyTrace(
-                bounds,
-                this.inputTraceMap,
-                curr.mspPairId,
-                si,
-              )
-            ) {
+            const traceIntersectionResult = rectIntersectsAnyTrace(
+              bounds,
+              this.inputTraceMap,
+              curr.mspPairId,
+              si,
+            )
+            if (traceIntersectionResult.hasIntersection) {
               this.testedCandidates.push({
                 center: testCenter,
                 width,

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver_visualize.ts

@@ -21,12 +21,11 @@ export function visualizeSingleNetLabelPlacementSolver(
   const groupFill = getColorFromString(groupId, 0.5)
 
   for (const trace of Object.values(solver.inputTraceMap)) {
-    if (trace.globalConnNetId !== groupId) continue
     const isHost = host ? trace.mspPairId === host.mspPairId : false
     graphics.lines!.push({
       points: trace.tracePath,
-      strokeColor: isHost ? groupStroke : groupFill,
-      strokeDash: isHost ? undefined : "4 2",
+      // strokeColor: isHost ? groupStroke : groupFill,
+      // strokeDash: isHost ? undefined : "4 2",
     } as any)
   }
 

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts

@@ -33,13 +33,20 @@ export function rectIntersectsAnyTrace(
   inputTraceMap: Record<MspConnectionPairId, SolvedTracePath>,
   hostPathId?: MspConnectionPairId,
   hostSegIndex?: number,
-): boolean {
+):
+  | {
+      hasIntersection: true
+      mspPairId: MspConnectionPairId
+      segIndex: number
+    }
+  | { hasIntersection: false } {
   for (const [pairId, solved] of Object.entries(inputTraceMap)) {
     const pts = solved.tracePath
     for (let i = 0; i < pts.length - 1; i++) {
       if (pairId === hostPathId && i === hostSegIndex) continue
-      if (segmentIntersectsRect(pts[i]!, pts[i + 1]!, bounds)) return true
+      if (segmentIntersectsRect(pts[i]!, pts[i + 1]!, bounds))
+        return { hasIntersection: true, mspPairId: pairId, segIndex: i }
     }
   }
-  return false
+  return { hasIntersection: false }
 }

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/solvePortOnlyPin.ts

@@ -3,6 +3,7 @@ import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/Ms
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { FacingDirection } from "lib/utils/dir"
 import { ChipObstacleSpatialIndex } from "lib/data-structures/ChipObstacleSpatialIndex"
+import { getPinDirection } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection"
 import type {
   NetLabelPlacement,
   OverlappingSameNetTraceGroup,
@@ -51,16 +52,18 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
     }
   }
 
-  // Find pin coordinates
+  // Find pin coordinates and facing direction
   let pin: { x: number; y: number } | null = null
+  let pinFacingDirection: FacingDirection | null = null
   for (const chip of inputProblem.chips) {
     const p = chip.pins.find((pp) => pp.pinId === pinId)
     if (p) {
       pin = { x: p.x, y: p.y }
+      pinFacingDirection = p._facingDirection || getPinDirection(p, chip)
       break
     }
   }
-  if (!pin) {
+  if (!pin || !pinFacingDirection) {
     return {
       placement: null,
       testedCandidates: [],
@@ -123,14 +126,13 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
     }
 
     // Trace collision check
-    if (
-      rectIntersectsAnyTrace(
-        bounds,
-        inputTraceMap,
-        "" as MspConnectionPairId,
-        -1,
-      )
-    ) {
+    const traceIntersectionResult = rectIntersectsAnyTrace(
+      bounds,
+      inputTraceMap,
+      "" as MspConnectionPairId,
+      -1,
+    )
+    if (traceIntersectionResult.hasIntersection) {
       testedCandidates.push({
         center,
         width,
@@ -172,9 +174,34 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
     return { placement, testedCandidates }
   }
 
-  return {
-    placement: null,
-    testedCandidates,
-    error: "Could not place net label at port without collisions",
+  // If no valid placements found, return placement using pin's facing direction
+  const fallbackOrientation = pinFacingDirection
+  const { width, height } = getDimsForOrientation(fallbackOrientation)
+  const baseCenter = getCenterFromAnchor(
+    anchor,
+    fallbackOrientation,
+    width,
+    height,
+  )
+  const outward = outwardOf(fallbackOrientation)
+  const offset = 1e-3
+  const fallbackCenter = {
+    x: baseCenter.x + outward.x * offset,
+    y: baseCenter.y + outward.y * offset,
   }
+
+  const fallbackPlacement: NetLabelPlacement = {
+    globalConnNetId: overlappingSameNetTraceGroup.globalConnNetId,
+    dcConnNetId: undefined,
+    netId: overlappingSameNetTraceGroup.netId,
+    mspConnectionPairIds: [],
+    pinIds: [pinId],
+    orientation: fallbackOrientation,
+    anchorPoint: anchor,
+    width,
+    height,
+    center: fallbackCenter,
+  }
+
+  return { placement: fallbackPlacement, testedCandidates }
 }

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapIssueSolver/TraceOverlapIssueSolver.ts

@@ -2,6 +2,7 @@ import type { GraphicsObject } from "graphics-debug"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { applyJogToTerminalSegment } from "./applyJogToTrace"
 
 type ConnNetId = string
 
@@ -83,38 +84,39 @@ export class TraceOverlapIssueSolver extends BaseSolver {
 
         const segIdxs = Array.from(segIdxSet).sort((a, b) => a - b)
 
-        // Track per-point adjustments to avoid double-shifting shared joints
-        const appliedX = new Set<number>()
-        const appliedY = new Set<number>()
+        const segIdxsRev = Array.from(segIdxSet)
+          .sort((a, b) => a - b)
+          .reverse()
 
-        for (const si of segIdxs) {
-          if (si < 0 || si >= pts.length - 1) continue
-          // Do not move the first or last segment since they connect directly to pins
-          if (si === 0 || si === pts.length - 2) continue
-          const start = pts[si]!
-          const end = pts[si + 1]!
-          const isVertical = Math.abs(start.x - end.x) < EPS
-          const isHorizontal = Math.abs(start.y - end.y) < EPS
+        const JOG_SIZE = this.SHIFT_DISTANCE
 
-          if (!isVertical && !isHorizontal) continue
+        // Process from end to start to keep indices valid after splicing
+        for (const si of segIdxsRev) {
+          if (si < 0 || si >= pts.length - 1) continue
 
-          if (isVertical) {
-            if (!appliedX.has(si)) {
+          if (si === 0 || si === pts.length - 2) {
+            applyJogToTerminalSegment({
+              pts,
+              segmentIndex: si,
+              offset,
+              JOG_SIZE,
+              EPS,
+            })
+          } else {
+            // Internal segment - shift both points
+            const start = pts[si]!
+            const end = pts[si + 1]!
+            const isVertical = Math.abs(start.x - end.x) < EPS
+            const isHorizontal = Math.abs(start.y - end.y) < EPS
+            if (!isVertical && !isHorizontal) continue
+
+            if (isVertical) {
               start.x += offset
-              appliedX.add(si)
-            }
-            if (!appliedX.has(si + 1)) {
               end.x += offset
-              appliedX.add(si + 1)
-            }
-          } else if (isHorizontal) {
-            if (!appliedY.has(si)) {
+            } else {
+              // Horizontal
               start.y += offset
-              appliedY.add(si)
-            }
-            if (!appliedY.has(si + 1)) {
               end.y += offset
-              appliedY.add(si + 1)
             }
           }
         }

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapIssueSolver/applyJogToTrace.ts

@@ -0,0 +1,76 @@
+import type { Point } from "@tscircuit/math-utils"
+
+export const applyJogToTerminalSegment = ({
+  pts,
+  segmentIndex: si,
+  offset,
+  JOG_SIZE,
+  EPS = 1e-6,
+}: {
+  pts: Point[]
+  segmentIndex: number
+  offset: number
+  JOG_SIZE: number
+  EPS?: number
+}) => {
+  if (si !== 0 && si !== pts.length - 2) return
+
+  const start = pts[si]!
+  const end = pts[si + 1]!
+  const isVertical = Math.abs(start.x - end.x) < EPS
+  const isHorizontal = Math.abs(start.y - end.y) < EPS
+  if (!isVertical && !isHorizontal) return
+
+  const segDir = isVertical
+    ? end.y > start.y
+      ? 1
+      : -1
+    : end.x > start.x
+      ? 1
+      : -1
+
+  if (si === 0) {
+    if (isVertical) {
+      const jogY = start.y + segDir * JOG_SIZE
+      pts.splice(
+        1,
+        1,
+        { x: start.x, y: jogY },
+        { x: start.x + offset, y: jogY },
+        { x: end.x + offset, y: end.y },
+      )
+    } else {
+      // Horizontal
+      const jogX = start.x + segDir * JOG_SIZE
+      pts.splice(
+        1,
+        1,
+        { x: jogX, y: start.y },
+        { x: jogX, y: start.y + offset },
+        { x: end.x, y: end.y + offset },
+      )
+    }
+  } else {
+    // si === pts.length - 2
+    if (isVertical) {
+      const jogY = end.y - segDir * JOG_SIZE
+      pts.splice(
+        si,
+        1,
+        { x: start.x + offset, y: start.y },
+        { x: end.x + offset, y: jogY },
+        { x: end.x, y: jogY },
+      )
+    } else {
+      // Horizontal
+      const jogX = end.x - segDir * JOG_SIZE
+      pts.splice(
+        si,
+        1,
+        { x: start.x, y: start.y + offset },
+        { x: jogX, y: end.y + offset },
+        { x: jogX, y: end.y },
+      )
+    }
+  }
+}

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapShiftSolver.ts

@@ -89,7 +89,7 @@ export class TraceOverlapShiftSolver extends BaseSolver {
     overlappingTraceSegments: Array<OverlappingTraceSegmentLocator>
   } | null {
     // Detect the next set of overlapping segments between two different net islands.
-    const EPS = 1e-6
+    const EPS = 2e-3
 
     const netIds = Object.keys(this.traceNetIslands)
     // Compare each pair of different nets

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/site/SchematicTracePipelineSolver/SchematicTracePipelineSolver02.page.tsx

@@ -0,0 +1,177 @@
+import { GenericSolverDebugger } from "site/components/GenericSolverDebugger"
+import { useMemo } from "react"
+import type { InputProblem } from "lib/types/InputProblem"
+import { SchematicTracePipelineSolver } from "lib/index"
+
+const inputProblem = {
+  chips: [
+    {
+      chipId: "schematic_component_0",
+      center: {
+        x: 0,
+        y: 0,
+      },
+      width: 0.4,
+      height: 0.8,
+      pins: [
+        {
+          pinId: "U1.6",
+          x: 0.6000000000000001,
+          y: -0.2,
+        },
+        {
+          pinId: "U1.8",
+          x: 0.6000000000000001,
+          y: 0,
+        },
+        {
+          pinId: "U1.1",
+          x: 0.6000000000000001,
+          y: 0.2,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_1",
+      center: {
+        x: 1.4,
+        y: 0.55,
+      },
+      width: 0.5291665999999999,
+      height: 1.0583333000000001,
+      pins: [
+        {
+          pinId: "C2.1",
+          x: 1.4002733499999995,
+          y: -0.0012093000000001908,
+        },
+        {
+          pinId: "C2.2",
+          x: 1.3997266500000003,
+          y: 1.1012093000000003,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_2",
+      center: {
+        x: 2.7,
+        y: 1.3,
+      },
+      width: 1.0583332999999997,
+      height: 0.388910699999999,
+      pins: [
+        {
+          pinId: "R1.1",
+          x: 2.1487093,
+          y: 1.3002732499999994,
+        },
+        {
+          pinId: "R1.2",
+          x: 3.2512907000000006,
+          y: 1.2997267500000007,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_3",
+      center: {
+        x: 4.4,
+        y: 0,
+      },
+      width: 0.4,
+      height: 0.4,
+      pins: [
+        {
+          pinId: "JP5.1",
+          x: 3.8000000000000003,
+          y: 0,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_4",
+      center: {
+        x: 4.4,
+        y: -0.9,
+      },
+      width: 0.4,
+      height: 0.4,
+      pins: [
+        {
+          pinId: "JP9.1",
+          x: 3.8000000000000003,
+          y: -0.9,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_5",
+      center: {
+        x: 2,
+        y: -1.1,
+      },
+      width: 0.8843008999999997,
+      height: 0.5299361999999987,
+      pins: [
+        {
+          pinId: "JP8.1",
+          x: 2.4458007999999998,
+          y: -1.2015872704999997,
+        },
+        {
+          pinId: "JP8.2",
+          x: 2.0034928,
+          y: -0.8474009705000005,
+        },
+        {
+          pinId: "JP8.3",
+          x: 1.5541992,
+          y: -1.2014628704999997,
+        },
+      ],
+    },
+  ],
+  directConnections: [
+    {
+      pinIds: ["C2.1", "U1.8"],
+      netId: "capacitor.C2 > port.pin1 to .U1 > .pin8",
+    },
+    {
+      pinIds: ["C2.2", "R1.1"],
+      netId: "capacitor.C2 > port.pin2 to .R1 > .pin1",
+    },
+    {
+      pinIds: ["R1.1", "U1.1"],
+      netId: "resistor.R1 > port.pin1 to .U1 > .pin1",
+    },
+    {
+      pinIds: ["JP5.1", "R1.2"],
+      netId: "pinheader.JP5 > port.pin1 to .R1 > .pin2",
+    },
+    {
+      pinIds: ["JP9.1", "R1.2"],
+      netId: "pinheader.JP9 > port.pin1 to .R1 > .pin2",
+    },
+    {
+      pinIds: ["JP8.2", "U1.6"],
+      netId: "solderjumper.JP8 > port.pin2 to .U1 > .pin6",
+    },
+  ],
+  netConnections: [
+    {
+      netId: "PAD",
+      pinIds: ["R1.2", "JP5.1", "JP9.1"],
+    },
+  ],
+  availableNetLabelOrientations: {},
+  maxMspPairDistance: 5,
+} as InputProblem
+
+export default () => {
+  const solver = useMemo(
+    () => new SchematicTracePipelineSolver(inputProblem),
+    [],
+  )
+  return <GenericSolverDebugger solver={solver} />
+}

package/tests/examples/__snapshots__/example11.snap.svg

@@ -70,7 +70,7 @@ x+" data-x="1.48" data-y="-0.665" cx="516.9811320754716" cy="426.7924528301886"
     <polyline data-points="0.5800000000000001,-0.665 0.1,-0.665 0.1,0.1 -1.6800000000000002,0.1 -1.6800000000000002,0.765 -1.58,0.765" data-type="line" data-label="" points="381.1320754716981,426.7924528301886 308.6792452830188,426.7924528301886 308.6792452830188,311.3207547169811 39.99999999999997,311.3207547169811 39.99999999999997,210.94339622641508 55.09433962264151,210.94339622641508" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
-    <polyline data-points="1.48,-0.665 1.78,-0.665 1.78,0.03527232500000027 0,0.03527232500000027 0,0.765 -0.48,0.765" data-type="line" data-label="" points="516.9811320754716,426.7924528301886 562.2641509433961,426.7924528301886 562.2641509433961,321.0909698113207 293.58490566037733,321.0909698113207 293.58490566037733,210.94339622641508 221.1320754716981,210.94339622641508" fill="none" stroke="purple" stroke-width="1" />
+    <polyline data-points="1.48,-0.665 1.78,-0.665 1.78,0.03527232500000027 0,0.03527232500000027 0,0.865 -0.38,0.865 -0.38,0.765 -0.48,0.765" data-type="line" data-label="" points="516.9811320754716,426.7924528301886 562.2641509433961,426.7924528301886 562.2641509433961,321.0909698113207 293.58490566037733,321.0909698113207 293.58490566037733,195.84905660377356 236.2264150943396,195.84905660377356 236.2264150943396,210.94339622641508 221.1320754716981,210.94339622641508" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
     <rect data-type="rect" data-label="schematic_component_0" data-x="-1.03" data-y="0.765" x="55.09433962264151" y="181.59164528301895" width="166.0377358490566" height="58.70350188679228" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.006625000000000001" />

package/tests/examples/__snapshots__/example16.snap.svg

@@ -0,0 +1,195 @@
+<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>
+    <circle data-type="point" data-label="U1.6
+x+" data-x="0.6000000000000001" data-y="-0.2" cx="160.00000000000003" cy="359.23793250000006" r="3" fill="hsl(324, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U1.8
+x+" data-x="0.6000000000000001" data-y="0" cx="160.00000000000003" cy="339.23793250000006" r="3" fill="hsl(326, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U1.1
+x+" data-x="0.6000000000000001" data-y="0.2" cx="160.00000000000003" cy="319.23793250000006" r="3" fill="hsl(319, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="C2.1
+y-" data-x="1.4002733499999995" data-y="-0.0012093000000001908" cx="240.027335" cy="339.3588625000001" r="3" fill="hsl(2, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="C2.2
+y+" data-x="1.3997266500000003" data-y="1.1012093000000003" cx="239.97266500000006" cy="229.1170025" r="3" fill="hsl(3, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="R1.1
+x-" data-x="2.1487092999999997" data-y="1.3002732499999994" cx="314.87093" cy="209.21060750000012" r="3" fill="hsl(226, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="R1.2
+x+" data-x="3.2512907000000006" data-y="1.2997267500000007" cx="425.12907000000007" cy="209.2652575" r="3" fill="hsl(227, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="JP5.1
+x-" data-x="3.8000000000000003" data-y="0" cx="480" cy="339.23793250000006" r="3" fill="hsl(242, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="JP9.1
+x-" data-x="3.8000000000000003" data-y="-0.9" cx="480" cy="429.23793250000006" r="3" fill="hsl(126, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="JP8.1
+x+" data-x="2.4458007999999998" data-y="-1.2015872704999997" cx="344.58008" cy="459.39665955000004" r="3" fill="hsl(245, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="JP8.2
+y+" data-x="2.0034928" data-y="-0.8350319000000007" cx="300.34928" cy="422.74112250000013" r="3" fill="hsl(246, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="JP8.3
+x-" data-x="1.5541992" data-y="-1.2014628704999997" cx="255.41992000000002" cy="459.38421955" r="3" fill="hsl(247, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="" data-x="1.4002733499999995" data-y="-0.30120930000000024" cx="240.027335" cy="369.3588625000001" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="" data-x="0.733854175" data-y="0.2" cx="173.38541750000002" cy="319.23793250000006" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="" data-x="3.451290700000001" data-y="1.2997267500000007" cx="445.12907000000007" cy="209.2652575" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="" data-x="2.0034928" data-y="-0.46751595000000035" cx="300.34928" cy="385.9895275000001" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+  </g>
+  <g>
+    <polyline data-points="1.4002733499999995,-0.0012093000000001908 0.6000000000000001,0" data-type="line" data-label="" points="240.027335,339.3588625000001 160.00000000000003,339.23793250000006" fill="none" stroke="hsl(256, 100%, 50%, 0.8)" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="1.3997266500000003,1.1012093000000003 2.1487092999999997,1.3002732499999994" data-type="line" data-label="" points="239.97266500000006,229.1170025 314.87093,209.21060750000012" fill="none" stroke="hsl(256, 100%, 50%, 0.8)" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="2.1487092999999997,1.3002732499999994 0.6000000000000001,0.2" data-type="line" data-label="" points="314.87093,209.21060750000012 160.00000000000003,319.23793250000006" fill="none" stroke="hsl(280, 100%, 50%, 0.8)" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="3.8000000000000003,0 3.2512907000000006,1.2997267500000007" data-type="line" data-label="" points="480,339.23793250000006 425.12907000000007,209.2652575" fill="none" stroke="hsl(336, 100%, 50%, 0.8)" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="3.8000000000000003,-0.9 3.2512907000000006,1.2997267500000007" data-type="line" data-label="" points="480,429.23793250000006 425.12907000000007,209.2652575" fill="none" stroke="hsl(336, 100%, 50%, 0.8)" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="2.0034928,-0.8350319000000007 0.6000000000000001,-0.2" data-type="line" data-label="" points="300.34928,422.74112250000013 160.00000000000003,359.23793250000006" fill="none" stroke="hsl(352, 100%, 50%, 0.8)" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="3.2512907000000006,1.2997267500000007 3.8000000000000003,0" data-type="line" data-label="" points="425.12907000000007,209.2652575 480,339.23793250000006" fill="none" stroke="hsl(123, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
+  </g>
+  <g>
+    <polyline data-points="3.2512907000000006,1.2997267500000007 3.8000000000000003,-0.9" data-type="line" data-label="" points="425.12907000000007,209.2652575 480,429.23793250000006" fill="none" stroke="hsl(123, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
+  </g>
+  <g>
+    <polyline data-points="3.8000000000000003,0 3.8000000000000003,-0.9" data-type="line" data-label="" points="480,339.23793250000006 480,429.23793250000006" fill="none" stroke="hsl(123, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
+  </g>
+  <g>
+    <polyline data-points="1.4002733499999995,-0.0012093000000001908 1.4002733499999995,-0.30120930000000024 1.0001366749999998,-0.30120930000000024 1.0001366749999998,0 0.6000000000000001,0" data-type="line" data-label="" points="240.027335,339.3588625000001 240.027335,369.3588625000001 200.0136675,369.3588625000001 200.0136675,339.23793250000006 160.00000000000003,339.23793250000006" fill="none" stroke="purple" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="2.1487092999999997,1.3002732499999994 1.3997266500000003,1.3002732499999994 1.3997266500000003,1.1012093000000003" data-type="line" data-label="" points="314.87093,209.21060750000012 239.97266500000006,209.21060750000012 239.97266500000006,229.1170025" fill="none" stroke="purple" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="0.6000000000000001,0.2 0.86770835,0.2 0.86770835,1.1033769750000004 1.3997266500000003,1.1033769750000004 1.3997266500000003,1.1012093000000003" data-type="line" data-label="" points="160.00000000000003,319.23793250000006 186.77083500000003,319.23793250000006 186.77083500000003,228.900235 239.97266500000006,228.900235 239.97266500000006,229.1170025" fill="none" stroke="purple" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="3.8000000000000003,-0.9 3.6000000000000005,-0.9 3.6000000000000005,0 3.8000000000000003,0" data-type="line" data-label="" points="480,429.23793250000006 460.0000000000001,429.23793250000006 460.0000000000001,339.23793250000006 480,339.23793250000006" fill="none" stroke="purple" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="3.2512907000000006,1.2997267500000007 3.451290700000001,1.2997267500000007 3.5256453500000005,1.2997267500000007 3.5256453500000005,0 3.6,0 3.8000000000000003,0" data-type="line" data-label="" points="425.12907000000007,209.2652575 445.12907000000007,209.2652575 452.5645350000001,209.2652575 452.5645350000001,339.23793250000006 460,339.23793250000006 480,339.23793250000006" fill="none" stroke="purple" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="2.0034928,-0.8350319000000007 2.0034928,-0.1 0.7000000000000001,-0.1 0.7000000000000001,-0.2 0.6000000000000001,-0.2" data-type="line" data-label="" points="300.34928,422.74112250000013 300.34928,349.23793250000006 170.00000000000003,349.23793250000006 170.00000000000003,359.23793250000006 160.00000000000003,359.23793250000006" fill="none" stroke="purple" stroke-width="1" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="schematic_component_0" data-x="0" data-y="0" x="40.00000000000002" y="299.23793250000006" width="120" height="80" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.01" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="schematic_component_1" data-x="1.4" data-y="0.55" x="213.54167" y="229.1170025" width="52.916660000000036" height="110.24186000000009" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.01" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="schematic_component_2" data-x="2.7" data-y="1.3" x="314.87093" y="189.7923975000001" width="110.25814000000008" height="38.8910699999999" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.01" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="schematic_component_3" data-x="4.4" data-y="0" x="480" y="319.23793250000006" width="120" height="40" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.01" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="schematic_component_4" data-x="4.4" data-y="-0.9" x="480" y="409.23793250000006" width="120" height="40" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.01" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="schematic_component_5" data-x="2" data-y="-1.1" x="255.41992000000002" y="422.74112250000013" width="89.16015999999999" height="52.99361999999991" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.01" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="" data-x="1.6252733499999996" data-y="-0.30120930000000024" x="240.027335" y="359.3588625000001" width="45" height="20" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.01" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="" data-x="0.733854175" data-y="0.42500000000000004" x="163.38541750000005" y="274.23793250000006" width="19.99999999999997" height="45" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.01" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="" data-x="3.451290700000001" data-y="1.5247267500000008" x="435.12907000000007" y="164.26525749999996" width="20" height="45.00000000000003" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.01" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="" data-x="2.2284928" data-y="-0.46751595000000035" x="300.34928" y="375.9895275000001" width="45" height="19.999999999999943" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.01" />
+  </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": 100,
+        "c": 0,
+        "e": 100.00000000000003,
+        "b": 0,
+        "d": -100,
+        "f": 339.23793250000006
+      };
+      // 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/examples/example14.test.tsx

@@ -1,7 +1,6 @@
 import { expect, test } from "bun:test"
 import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
 import { inputProblem } from "site/examples/example14.page"
-import "tests/fixtures/matcher"
 
 test.skip("example14 - should fail with net label placement collision error", () => {
   const solver = new SchematicTracePipelineSolver(inputProblem)

package/tests/examples/example16.test.tsx

@@ -0,0 +1,175 @@
+import { expect } from "bun:test"
+import { test } from "bun:test"
+import { SchematicTracePipelineSolver, type InputProblem } from "lib/index"
+import "tests/fixtures/matcher"
+
+const inputProblem = {
+  chips: [
+    {
+      chipId: "schematic_component_0",
+      center: {
+        x: 0,
+        y: 0,
+      },
+      width: 0.4,
+      height: 0.8,
+      pins: [
+        {
+          pinId: "U1.6",
+          x: 0.6000000000000001,
+          y: -0.2,
+        },
+        {
+          pinId: "U1.8",
+          x: 0.6000000000000001,
+          y: 0,
+        },
+        {
+          pinId: "U1.1",
+          x: 0.6000000000000001,
+          y: 0.2,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_1",
+      center: {
+        x: 1.4,
+        y: 0.55,
+      },
+      width: 0.5291665999999999,
+      height: 1.0583333000000001,
+      pins: [
+        {
+          pinId: "C2.1",
+          x: 1.4002733499999995,
+          y: -0.0012093000000001908,
+        },
+        {
+          pinId: "C2.2",
+          x: 1.3997266500000003,
+          y: 1.1012093000000003,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_2",
+      center: {
+        x: 2.7,
+        y: 1.3,
+      },
+      width: 1.0583332999999997,
+      height: 0.388910699999999,
+      pins: [
+        {
+          pinId: "R1.1",
+          x: 2.1487093,
+          y: 1.3002732499999994,
+        },
+        {
+          pinId: "R1.2",
+          x: 3.2512907000000006,
+          y: 1.2997267500000007,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_3",
+      center: {
+        x: 4.4,
+        y: 0,
+      },
+      width: 0.4,
+      height: 0.4,
+      pins: [
+        {
+          pinId: "JP5.1",
+          x: 3.8000000000000003,
+          y: 0,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_4",
+      center: {
+        x: 4.4,
+        y: -0.9,
+      },
+      width: 0.4,
+      height: 0.4,
+      pins: [
+        {
+          pinId: "JP9.1",
+          x: 3.8000000000000003,
+          y: -0.9,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_5",
+      center: {
+        x: 2,
+        y: -1.1,
+      },
+      width: 0.8843008999999997,
+      height: 0.5299361999999987,
+      pins: [
+        {
+          pinId: "JP8.1",
+          x: 2.4458007999999998,
+          y: -1.2015872704999997,
+        },
+        {
+          pinId: "JP8.2",
+          x: 2.0034928,
+          y: -0.8474009705000005,
+        },
+        {
+          pinId: "JP8.3",
+          x: 1.5541992,
+          y: -1.2014628704999997,
+        },
+      ],
+    },
+  ],
+  directConnections: [
+    {
+      pinIds: ["C2.1", "U1.8"],
+      netId: "capacitor.C2 > port.pin1 to .U1 > .pin8",
+    },
+    {
+      pinIds: ["C2.2", "R1.1"],
+      netId: "capacitor.C2 > port.pin2 to .R1 > .pin1",
+    },
+    {
+      pinIds: ["R1.1", "U1.1"],
+      netId: "resistor.R1 > port.pin1 to .U1 > .pin1",
+    },
+    {
+      pinIds: ["JP5.1", "R1.2"],
+      netId: "pinheader.JP5 > port.pin1 to .R1 > .pin2",
+    },
+    {
+      pinIds: ["JP9.1", "R1.2"],
+      netId: "pinheader.JP9 > port.pin1 to .R1 > .pin2",
+    },
+    {
+      pinIds: ["JP8.2", "U1.6"],
+      netId: "solderjumper.JP8 > port.pin2 to .U1 > .pin6",
+    },
+  ],
+  netConnections: [
+    {
+      netId: "PAD",
+      pinIds: ["R1.2", "JP5.1", "JP9.1"],
+    },
+  ],
+  availableNetLabelOrientations: {},
+  maxMspPairDistance: 5,
+} as InputProblem
+
+test("example16", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem)
+  solver.solve()
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver01.test.ts

@@ -1,7 +1,6 @@
 import { expect, test } from "bun:test"
 import { SingleNetLabelPlacementSolver } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver"
 import { input } from "site/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver01.page"
-import "tests/fixtures/matcher"
 
 test("SingleNetLabelPlacementSolver01 issue reproduction (should pass)", () => {
   const solver = new SingleNetLabelPlacementSolver(input as any)
@@ -9,5 +8,5 @@ test("SingleNetLabelPlacementSolver01 issue reproduction (should pass)", () => {
   solver.solve()
 
   // TODO: Fix the test
-  // expect(solver.solved).toBe(true)
+  expect(solver.solved).toBe(true)
 })