@tscircuit/schematic-trace-solver 0.0.4 → 0.0.6

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;
@@ -406,6 +409,7 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof GuidelinesSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver>)[];
     constructor(inputProblem: InputProblem);
     currentPipelineStepIndex: number;
+    private cloneAndCorrectInputProblem;
     _step(): void;
     solveUntilPhase(phase: string): void;
     getCurrentPhase(): 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;
@@ -5446,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;
@@ -5508,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);
@@ -7232,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])
@@ -7266,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);
@@ -7406,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,
@@ -7475,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;
   }
@@ -7701,6 +7865,32 @@ var GuidelinesSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/SchematicTracePipelineSolver/correctPinsInsideChip.ts
+var correctPinsInsideChips = (problem) => {
+  for (const chip of problem.chips) {
+    const bounds = getInputChipBounds(chip);
+    for (const pin of chip.pins) {
+      const isInside = pin.x > bounds.minX && pin.x < bounds.maxX && pin.y > bounds.minY && pin.y < bounds.maxY;
+      if (!isInside) continue;
+      const distLeft = pin.x - bounds.minX;
+      const distRight = bounds.maxX - pin.x;
+      const distBottom = pin.y - bounds.minY;
+      const distTop = bounds.maxY - pin.y;
+      const minDist = Math.min(distLeft, distRight, distBottom, distTop);
+      if (minDist === distLeft) {
+        pin.x = bounds.minX;
+      } else if (minDist === distRight) {
+        pin.x = bounds.maxX;
+      } else if (minDist === distBottom) {
+        pin.y = bounds.minY;
+      } else {
+        pin.y = bounds.maxY;
+      }
+      pin._facingDirection = void 0;
+    }
+  }
+};
+
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -7799,7 +7989,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   ];
   constructor(inputProblem) {
     super();
-    this.inputProblem = inputProblem;
+    this.inputProblem = this.cloneAndCorrectInputProblem(inputProblem);
     this.MAX_ITERATIONS = 1e6;
     this.startTimeOfPhase = {};
     this.endTimeOfPhase = {};
@@ -7807,6 +7997,14 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
     this.firstIterationOfPhase = {};
   }
   currentPipelineStepIndex = 0;
