@tscircuit/schematic-trace-solver 0.0.3 → 0.0.5

package/README.md

@@ -76,4 +76,6 @@ const solver = new SchematicTracePipelineSolver({
     GND: ["y+", "y-"],
   },
 })
+
+solver.solve()
 ```

package/cosmos.config.json

@@ -2,5 +2,6 @@
   "$schema": "http://json.schemastore.org/cosmos-config",
   "plugins": ["react-cosmos-plugin-vite"],
   "fixtureFileSuffix": "page",
-  "decoratorFile": "cosmos.decorator.tsx"
+  "decoratorFile": "cosmos.decorator.tsx",
+  "port": 5020
 }

package/dist/index.d.ts

@@ -85,6 +85,7 @@ interface InputProblem {
     directConnections: Array<InputDirectConnection>;
     netConnections: Array<InputNetConnection>;
     availableNetLabelOrientations: Record<NetId, FacingDirection[]>;
+    maxMspPairDistance?: number;
     _chipObstacleSpatialIndex?: ChipObstacleSpatialIndex;
 }
 
@@ -107,6 +108,7 @@ declare class MspConnectionPairSolver extends BaseSolver {
     globalConnMap: ConnectivityMap;
     queuedDcNetIds: string[];
     chipMap: Record<string, InputChip>;
+    maxMspPairDistance: number;
     pinMap: Record<string, InputPin & {
         chipId: string;
     }>;
@@ -339,7 +341,8 @@ declare class SingleNetLabelPlacementSolver extends BaseSolver {
 type OverlappingSameNetTraceGroup = {
     globalConnNetId: string;
     netId?: string;
-    overlappingTraces: SolvedTracePath;
+    overlappingTraces?: SolvedTracePath;
+    portOnlyPinId?: string;
 };
 interface NetLabelPlacement {
     globalConnNetId: string;

package/dist/index.js

@@ -5274,8 +5274,9 @@ var getConnectivityMapsFromInputProblem = (inputProblem) => {
 };
 
 // lib/solvers/MspConnectionPairSolver/getMspConnectionPairsFromPins.ts
-function getOrthogonalMinimumSpanningTree(pins) {
+function getOrthogonalMinimumSpanningTree(pins, opts = {}) {
   const n = pins.length;
+  const maxDistance = opts?.maxDistance ?? Number.POSITIVE_INFINITY;
   if (n <= 1) return [];
   {
     const seen = /* @__PURE__ */ new Set();
@@ -5316,7 +5317,8 @@ function getOrthogonalMinimumSpanningTree(pins) {
     }
     for (let v = 0; v < n; v++) {
       if (!inTree[v]) {
-        const d = manhattan(pins[u], pins[v]);
+        const d0 = manhattan(pins[u], pins[v]);
+        const d = d0 > maxDistance ? Number.POSITIVE_INFINITY : d0;
         if (d < bestDist[v] || d === bestDist[v] && pins[u].pinId < pins[parent[v]]?.pinId) {
           bestDist[v] = d;
           parent[v] = u;
@@ -5335,6 +5337,36 @@ var getColorFromString = (string, alpha = 1) => {
   return `hsl(${hash % 360}, 100%, 50%, ${alpha})`;
 };
 
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection.ts
+var getPinDirection = (pin, chip) => {
+  const { x, y } = pin;
+  const { center, width, height } = chip;
+  const yPlusEdge = center.y + height / 2;
+  const yMinusEdge = center.y - height / 2;
+  const xPlusEdge = center.x + width / 2;
+  const xMinusEdge = center.x - width / 2;
+  const yPlusDistance = yPlusEdge - y;
+  const yMinusDistance = y - yMinusEdge;
+  const xPlusDistance = xPlusEdge - x;
+  const xMinusDistance = x - xMinusEdge;
+  const minDistance = Math.min(
+    yPlusDistance,
+    yMinusDistance,
+    xPlusDistance,
+    xMinusDistance
+  );
+  if (minDistance === yPlusDistance) {
+    return "y+";
+  }
+  if (minDistance === yMinusDistance) {
+    return "y-";
+  }
+  if (minDistance === xPlusDistance) {
+    return "x+";
+  }
+  return "x-";
+};
+
 // lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem.ts
 var visualizeInputProblem = (inputProblem, opts = {}) => {
   const { connectionAlpha = 0.8, chipAlpha = 0.8 } = opts;
@@ -5359,7 +5391,8 @@ var visualizeInputProblem = (inputProblem, opts = {}) => {
     });
     for (const pin of chip.pins) {
       graphics.points.push({
-        label: pin.pinId,
+        label: `${pin.pinId}
+${pin._facingDirection ?? getPinDirection(pin, chip)}`,
         x: pin.x,
         y: pin.y,
         color: getColorFromString(pin.pinId, 0.8)
@@ -5415,11 +5448,13 @@ var MspConnectionPairSolver = class extends BaseSolver {
   globalConnMap;
   queuedDcNetIds;
   chipMap;
+  maxMspPairDistance;
   pinMap;
   userNetIdByPinId;
   constructor({ inputProblem }) {
     super();
     this.inputProblem = inputProblem;
+    this.maxMspPairDistance = inputProblem.maxMspPairDistance ?? 1;
     const { directConnMap, netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
     this.dcConnMap = directConnMap;
     this.globalConnMap = netConnMap;
@@ -5477,7 +5512,8 @@ var MspConnectionPairSolver = class extends BaseSolver {
       return;
     }
     const msp = getOrthogonalMinimumSpanningTree(
-      directlyConnectedPins.map((p) => this.pinMap[p])
+      directlyConnectedPins.map((p) => this.pinMap[p]),
+      { maxDistance: this.maxMspPairDistance }
     );
     for (const [pin1, pin2] of msp) {
       const globalConnNetId = this.globalConnMap.getNetConnectedToId(pin1);
@@ -6463,36 +6499,6 @@ var calculateElbow = (point1, point2, options = {}) => {
   return orderFlipped ? result.reverse() : result;
 };
 
-// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection.ts
-var getPinDirection = (pin, chip) => {
-  const { x, y } = pin;
-  const { center, width, height } = chip;
-  const yPlusEdge = center.y + height / 2;
-  const yMinusEdge = center.y - height / 2;
-  const xPlusEdge = center.x + width / 2;
-  const xMinusEdge = center.x - width / 2;
-  const yPlusDistance = Math.abs(y - yPlusEdge);
-  const yMinusDistance = Math.abs(y - yMinusEdge);
-  const xPlusDistance = Math.abs(x - xPlusEdge);
-  const xMinusDistance = Math.abs(x - xMinusEdge);
-  const minDistance = Math.min(
-    yPlusDistance,
-    yMinusDistance,
-    xPlusDistance,
-    xMinusDistance
-  );
-  if (minDistance === yPlusDistance) {
-    return "y+";
-  }
-  if (minDistance === yMinusDistance) {
-    return "y-";
-  }
-  if (minDistance === xPlusDistance) {
-    return "x+";
-  }
-  return "x-";
-};
-
 // lib/utils/dir.ts
 var dir = (facingDirection) => {
   switch (facingDirection) {
@@ -6893,6 +6899,7 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
         const appliedY = /* @__PURE__ */ new Set();
         for (const si of segIdxs) {
           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) < EPS;
@@ -7230,6 +7237,92 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
       this.solved = true;
       return;
     }
+    if (this.overlappingSameNetTraceGroup.portOnlyPinId) {
+      const pinId = this.overlappingSameNetTraceGroup.portOnlyPinId;
+      let pin = null;
+      for (const chip of this.inputProblem.chips) {
+        const p = chip.pins.find((pp) => pp.pinId === pinId);
+        if (p) {
+          pin = { x: p.x, y: p.y };
+          break;
+        }
+      }
+      if (!pin) {
+        this.failed = true;
+        this.error = `Port-only pin not found: ${pinId}`;
+        return;
+      }
+      const orientations2 = this.availableOrientations.length > 0 ? this.availableOrientations : ["x+", "x-", "y+", "y-"];
+      const anchor = { x: pin.x, y: pin.y };
+      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 };
+      for (const orientation of orientations2) {
+        const { width, height } = this.getDimsForOrientation(orientation);
+        const baseCenter = this.getCenterFromAnchor(
+          anchor,
+          orientation,
+          width,
+          height
+        );
+        const outward = outwardOf(orientation);
+        const offset = 1e-3;
+        const center = {
+          x: baseCenter.x + outward.x * offset,
+          y: baseCenter.y + outward.y * offset
+        };
+        const bounds = this.getRectBounds(center, width, height);
+        const chips = this.chipObstacleSpatialIndex.getChipsInBounds(bounds);
+        if (chips.length > 0) {
+          this.testedCandidates.push({
+            center,
+            width,
+            height,
+            bounds,
+            anchor,
+            orientation,
+            status: "chip-collision",
+            hostSegIndex: -1
+          });
+          continue;
+        }
+        if (this.rectIntersectsAnyTrace(bounds, "", -1)) {
+          this.testedCandidates.push({
+            center,
+            width,
+            height,
+            bounds,
+            anchor,
+            orientation,
+            status: "trace-collision",
+            hostSegIndex: -1
+          });
+          continue;
+        }
+        this.testedCandidates.push({
+          center,
+          width,
+          height,
+          bounds,
+          anchor,
+          orientation,
+          status: "ok",
+          hostSegIndex: -1
+        });
+        this.netLabelPlacement = {
+          globalConnNetId: this.overlappingSameNetTraceGroup.globalConnNetId,
+          dcConnNetId: void 0,
+          orientation,
+          anchorPoint: anchor,
+          width,
+          height,
+          center
+        };
+        this.solved = true;
+        return;
+      }
+      this.failed = true;
+      this.error = "Could not place net label at port without collisions";
+      return;
+    }
     const groupId = this.overlappingSameNetTraceGroup.globalConnNetId;
     const chipsById = Object.fromEntries(
       this.inputProblem.chips.map((c) => [c.chipId, c])
@@ -7264,8 +7357,13 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
       (t) => t.pins[0].chipId === largestChipId || t.pins[1].chipId === largestChipId
     );
     let host = hostCandidates.length > 0 ? hostCandidates.reduce((a, b) => lengthOf(a) >= lengthOf(b) ? a : b) : this.overlappingSameNetTraceGroup.overlappingTraces;
+    if (!host) {
+      this.failed = true;
+      this.error = "No host trace found for net label placement";
+      return;
+    }
     let pts = host.tracePath.slice();
-    if (largestChipId) {
+    if (largestChipId && host) {
       const largePin = host.pins[0].chipId === largestChipId ? host.pins[0] : host.pins[1];
       const d0 = Math.abs(pts[0].x - largePin.x) + Math.abs(pts[0].y - largePin.y);
       const dL = Math.abs(pts[pts.length - 1].x - largePin.x) + Math.abs(pts[pts.length - 1].y - largePin.y);
@@ -7404,7 +7502,7 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     const groupFill = getColorFromString(groupId, 0.5);
     for (const trace of Object.values(this.inputTraceMap)) {
       if (trace.globalConnNetId !== groupId) continue;
-      const isHost = trace.mspPairId === host.mspPairId;
+      const isHost = host ? trace.mspPairId === host.mspPairId : false;
       graphics.lines.push({
         points: trace.tracePath,
         strokeColor: isHost ? groupStroke : groupFill,
@@ -7473,32 +7571,100 @@ var NetLabelPlacementSolver = class extends BaseSolver {
       if (!byGlobal[key]) byGlobal[key] = [];
       byGlobal[key].push(trace);
     }
+    const { netConnMap } = getConnectivityMapsFromInputProblem(
+      this.inputProblem
+    );
+    const userNetIdByPinId = {};
+    for (const dc of this.inputProblem.directConnections) {
+      if (dc.netId) {
+        const [a, b] = dc.pinIds;
+        userNetIdByPinId[a] = dc.netId;
+        userNetIdByPinId[b] = dc.netId;
+      }
+    }
+    for (const nc of this.inputProblem.netConnections) {
+      for (const pid of nc.pinIds) {
+        userNetIdByPinId[pid] = nc.netId;
+      }
+    }
     const groups = [];
-    for (const [globalConnNetId, traces] of Object.entries(byGlobal)) {
-      if (traces.length === 0) continue;
-      const lengthOf = (path) => {
-        let sum = 0;
-        const pts = path.tracePath;
-        for (let i = 0; i < pts.length - 1; i++) {
-          sum += Math.abs(pts[i + 1].x - pts[i].x) + Math.abs(pts[i + 1].y - pts[i].y);
-        }
-        return sum;
-      };
-      let rep = traces[0];
-      let repLen = lengthOf(rep);
-      for (let i = 1; i < traces.length; i++) {
-        const len = lengthOf(traces[i]);
-        if (len > repLen) {
-          rep = traces[i];
-          repLen = len;
+    for (const globalConnNetId of Object.keys(netConnMap.netMap)) {
+      const pinsInNet = netConnMap.getIdsConnectedToNet(
+        globalConnNetId
+      );
+      const adj = {};
+      for (const pid of pinsInNet) adj[pid] = /* @__PURE__ */ new Set();
+      for (const t of byGlobal[globalConnNetId] ?? []) {
+        const a = t.pins[0].pinId;
+        const b = t.pins[1].pinId;
+        if (adj[a] && adj[b]) {
+          adj[a].add(b);
+          adj[b].add(a);
+        }
+      }
+      const visited = /* @__PURE__ */ new Set();
+      for (const pid of pinsInNet) {
+        if (visited.has(pid)) continue;
+        const stack = [pid];
+        const component = /* @__PURE__ */ new Set();
+        visited.add(pid);
+        while (stack.length > 0) {
+          const u = stack.pop();
+          component.add(u);
+          for (const v of adj[u] ?? []) {
+            if (!visited.has(v)) {
+              visited.add(v);
+              stack.push(v);
+            }
+          }
+        }
+        const compTraces = (byGlobal[globalConnNetId] ?? []).filter(
+          (t) => component.has(t.pins[0].pinId) && component.has(t.pins[1].pinId)
+        );
+        if (compTraces.length > 0) {
+          const lengthOf = (path) => {
+            let sum = 0;
+            const pts = path.tracePath;
+            for (let i = 0; i < pts.length - 1; i++) {
+              sum += Math.abs(pts[i + 1].x - pts[i].x) + Math.abs(pts[i + 1].y - pts[i].y);
+            }
+            return sum;
+          };
+          let rep = compTraces[0];
+          let repLen = lengthOf(rep);
+          for (let i = 1; i < compTraces.length; i++) {
+            const len = lengthOf(compTraces[i]);
+            if (len > repLen) {
+              rep = compTraces[i];
+              repLen = len;
+            }
+          }
+          let userNetId = compTraces.find((t) => t.userNetId != null)?.userNetId;
+          if (!userNetId) {
+            for (const p of component) {
+              if (userNetIdByPinId[p]) {
+                userNetId = userNetIdByPinId[p];
+                break;
+              }
+            }
+          }
+          groups.push({
+            globalConnNetId,
+            netId: userNetId,
+            overlappingTraces: rep
+          });
+        } else {
+          for (const p of component) {
+            const userNetId = userNetIdByPinId[p];
+            if (!userNetId) continue;
+            groups.push({
+              globalConnNetId,
+              netId: userNetId,
+              portOnlyPinId: p
+            });
+          }
         }
       }
-      const userNetId = traces.find((t) => t.userNetId != null)?.userNetId;
-      groups.push({
-        globalConnNetId,
-        netId: userNetId,
-        overlappingTraces: rep
-      });
     }
     return groups;
   }

package/lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts

@@ -25,6 +25,7 @@ export class MspConnectionPairSolver extends BaseSolver {
   globalConnMap: ConnectivityMap
   queuedDcNetIds: string[]
   chipMap: Record<string, InputChip>
+  maxMspPairDistance: number
 
   pinMap: Record<string, InputPin & { chipId: string }>
   userNetIdByPinId: Record<string, string | undefined>
@@ -33,6 +34,7 @@ export class MspConnectionPairSolver extends BaseSolver {
     super()
 
     this.inputProblem = inputProblem
+    this.maxMspPairDistance = inputProblem.maxMspPairDistance ?? 1
 
     const { directConnMap, netConnMap } =
       getConnectivityMapsFromInputProblem(inputProblem)
@@ -112,6 +114,7 @@ export class MspConnectionPairSolver extends BaseSolver {
 
     const msp = getOrthogonalMinimumSpanningTree(
       directlyConnectedPins.map((p) => this.pinMap[p]!),
+      { maxDistance: this.maxMspPairDistance },
     )
 
     for (const [pin1, pin2] of msp) {

package/lib/solvers/MspConnectionPairSolver/getMspConnectionPairsFromPins.ts

@@ -18,8 +18,10 @@ import type { InputPin, PinId } from "lib/types/InputProblem"
  */
 export function getOrthogonalMinimumSpanningTree(
   pins: InputPin[],
+  opts: { maxDistance?: number } = {},
 ): Array<[PinId, PinId]> {
   const n = pins.length
+  const maxDistance = opts?.maxDistance ?? Number.POSITIVE_INFINITY
   if (n <= 1) return []
 
   // Quick validation (optional; remove if hot path)
@@ -79,7 +81,8 @@ export function getOrthogonalMinimumSpanningTree(
     // Relax edges from u to all v not yet in the tree
     for (let v = 0; v < n; v++) {
       if (!inTree[v]) {
-        const d = manhattan(pins[u], pins[v])
+        const d0 = manhattan(pins[u], pins[v])
+        const d = d0 > maxDistance ? Number.POSITIVE_INFINITY : d0
         if (
           d < bestDist[v] ||
           (d === bestDist[v] && pins[u].pinId < pins[parent[v]]?.pinId)

package/lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver.ts

@@ -8,6 +8,7 @@ import type { Point } from "@tscircuit/math-utils"
 import type { GraphicsObject } from "graphics-debug"
 import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
 import { getColorFromString } from "lib/utils/getColorFromString"
+import { getConnectivityMapsFromInputProblem } from "../MspConnectionPairSolver/getConnectivityMapFromInputProblem"
 
 /**
  * A group of traces that have at least one overlapping segment and
@@ -16,7 +17,8 @@ import { getColorFromString } from "lib/utils/getColorFromString"
 export type OverlappingSameNetTraceGroup = {
   globalConnNetId: string
   netId?: string
-  overlappingTraces: SolvedTracePath
+  overlappingTraces?: SolvedTracePath
+  portOnlyPinId?: string
 }
 
 export interface NetLabelPlacement {
@@ -76,7 +78,7 @@ export class NetLabelPlacementSolver extends BaseSolver {
   }
 
   computeOverlappingSameNetTraceGroups(): Array<OverlappingSameNetTraceGroup> {
-    // Group traces by their global connectivity net id.
+    // Group existing traces by their global connectivity net id.
     const byGlobal: Record<string, Array<SolvedTracePath>> = {}
     for (const trace of Object.values(this.inputTraceMap)) {
       const key = trace.globalConnNetId
@@ -84,35 +86,120 @@ export class NetLabelPlacementSolver extends BaseSolver {
       byGlobal[key].push(trace)
     }
 
-    // For each group, pick a representative path (longest by L1 length).
+    // Build global connectivity from input so we also consider pins with no traces
+    const { netConnMap } = getConnectivityMapsFromInputProblem(
+      this.inputProblem,
+    )
+
+    // Map pins to user-provided netIds (if any)
+    const userNetIdByPinId: Record<string, string | undefined> = {}
+    for (const dc of this.inputProblem.directConnections) {
+      if (dc.netId) {
+        const [a, b] = dc.pinIds
+        userNetIdByPinId[a] = dc.netId
+        userNetIdByPinId[b] = dc.netId
+      }
+    }
+    for (const nc of this.inputProblem.netConnections) {
+      for (const pid of nc.pinIds) {
+        userNetIdByPinId[pid] = nc.netId
+      }
+    }
+
     const groups: Array<OverlappingSameNetTraceGroup> = []
-    for (const [globalConnNetId, traces] of Object.entries(byGlobal)) {
-      if (traces.length === 0) continue
-      const lengthOf = (path: SolvedTracePath) => {
-        let sum = 0
-        const pts = path.tracePath
-        for (let i = 0; i < pts.length - 1; i++) {
-          sum +=
-            Math.abs(pts[i + 1]!.x - pts[i]!.x) +
-            Math.abs(pts[i + 1]!.y - pts[i]!.y)
+
+    // Consider every global connectivity net id
+    for (const globalConnNetId of Object.keys((netConnMap as any).netMap)) {
+      const pinsInNet = netConnMap.getIdsConnectedToNet(
+        globalConnNetId,
+      ) as string[]
+
+      // Build adjacency from solved traces (edges)
+      const adj: Record<string, Set<string>> = {}
+      for (const pid of pinsInNet) adj[pid] = new Set()
+      for (const t of byGlobal[globalConnNetId] ?? []) {
+        const a = t.pins[0].pinId
+        const b = t.pins[1].pinId
+        if (adj[a] && adj[b]) {
+          adj[a].add(b)
+          adj[b].add(a)
         }
-        return sum
       }
-      let rep = traces[0]!
-      let repLen = lengthOf(rep)
-      for (let i = 1; i < traces.length; i++) {
-        const len = lengthOf(traces[i]!)
-        if (len > repLen) {
-          rep = traces[i]!
-          repLen = len
+
+      // Find connected components based on trace edges
+      const visited = new Set<string>()
+      for (const pid of pinsInNet) {
+        if (visited.has(pid)) continue
+        const stack = [pid]
+        const component = new Set<string>()
+        visited.add(pid)
+        while (stack.length > 0) {
+          const u = stack.pop()!
+          component.add(u)
+          for (const v of adj[u] ?? []) {
+            if (!visited.has(v)) {
+              visited.add(v)
+              stack.push(v)
+            }
+          }
+        }
+
+        // Collect traces fully inside this component
+        const compTraces = (byGlobal[globalConnNetId] ?? []).filter(
+          (t) =>
+            component.has(t.pins[0].pinId) && component.has(t.pins[1].pinId),
+        )
+
+        if (compTraces.length > 0) {
+          // Choose a representative trace (longest by L1 length)
+          const lengthOf = (path: SolvedTracePath) => {
+            let sum = 0
+            const pts = path.tracePath
+            for (let i = 0; i < pts.length - 1; i++) {
+              sum +=
+                Math.abs(pts[i + 1]!.x - pts[i]!.x) +
+                Math.abs(pts[i + 1]!.y - pts[i]!.y)
+            }
+            return sum
+          }
+          let rep = compTraces[0]!
+          let repLen = lengthOf(rep)
+          for (let i = 1; i < compTraces.length; i++) {
+            const len = lengthOf(compTraces[i]!)
+            if (len > repLen) {
+              rep = compTraces[i]!
+              repLen = len
+            }
+          }
+
+          let userNetId = compTraces.find((t) => t.userNetId != null)?.userNetId
+          if (!userNetId) {
+            for (const p of component) {
+              if (userNetIdByPinId[p]) {
+                userNetId = userNetIdByPinId[p]
+                break
+              }
+            }
+          }
+
+          groups.push({
+            globalConnNetId,
+            netId: userNetId,
+            overlappingTraces: rep,
+          })
+        } else {
+          // No traces in this component: place label at each pin that has a user net id
+          for (const p of component) {
+            const userNetId = userNetIdByPinId[p]
+            if (!userNetId) continue
+            groups.push({
+              globalConnNetId,
+              netId: userNetId,
+              portOnlyPinId: p,
+            })
+          }
         }
       }
-      const userNetId = traces.find((t) => t.userNetId != null)?.userNetId
-      groups.push({
-        globalConnNetId,
-        netId: userNetId,
-        overlappingTraces: rep,
-      })
     }
 
     return groups

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

@@ -172,6 +172,119 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
       return
     }
 
+    // Handle port-only island (no traces) by placing a label at the port
+    if (this.overlappingSameNetTraceGroup.portOnlyPinId) {
+      const pinId = this.overlappingSameNetTraceGroup.portOnlyPinId
+      // Find pin coordinates
+      let pin: { x: number; y: number } | null = null
+      for (const chip of this.inputProblem.chips) {
+        const p = chip.pins.find((pp) => pp.pinId === pinId)
+        if (p) {
+          pin = { x: p.x, y: p.y }
+          break
+        }
+      }
+      if (!pin) {
+        this.failed = true
+        this.error = `Port-only pin not found: ${pinId}`
+        return
+      }
+
+      const orientations =
+        this.availableOrientations.length > 0
+          ? this.availableOrientations
+          : (["x+", "x-", "y+", "y-"] as FacingDirection[])
+
+      const anchor = { x: pin.x, y: pin.y }
+      const outwardOf = (o: FacingDirection) =>
+        o === "x+"
+          ? { x: 1, y: 0 }
+          : o === "x-"
+            ? { x: -1, y: 0 }
+            : o === "y+"
+              ? { x: 0, y: 1 }
+              : { x: 0, y: -1 }
+
+      for (const orientation of orientations) {
+        const { width, height } = this.getDimsForOrientation(orientation)
+        // Place label fully outside the chip: shift center slightly outward
+        const baseCenter = this.getCenterFromAnchor(
+          anchor,
+          orientation,
+          width,
+          height,
+        )
+        const outward = outwardOf(orientation)
+        const offset = 1e-3
+        const center = {
+          x: baseCenter.x + outward.x * offset,
+          y: baseCenter.y + outward.y * offset,
+        }
+        const bounds = this.getRectBounds(center, width, height)
+
+        // Chip collision check
+        const chips = this.chipObstacleSpatialIndex.getChipsInBounds(bounds)
+        if (chips.length > 0) {
+          this.testedCandidates.push({
+            center,
+            width,
+            height,
+            bounds,
+            anchor,
+            orientation,
+            status: "chip-collision",
+            hostSegIndex: -1,
+          })
+          continue
+        }
+
+        // Trace collision check
+        if (
+          this.rectIntersectsAnyTrace(bounds, "" as MspConnectionPairId, -1)
+        ) {
+          this.testedCandidates.push({
+            center,
+            width,
+            height,
+            bounds,
+            anchor,
+            orientation,
+            status: "trace-collision",
+            hostSegIndex: -1,
+          })
+          continue
+        }
+
+        // Found a valid placement
+        this.testedCandidates.push({
+          center,
+          width,
+          height,
+          bounds,
+          anchor,
+          orientation,
+          status: "ok",
+          hostSegIndex: -1,
+        })
+
+        this.netLabelPlacement = {
+          globalConnNetId: this.overlappingSameNetTraceGroup.globalConnNetId,
+          dcConnNetId: undefined,
+          orientation,
+          anchorPoint: anchor,
+          width,
+          height,
+          center,
+        }
+        this.solved = true
+        return
+      }
+
+      this.failed = true
+      this.error = "Could not place net label at port without collisions"
+      return
+    }
+
     // Prefer starting from the trace connected to the "largest" chip (most pins)
     const groupId = this.overlappingSameNetTraceGroup.globalConnNetId
     const chipsById: Record<string, InputChip> = Object.fromEntries(
@@ -218,9 +331,15 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
         ? hostCandidates.reduce((a, b) => (lengthOf(a) >= lengthOf(b) ? a : b))
         : this.overlappingSameNetTraceGroup.overlappingTraces
 
+    if (!host) {
+      this.failed = true
+      this.error = "No host trace found for net label placement"
+      return
+    }
+
     // Ensure we traverse the host path starting at the segment attached to the largest chip's pin
     let pts = host.tracePath.slice()
-    if (largestChipId) {
+    if (largestChipId && host) {
       const largePin =
         host.pins[0].chipId === largestChipId ? host.pins[0] : host.pins[1]
       const d0 =
@@ -312,7 +431,7 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
           }
 
           // Trace collision check (ignore the host segment)
-          if (this.rectIntersectsAnyTrace(bounds, host.mspPairId, si)) {
+          if (this.rectIntersectsAnyTrace(bounds, host!.mspPairId, si)) {
             this.testedCandidates.push({
               center: testCenter,
               width,
@@ -340,7 +459,7 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
 
           this.netLabelPlacement = {
             globalConnNetId: this.overlappingSameNetTraceGroup.globalConnNetId,
-            dcConnNetId: host.dcConnNetId,
+            dcConnNetId: host!.dcConnNetId,
             orientation,
             anchorPoint: anchor,
             width,
@@ -411,7 +530,7 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
 
     for (const trace of Object.values(this.inputTraceMap)) {
       if (trace.globalConnNetId !== groupId) continue
-      const isHost = trace.mspPairId === host.mspPairId
+      const isHost = host ? trace.mspPairId === host.mspPairId : false
       graphics.lines!.push({
         points: trace.tracePath,
         strokeColor: isHost ? groupStroke : groupFill,

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection.ts

@@ -14,10 +14,10 @@ export const getPinDirection = (
   const xMinusEdge = center.x - width / 2
 
   // Which edge is the pin closest to?
-  const yPlusDistance = Math.abs(y - yPlusEdge)
-  const yMinusDistance = Math.abs(y - yMinusEdge)
-  const xPlusDistance = Math.abs(x - xPlusEdge)
-  const xMinusDistance = Math.abs(x - xMinusEdge)
+  const yPlusDistance = yPlusEdge - y
+  const yMinusDistance = y - yMinusEdge
+  const xPlusDistance = xPlusEdge - x
+  const xMinusDistance = x - xMinusEdge
 
   const minDistance = Math.min(
     yPlusDistance,

package/lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem.ts

@@ -1,6 +1,7 @@
 import type { GraphicsObject } from "graphics-debug"
 import type { PinId, InputPin, InputProblem } from "lib/types/InputProblem"
 import { getColorFromString } from "lib/utils/getColorFromString"
+import { getPinDirection } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection"
 
 export const visualizeInputProblem = (
   inputProblem: InputProblem,
@@ -37,7 +38,7 @@ export const visualizeInputProblem = (
 
     for (const pin of chip.pins) {
       graphics.points.push({
-        label: pin.pinId,
+        label: `${pin.pinId}\n${pin._facingDirection ?? getPinDirection(pin, chip)}`,
         x: pin.x,
         y: pin.y,
         color: getColorFromString(pin.pinId, 0.8),

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

@@ -89,6 +89,8 @@ export class TraceOverlapIssueSolver extends BaseSolver {
 
         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

package/lib/types/InputProblem.ts

@@ -35,6 +35,7 @@ export interface InputProblem {
   netConnections: Array<InputNetConnection>
 
   availableNetLabelOrientations: Record<NetId, FacingDirection[]>
+  maxMspPairDistance?: number
 
   _chipObstacleSpatialIndex?: ChipObstacleSpatialIndex
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "type": "module",
   "scripts": {
     "start": "cosmos",
@@ -10,6 +10,7 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.2.2",
+    "@react-hook/resize-observer": "^2.0.2",
     "@tscircuit/math-utils": "^0.0.19",
     "@types/bun": "latest",
     "calculate-elbow": "^0.0.10",
@@ -19,8 +20,7 @@
     "react-cosmos": "^7.0.0",
     "react-cosmos-plugin-vite": "^7.0.0",
     "tsup": "^8.5.0",
-    "vite": "^7.1.3",
-    "@react-hook/resize-observer": "^2.0.2"
+    "vite": "^7.1.3"
   },
   "peerDependencies": {
     "typescript": "^5"

package/site/examples/example01-basic.page.tsx

@@ -99,6 +99,7 @@ const inputProblem: InputProblem = {
     EN: ["x+", "x-"],
     GND: ["y+", "y-"],
   },
+  maxMspPairDistance: 2,
 }
 
 export default () => <PipelineDebugger inputProblem={inputProblem} />

package/site/examples/example02.page.tsx

@@ -0,0 +1,182 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import type { InputProblem } from "lib/types/InputProblem"
+const inputProblem: InputProblem = {
+  chips: [
+    {
+      chipId: "schematic_component_0",
+      center: {
+        x: -1.9145832999999999,
+        y: 0.5512093000000002,
+      },
+      width: 0.5291665999999999,
+      height: 1.0583333000000001,
+      pins: [
+        {
+          pinId: "C6.1",
+          x: -1.9148566499999995,
+          y: 1.1024186000000005,
+        },
+        {
+          pinId: "C6.2",
+          x: -1.9143099500000003,
+          y: 0,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_1",
+      center: {
+        x: -4.1729164999999995,
+        y: 0.5512093,
+      },
+      width: 0.5291665999999999,
+      height: 1.0583333000000001,
+      pins: [
+        {
+          pinId: "C1.1",
+          x: -4.173189849999999,
+          y: 1.1024186000000002,
+        },
+        {
+          pinId: "C1.2",
+          x: -4.17264315,
+          y: -2.220446049250313e-16,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_2",
+      center: {
+        x: -3.0437499,
+        y: 0.5512093,
+      },
+      width: 0.5291665999999999,
+      height: 1.0583333000000001,
+      pins: [
+        {
+          pinId: "C2.1",
+          x: -3.0440232499999995,
+          y: 1.1024186000000002,
+        },
+        {
+          pinId: "C2.2",
+          x: -3.0434765500000003,
+          y: -2.220446049250313e-16,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_3",
+      center: {
+        x: 1.9145832999999999,
+        y: -0.4512093000000006,
+      },
+      width: 0.5291665999999999,
+      height: 1.0583333000000001,
+      pins: [
+        {
+          pinId: "C5.1",
+          x: 1.9143099500000003,
+          y: 0.09999999999999964,
+        },
+        {
+          pinId: "C5.2",
+          x: 1.9148566499999995,
+          y: -1.0024186000000008,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_4",
+      center: {
+        x: 0,
+        y: 0,
+      },
+      width: 1.2000000000000002,
+      height: 0.8,
+      pins: [
+        {
+          pinId: "U1.1",
+          x: -1,
+          y: 0.2,
+        },
+        {
+          pinId: "U1.2",
+          x: -1,
+          y: 0,
+        },
+        {
+          pinId: "U1.3",
+          x: -1,
+          y: -0.2,
+        },
+        {
+          pinId: "U1.4",
+          x: 1,
+          y: -0.1,
+        },
+        {
+          pinId: "U1.5",
+          x: 1,
+          y: 0.1,
+        },
+      ],
+    },
+  ],
+  directConnections: [
+    {
+      pinIds: ["U1.1", "C6.1"],
+      netId: "group.voltage_regulator > chip.U1 > port.VIN to C6.1",
+    },
+    {
+      pinIds: ["U1.1", "C1.1"],
+      netId: "group.voltage_regulator > chip.U1 > port.VIN to C1.1",
+    },
+    {
+      pinIds: ["U1.1", "C2.1"],
+      netId: "group.voltage_regulator > chip.U1 > port.VIN to C2.1",
+    },
+    {
+      pinIds: ["U1.2", "C6.2"],
+      netId: "group.voltage_regulator > chip.U1 > port.GND to C6.2",
+    },
+    {
+      pinIds: ["U1.2", "C1.2"],
+      netId: "group.voltage_regulator > chip.U1 > port.GND to C1.2",
+    },
+    {
+      pinIds: ["U1.2", "C2.2"],
+      netId: "group.voltage_regulator > chip.U1 > port.GND to C2.2",
+    },
+    {
+      pinIds: ["U1.3", "U1.1"],
+      netId: "group.voltage_regulator > chip.U1 > port.EN to U1.1",
+    },
+    {
+      pinIds: ["U1.5", "C5.1"],
+      netId: "group.voltage_regulator > chip.U1 > port.VOUT to C5.1",
+    },
+  ],
+  netConnections: [
+    {
+      netId: "VSYS",
+      pinIds: ["C6.1", "C1.1", "C2.1", "U1.1", "U1.3"],
+    },
+    {
+      netId: "GND",
+      pinIds: ["C6.2", "C1.2", "C2.2", "C5.2", "U1.2"],
+    },
+    {
+      netId: "V3_3",
+      pinIds: ["C5.1", "U1.5"],
+    },
+  ],
+  maxMspPairDistance: 2,
+  availableNetLabelOrientations: {
+    VSYS: ["y+"],
+    GND: ["y-"],
+    V3_3: ["y+"],
+  },
+}
+
+export default () => <PipelineDebugger inputProblem={inputProblem} />

package/tests/functions/generateElbowVariants.test.ts

@@ -3,7 +3,7 @@ import { test, expect } from "bun:test"
 import type { Guideline } from "lib/solvers/GuidelinesSolver/GuidelinesSolver"
 import type { Point } from "@tscircuit/math-utils"
 
-test("generateElbowVariants - simple horizontal segment", () => {
+test.skip("generateElbowVariants - simple horizontal segment", () => {
   const baseElbow: Point[] = [
     { x: 0, y: 0 },
     { x: 1, y: 0 },
@@ -44,7 +44,7 @@ test("generateElbowVariants - no movable segments", () => {
   expect(result.elbowVariants[0]).toEqual(baseElbow)
 })
 
-test("generateElbowVariants - vertical movable segment", () => {
+test.skip("generateElbowVariants - vertical movable segment", () => {
   const baseElbow: Point[] = [
     { x: 0, y: 0 },
     { x: 0, y: 1 },
@@ -66,7 +66,7 @@ test("generateElbowVariants - vertical movable segment", () => {
   expect(result.elbowVariants.length).toBe(3) // Original + 2 guidelines
 })
 
-test("generateElbowVariants - multiple segments with guidelines", () => {
+test.skip("generateElbowVariants - multiple segments with guidelines", () => {
   const baseElbow: Point[] = [
     { x: 0, y: 0 },
     { x: 1, y: 0 },

package/vite.config.ts

@@ -9,4 +9,7 @@ export default defineConfig({
       tests: path.resolve(__dirname, "tests"),
     },
   },
+  server: {
+    port: 5020,
+  },
 })