+  cloneAndCorrectInputProblem(original) {
+    const cloned = structuredClone({
+      ...original,
+      _chipObstacleSpatialIndex: void 0
+    });
+    correctPinsInsideChips(cloned);
+    return cloned;
+  }
   _step() {
     const pipelineStepDef = this.pipelineDef[this.currentPipelineStepIndex];
     if (!pipelineStepDef) {

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/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -12,6 +12,8 @@ import { TraceOverlapShiftSolver } from "../TraceOverlapShiftSolver/TraceOverlap
 import { NetLabelPlacementSolver } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
 import { visualizeInputProblem } from "./visualizeInputProblem"
 import { GuidelinesSolver } from "../GuidelinesSolver/GuidelinesSolver"
+import { getInputChipBounds } from "../GuidelinesSolver/getInputChipBounds"
+import { correctPinsInsideChips } from "./correctPinsInsideChip"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -135,7 +137,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
 
   constructor(inputProblem: InputProblem) {
     super()
-    this.inputProblem = inputProblem
+    this.inputProblem = this.cloneAndCorrectInputProblem(inputProblem)
     this.MAX_ITERATIONS = 1e6
     this.startTimeOfPhase = {}
     this.endTimeOfPhase = {}
@@ -145,6 +147,17 @@ export class SchematicTracePipelineSolver extends BaseSolver {
 
   currentPipelineStepIndex = 0
 
+  private cloneAndCorrectInputProblem(original: InputProblem): InputProblem {
+    const cloned: InputProblem = structuredClone({
+      ...original,
+      _chipObstacleSpatialIndex: undefined,
+    })
+
+    correctPinsInsideChips(cloned)
+
+    return cloned
+  }
+
   override _step() {
     const pipelineStepDef = this.pipelineDef[this.currentPipelineStepIndex]
     if (!pipelineStepDef) {

package/lib/solvers/SchematicTracePipelineSolver/correctPinsInsideChip.ts

@@ -0,0 +1,37 @@
+import type { InputProblem } from "lib/types/InputProblem"
+import { getInputChipBounds } from "../GuidelinesSolver/getInputChipBounds"
+
+export const correctPinsInsideChips = (problem: InputProblem) => {
+  for (const chip of problem.chips) {
+    const bounds = getInputChipBounds(chip)
+    for (const pin of chip.pins) {
+      const isInside =
+        pin.x > bounds.minX &&
+        pin.x < bounds.maxX &&
+        pin.y > bounds.minY &&
+        pin.y < bounds.maxY
+
+      if (!isInside) continue
+
+      const distLeft = pin.x - bounds.minX
+      const distRight = bounds.maxX - pin.x
+      const distBottom = pin.y - bounds.minY
+      const distTop = bounds.maxY - pin.y
+
+      const minDist = Math.min(distLeft, distRight, distBottom, distTop)
+
+      if (minDist === distLeft) {
+        pin.x = bounds.minX
+      } else if (minDist === distRight) {
+        pin.x = bounds.maxX
+      } else if (minDist === distBottom) {
+        pin.y = bounds.minY
+      } else {
+        pin.y = bounds.maxY
+      }
+
+      // Clear any cached facing direction since geometry changed.
+      pin._facingDirection = undefined
+    }
+  }
+}

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,12 +1,13 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "type": "module",
   "scripts": {
     "start": "cosmos",
     "build": "tsup lib/index.ts --format esm --dts",
-    "format": "biome format --write ."
+    "format": "biome format --write .",
+    "format:check": "biome format ."
   },
   "devDependencies": {
     "@biomejs/biome": "^2.2.2",

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

@@ -171,6 +171,7 @@ const inputProblem: InputProblem = {
       pinIds: ["C5.1", "U1.5"],
     },
   ],
+  maxMspPairDistance: 2,
   availableNetLabelOrientations: {
     VSYS: ["y+"],
     GND: ["y-"],

package/site/examples/example03.page.tsx

@@ -0,0 +1,215 @@
+import type { InputProblem } from "lib/index"
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+
+const inputProblem: InputProblem = {
+  chips: [
+    {
+      chipId: "schematic_component_0",
+      center: {
+        x: -3,
+        y: 1.5,
+      },
+      width: 1.0011537820000012,
+      height: 0.44923699999999833,
+      pins: [
+        {
+          pinId: "PIN1_PIN2.1",
+          x: -3.4724184500000006,
+          y: 1.4489565000000004,
+        },
+        {
+          pinId: "PIN1_PIN2.2",
+          x: -3.4724184500000006,
+          y: 1.4489565000000004,
+        },
+        {
+          pinId: "PIN1_PIN2.3",
+          x: -2.5275815499999994,
+          y: 1.4485175000000003,
+        },
+        {
+          pinId: "PIN1_PIN2.4",
+          x: -2.5275815499999994,
+          y: 1.4485175000000003,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_1",
+      center: {
+        x: 0,
+        y: 1.5,
+      },
+      width: 1.0011537820000012,
+      height: 0.44923699999999833,
+      pins: [
+        {
+          pinId: "PIN1_PIN3.1",
+          x: -0.4724184500000006,
+          y: 1.4489565000000004,
+        },
+        {
+          pinId: "PIN1_PIN3.2",
+          x: -0.4724184500000006,
+          y: 1.4489565000000004,
+        },
+        {
+          pinId: "PIN1_PIN3.3",
+          x: 0.4724184500000006,
+          y: 1.4485175000000003,
+        },
+        {
+          pinId: "PIN1_PIN3.4",
+          x: 0.4724184500000006,
+          y: 1.4485175000000003,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_2",
+      center: {
+        x: 3,
+        y: 1.5,
+      },
+      width: 1.0011537820000012,
+      height: 0.44923699999999833,
+      pins: [
+        {
+          pinId: "PIN1_PIN4.1",
+          x: 2.5275815499999994,
+          y: 1.4489565000000004,
+        },
+        {
+          pinId: "PIN1_PIN4.2",
+          x: 2.5275815499999994,
+          y: 1.4489565000000004,
+        },
+        {
+          pinId: "PIN1_PIN4.3",
+          x: 3.4724184500000006,
+          y: 1.4485175000000003,
+        },
+        {
+          pinId: "PIN1_PIN4.4",
+          x: 3.4724184500000006,
+          y: 1.4485175000000003,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_3",
+      center: {
+        x: -3,
+        y: -1.5,
+      },
+      width: 1.0011537820000012,
+      height: 0.44923699999999833,
+      pins: [
+        {
+          pinId: "PIN2_PIN3.1",
+          x: -3.4724184500000006,
+          y: -1.5510434999999996,
+        },
+        {
+          pinId: "PIN2_PIN3.2",
+          x: -3.4724184500000006,
+          y: -1.5510434999999996,
+        },
+        {
+          pinId: "PIN2_PIN3.3",
+          x: -2.5275815499999994,
+          y: -1.5514824999999997,
+        },
+        {
+          pinId: "PIN2_PIN3.4",
+          x: -2.5275815499999994,
+          y: -1.5514824999999997,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_4",
+      center: {
+        x: 0,
+        y: -1.5,
+      },
+      width: 1.0011537820000012,
+      height: 0.44923699999999833,
+      pins: [
+        {
+          pinId: "PIN2_PIN4.1",
+          x: -0.4724184500000006,
+          y: -1.5510434999999996,
+        },
+        {
+          pinId: "PIN2_PIN4.2",
+          x: -0.4724184500000006,
+          y: -1.5510434999999996,
+        },
+        {
+          pinId: "PIN2_PIN4.3",
+          x: 0.4724184500000006,
+          y: -1.5514824999999997,
+        },
+        {
+          pinId: "PIN2_PIN4.4",
+          x: 0.4724184500000006,
+          y: -1.5514824999999997,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_5",
+      center: {
+        x: 3,
+        y: -1.5,
+      },
+      width: 1.0011537820000012,
+      height: 0.44923699999999833,
+      pins: [
+        {
+          pinId: "PIN3_PIN4.1",
+          x: 2.5275815499999994,
+          y: -1.5510434999999996,
+        },
+        {
+          pinId: "PIN3_PIN4.2",
+          x: 2.5275815499999994,
+          y: -1.5510434999999996,
+        },
+        {
+          pinId: "PIN3_PIN4.3",
+          x: 3.4724184500000006,
+          y: -1.5514824999999997,
+        },
+        {
+          pinId: "PIN3_PIN4.4",
+          x: 3.4724184500000006,
+          y: -1.5514824999999997,
+        },
+      ],
+    },
+  ],
+  directConnections: [],
+  netConnections: [
+    {
+      netId: "PIN1",
+      pinIds: ["PIN1_PIN2.1", "PIN1_PIN3.1", "PIN1_PIN4.1"],
+    },
+    {
+      netId: "PIN2",
+      pinIds: ["PIN1_PIN2.2", "PIN2_PIN3.2", "PIN2_PIN4.2"],
+    },
+    {
+      netId: "PIN3",
+      pinIds: ["PIN1_PIN3.3", "PIN2_PIN3.3", "PIN3_PIN4.3"],
+    },
+    {
+      netId: "PIN4",
+      pinIds: ["PIN1_PIN4.4", "PIN2_PIN4.4", "PIN3_PIN4.4"],
+    },
+  ],
+  availableNetLabelOrientations: {},
+}
+
+export default () => <PipelineDebugger inputProblem={inputProblem} />

package/vite.config.ts

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