@tscircuit/schematic-trace-solver 0.0.27 → 0.0.29

package/dist/index.d.ts

@@ -154,6 +154,9 @@ interface MovableSegment {
     };
 }
 
+type ChipPin = InputPin & {
+    chipId: ChipId;
+};
 declare class SchematicTraceSingleLineSolver extends BaseSolver {
     pins: MspConnectionPair["pins"];
     inputProblem: InputProblem;
@@ -168,6 +171,7 @@ declare class SchematicTraceSingleLineSolver extends BaseSolver {
         x: number;
         y: number;
     }[] | null;
+    pinIdMap: Map<PinId, ChipPin>;
     constructor(params: {
         pins: MspConnectionPair["pins"];
         guidelines: Guideline[];

package/dist/index.js

@@ -469,6 +469,68 @@ var dir = (facingDirection) => {
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/generateElbowVariants.ts
 var EPS = 1e-6;
 var MIN_LEN = 1e-6;
+var checkIfUTurnNeeded = (elbow) => {
+  if (elbow.length !== 4) return false;
+  const [start, p1, p2, end] = elbow;
+  const startOrient = orientationOf(start, p1);
+  const startFacing = startOrient === "horizontal" ? p1.x > start.x ? "x+" : "x-" : p1.y > start.y ? "y+" : "y-";
+  const endOrient = orientationOf(p2, end);
+  const endFacing = endOrient === "horizontal" ? end.x > p2.x ? "x+" : "x-" : end.y > p2.y ? "y+" : "y-";
+  if (startFacing === "x+" && end.x < p1.x - EPS) return true;
+  if (startFacing === "x-" && end.x > p1.x + EPS) return true;
+  if (startFacing === "y+" && end.y < p1.y - EPS) return true;
+  if (startFacing === "y-" && end.y > p1.y + EPS) return true;
+  if (endFacing === "x-" && p2.x > end.x + EPS && startFacing === "x+")
+    return true;
+  if (endFacing === "x+" && p2.x < end.x - EPS && startFacing === "x-")
+    return true;
+  if (endFacing === "y-" && p2.y > end.y + EPS && startFacing === "y+")
+    return true;
+  if (endFacing === "y+" && p2.y < end.y - EPS && startFacing === "y-")
+    return true;
+  return false;
+};
+var expandToUTurn = (elbow) => {
+  if (elbow.length !== 4) return elbow;
+  const [start, p1, p2, end] = elbow;
+  const overshoot = Math.max(
+    Math.abs(start.x - p1.x),
+    Math.abs(start.y - p1.y),
+    0.2
+    // minimum overshoot
+  );
+  const startOrient = orientationOf(start, p1);
+  const expanded = [{ ...start }];
+  if (startOrient === "horizontal") {
+    const startDir = p1.x > start.x ? 1 : -1;
+    expanded.push({ x: start.x + startDir * overshoot, y: start.y });
+    const verticalSpace = Math.max(
+      overshoot * 2,
+      Math.abs(end.y - start.y) + overshoot
+    );
+    const midY = end.y > start.y ? start.y - verticalSpace : start.y + verticalSpace;
+    expanded.push({ x: start.x + startDir * overshoot, y: midY });
+    const endOrient = orientationOf(p2, end);
+    const endApproachX = endOrient === "horizontal" ? end.x > p2.x ? end.x - overshoot : end.x + overshoot : end.x;
+    expanded.push({ x: endApproachX, y: midY });
+    expanded.push({ x: endApproachX, y: end.y });
+  } else {
+    const startDir = p1.y > start.y ? 1 : -1;
+    expanded.push({ x: start.x, y: start.y + startDir * overshoot });
+    const horizontalSpace = Math.max(
+      overshoot * 2,
+      Math.abs(end.x - start.x) + overshoot
+    );
+    const midX = end.x > start.x ? start.x - horizontalSpace : start.x + horizontalSpace;
+    expanded.push({ x: midX, y: start.y + startDir * overshoot });
+    const endOrient = orientationOf(p2, end);
+    const endApproachY = endOrient === "vertical" ? end.y > p2.y ? end.y - overshoot : end.y + overshoot : end.y;
+    expanded.push({ x: midX, y: endApproachY });
+    expanded.push({ x: end.x, y: endApproachY });
+  }
+  expanded.push({ ...end });
+  return expanded;
+};
 var isAxisAligned = (a, b) => Math.abs(a.x - b.x) < EPS || Math.abs(a.y - b.y) < EPS;
 var orientationOf = (a, b) => {
   const dx = Math.abs(a.x - b.x);
@@ -550,15 +612,20 @@ var generateElbowVariants = ({
   const elbow = preprocessElbow(baseElbow);
   assertOrthogonalPolyline(elbow);
   const nPts = elbow.length;
-  const nSegs = nPts - 1;
-  if (nSegs < 5) {
+  if (nPts < 4) {
     return {
       elbowVariants: [elbow.map((p) => ({ ...p }))],
       movableSegments: []
     };
+  } else if (nPts === 4) {
+    const needsUTurn = checkIfUTurnNeeded(elbow);
+    if (needsUTurn) {
+      const expandedElbow = expandToUTurn(elbow);
+      return generateElbowVariants({ baseElbow: expandedElbow, guidelines });
+    }
   }
-  const firstMovableIndex = 2;
-  const lastMovableIndex = nPts - 4;
+  const firstMovableIndex = 1;
+  const lastMovableIndex = nPts - 3;
   const movableSegments = [];
   const movableIdx = [];
   const axes = [];
@@ -668,6 +735,86 @@ var visualizeGuidelines = ({
   return graphics;
 };
 
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getRestrictedCenterLines.ts
+var getRestrictedCenterLines = (params) => {
+  const { pins, inputProblem, pinIdMap, chipMap } = params;
+  const findAllDirectlyConnectedPins = (startPinId) => {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [startPinId];
+    visited.add(startPinId);
+    const directConns = inputProblem.directConnections || [];
+    while (queue.length) {
+      const cur = queue.shift();
+      for (const dc of directConns) {
+        if (dc.pinIds.includes(cur)) {
+          for (const p of dc.pinIds) {
+            if (!visited.has(p)) {
+              visited.add(p);
+              queue.push(p);
+            }
+          }
+        }
+      }
+    }
+    return visited;
+  };
+  const p0 = pins[0].pinId;
+  const p1 = pins[1].pinId;
+  const relatedPinIds = /* @__PURE__ */ new Set([
+    ...findAllDirectlyConnectedPins(p0),
+    ...findAllDirectlyConnectedPins(p1)
+  ]);
+  const restrictedCenterLines = /* @__PURE__ */ new Map();
+  const chipFacingMap = /* @__PURE__ */ new Map();
+  const chipsOfFacingPins = new Set(pins.map((p) => p.chipId));
+  for (const pinId of relatedPinIds) {
+    const pin = pinIdMap.get(pinId);
+    if (!pin) continue;
+    const chip = chipMap[pin.chipId];
+    if (!chip) continue;
+    const facing = pin._facingDirection ?? getPinDirection(pin, chip);
+    let entry = chipFacingMap.get(chip.chipId);
+    if (!entry) {
+      entry = { center: chip.center };
+      const counts = { xPos: 0, xNeg: 0, yPos: 0, yNeg: 0 };
+      for (const cp of chip.pins) {
+        const cpFacing = cp._facingDirection ?? getPinDirection(cp, chip);
+        if (cpFacing === "x+") counts.xPos++;
+        if (cpFacing === "x-") counts.xNeg++;
+        if (cpFacing === "y+") counts.yPos++;
+        if (cpFacing === "y-") counts.yNeg++;
+      }
+      entry.counts = counts;
+      chipFacingMap.set(chip.chipId, entry);
+    }
+    if (facing === "x+") entry.hasXPos = true;
+    if (facing === "x-") entry.hasXNeg = true;
+    if (facing === "y+") entry.hasYPos = true;
+    if (facing === "y-") entry.hasYNeg = true;
+  }
+  for (const [chipId, faces] of chipFacingMap) {
+    const axes = /* @__PURE__ */ new Set();
+    const rcl = { axes };
+    const counts = faces.counts;
+    const anySideHasMultiplePins = !!(counts && (counts.xPos > 1 || counts.xNeg > 1 || counts.yPos > 1 || counts.yNeg > 1));
+    const skipCenterRestriction = !anySideHasMultiplePins && chipsOfFacingPins.has(chipId);
+    if (!skipCenterRestriction) {
+      if (faces.hasXPos && faces.hasXNeg) {
+        rcl.x = faces.center.x;
+        axes.add("x");
+      }
+      if (faces.hasYPos && faces.hasYNeg) {
+        rcl.y = faces.center.y;
+        axes.add("y");
+      }
+    }
+    if (axes.size > 0) {
+      restrictedCenterLines.set(chipId, rcl);
+    }
+  }
+  return restrictedCenterLines;
+};
+
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver.ts
 var SchematicTraceSingleLineSolver = class extends BaseSolver {
   pins;
@@ -680,6 +827,8 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
   queuedCandidatePaths;
   chipObstacleSpatialIndex;
   solvedTracePath = null;
+  // map of pinId -> pin (with chipId attached)
+  pinIdMap = /* @__PURE__ */ new Map();
   constructor(params) {
     super();
     this.pins = params.pins;
@@ -690,6 +839,11 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
     if (!this.inputProblem._chipObstacleSpatialIndex) {
       this.inputProblem._chipObstacleSpatialIndex = this.chipObstacleSpatialIndex;
     }
+    for (const chip of this.inputProblem.chips) {
+      for (const pin of chip.pins) {
+        this.pinIdMap.set(pin.pinId, { ...pin, chipId: chip.chipId });
+      }
+    }
     for (const pin of this.pins) {
       if (!pin._facingDirection) {
         const chip = this.chipMap[pin.chipId];
@@ -746,10 +900,25 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
       return;
     }
     const nextCandidatePath = this.queuedCandidatePaths.shift();
+    const restrictedCenterLines = getRestrictedCenterLines({
+      pins: this.pins,
+      inputProblem: this.inputProblem,
+      pinIdMap: this.pinIdMap,
+      chipMap: this.chipMap
+    });
     for (let i = 0; i < nextCandidatePath.length - 1; i++) {
       const start = nextCandidatePath[i];
       const end = nextCandidatePath[i + 1];
       let excludeChipIds = [];
+      const EPS2 = 1e-9;
+      for (const [, rcl] of restrictedCenterLines) {
+        if (rcl.axes.has("x") && typeof rcl.x === "number") {
+          if ((start.x - rcl.x) * (end.x - rcl.x) < -EPS2) return;
+        }
+        if (rcl.axes.has("y") && typeof rcl.y === "number") {
+          if ((start.y - rcl.y) * (end.y - rcl.y) < -EPS2) return;
+        }
+      }
       const isStartPin = this.pins.some(
         (pin) => Math.abs(pin.x - start.x) < 1e-10 && Math.abs(pin.y - start.y) < 1e-10
       );
@@ -764,12 +933,12 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
           const bounds = getInputChipBounds(this.chipMap[startPin.chipId]);
           const dx = end.x - start.x;
           const dy = end.y - start.y;
-          const EPS2 = 1e-9;
+          const EPS3 = 1e-9;
           const onLeft = Math.abs(start.x - bounds.minX) < 1e-9;
           const onRight = Math.abs(start.x - bounds.maxX) < 1e-9;
           const onBottom = Math.abs(start.y - bounds.minY) < 1e-9;
           const onTop = Math.abs(start.y - bounds.maxY) < 1e-9;
-          const entersInterior = onLeft && dx > EPS2 || onRight && dx < -EPS2 || onBottom && dy > EPS2 || onTop && dy < -EPS2;
+          const entersInterior = onLeft && dx > EPS3 || onRight && dx < -EPS3 || onBottom && dy > EPS3 || onTop && dy < -EPS3;
           if (entersInterior) return;
           if (!excludeChipIds.includes(startPin.chipId)) {
             excludeChipIds.push(startPin.chipId);
@@ -784,12 +953,12 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
           const bounds = getInputChipBounds(this.chipMap[endPin.chipId]);
           const dx = start.x - end.x;
           const dy = start.y - end.y;
-          const EPS2 = 1e-9;
+          const EPS3 = 1e-9;
           const onLeft = Math.abs(end.x - bounds.minX) < 1e-9;
           const onRight = Math.abs(end.x - bounds.maxX) < 1e-9;
           const onBottom = Math.abs(end.y - bounds.minY) < 1e-9;
           const onTop = Math.abs(end.y - bounds.maxY) < 1e-9;
-          const entersInterior = onLeft && dx > EPS2 || onRight && dx < -EPS2 || onBottom && dy > EPS2 || onTop && dy < -EPS2;
+          const entersInterior = onLeft && dx > EPS3 || onRight && dx < -EPS3 || onBottom && dy > EPS3 || onTop && dy < -EPS3;
           if (entersInterior) return;
           if (!excludeChipIds.includes(endPin.chipId)) {
             excludeChipIds.push(endPin.chipId);

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

@@ -4,7 +4,13 @@ import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { Guideline } from "lib/solvers/GuidelinesSolver/GuidelinesSolver"
 import type { MspConnectionPair } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
 import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
-import type { InputChip, InputProblem } from "lib/types/InputProblem"
+import type {
+  ChipId,
+  InputChip,
+  InputPin,
+  InputProblem,
+  PinId,
+} from "lib/types/InputProblem"
 import { calculateElbow } from "calculate-elbow"
 import { getPinDirection } from "./getPinDirection"
 import {
@@ -15,6 +21,9 @@ import type { Point } from "@tscircuit/math-utils"
 import { visualizeGuidelines } from "lib/solvers/GuidelinesSolver/visualizeGuidelines"
 import { getInputChipBounds } from "lib/solvers/GuidelinesSolver/getInputChipBounds"
 import { getColorFromString } from "lib/utils/getColorFromString"
+import { getRestrictedCenterLines } from "./getRestrictedCenterLines"
+
+type ChipPin = InputPin & { chipId: ChipId }
 
 export class SchematicTraceSingleLineSolver extends BaseSolver {
   pins: MspConnectionPair["pins"]
@@ -31,6 +40,9 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
 
   solvedTracePath: { x: number; y: number }[] | null = null
 
+  // map of pinId -> pin (with chipId attached)
+  pinIdMap: Map<PinId, ChipPin> = new Map()
+
   constructor(params: {
     pins: MspConnectionPair["pins"]
     guidelines: Guideline[]
@@ -51,6 +63,13 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
         this.chipObstacleSpatialIndex
     }
 
+    // Build a lookup of all pins by id and attach chipId to each pin entry
+    for (const chip of this.inputProblem.chips) {
+      for (const pin of chip.pins) {
+        this.pinIdMap.set(pin.pinId, { ...pin, chipId: chip.chipId })
+      }
+    }
+
     for (const pin of this.pins) {
       if (!pin._facingDirection) {
         const chip = this.chipMap[pin.chipId]
@@ -118,6 +137,13 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
 
     const nextCandidatePath = this.queuedCandidatePaths.shift()!
 
+    const restrictedCenterLines = getRestrictedCenterLines({
+      pins: this.pins,
+      inputProblem: this.inputProblem,
+      pinIdMap: this.pinIdMap,
+      chipMap: this.chipMap,
+    })
+
     for (let i = 0; i < nextCandidatePath.length - 1; i++) {
       const start = nextCandidatePath[i]
       const end = nextCandidatePath[i + 1]
@@ -125,6 +151,19 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
       // Determine which chips to exclude for this specific segment
       let excludeChipIds: string[] = []
 
+      // If this segment would cross any restricted center line, reject the candidate path.
+      const EPS = 1e-9
+      for (const [, rcl] of restrictedCenterLines) {
+        if (rcl.axes.has("x") && typeof rcl.x === "number") {
+          // segment strictly crosses vertical center line
+          if ((start.x - rcl.x) * (end.x - rcl.x) < -EPS) return
+        }
+        if (rcl.axes.has("y") && typeof rcl.y === "number") {
+          // segment strictly crosses horizontal center line
+          if ((start.y - rcl.y) * (end.y - rcl.y) < -EPS) return
+        }
+      }
+
       // Always exclude chips that contain the start or end points of this segment
       // if those points are actually pin locations
       const isStartPin = this.pins.some(

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

@@ -14,6 +14,123 @@ export interface MovableSegment {
 const EPS = 1e-6 // numeric tolerance for equality
 const MIN_LEN = 1e-6 // forbid near-zero length segments (adjacent collapses)
 
+const checkIfUTurnNeeded = (elbow: Point[]): boolean => {
+  if (elbow.length !== 4) return false
+
+  const [start, p1, p2, end] = elbow
+
+  // Determine facing directions from the path segments
+  const startOrient = orientationOf(start, p1)
+  const startFacing: FacingDirection =
+    startOrient === "horizontal"
+      ? p1.x > start.x
+        ? "x+"
+        : "x-"
+      : p1.y > start.y
+        ? "y+"
+        : "y-"
+
+  const endOrient = orientationOf(p2, end)
+  const endFacing: FacingDirection =
+    endOrient === "horizontal"
+      ? end.x > p2.x
+        ? "x+"
+        : "x-"
+      : end.y > p2.y
+        ? "y+"
+        : "y-"
+
+  // Check if path overshoots and needs to turn back
+  if (startFacing === "x+" && end.x < p1.x - EPS) return true
+  if (startFacing === "x-" && end.x > p1.x + EPS) return true
+  if (startFacing === "y+" && end.y < p1.y - EPS) return true
+  if (startFacing === "y-" && end.y > p1.y + EPS) return true
+
+  // Check if path segments conflict (p2 is past the end in the facing direction)
+  if (endFacing === "x-" && p2.x > end.x + EPS && startFacing === "x+")
+    return true
+  if (endFacing === "x+" && p2.x < end.x - EPS && startFacing === "x-")
+    return true
+  if (endFacing === "y-" && p2.y > end.y + EPS && startFacing === "y+")
+    return true
+  if (endFacing === "y+" && p2.y < end.y - EPS && startFacing === "y-")
+    return true
+
+  return false
+}
+
+const expandToUTurn = (elbow: Point[]): Point[] => {
+  if (elbow.length !== 4) return elbow
+
+  const [start, p1, p2, end] = elbow
+
+  // Calculate overshoot distance from existing segments
+  const overshoot = Math.max(
+    Math.abs(start.x - p1.x),
+    Math.abs(start.y - p1.y),
+    0.2, // minimum overshoot
+  )
+
+  const startOrient = orientationOf(start, p1)
+  const expanded: Point[] = [{ ...start }]
+
+  if (startOrient === "horizontal") {
+    const startDir = p1.x > start.x ? 1 : -1
+    expanded.push({ x: start.x + startDir * overshoot, y: start.y })
+
+    // Move away vertically to create space for U-turn
+    const verticalSpace = Math.max(
+      overshoot * 2,
+      Math.abs(end.y - start.y) + overshoot,
+    )
+    const midY =
+      end.y > start.y ? start.y - verticalSpace : start.y + verticalSpace
+
+    expanded.push({ x: start.x + startDir * overshoot, y: midY })
+
+    // Approach end from its required direction
+    const endOrient = orientationOf(p2, end)
+    const endApproachX =
+      endOrient === "horizontal"
+        ? end.x > p2.x
+          ? end.x - overshoot
+          : end.x + overshoot
+        : end.x
+
+    expanded.push({ x: endApproachX, y: midY })
+    expanded.push({ x: endApproachX, y: end.y })
+  } else {
+    // Vertical start
+    const startDir = p1.y > start.y ? 1 : -1
+    expanded.push({ x: start.x, y: start.y + startDir * overshoot })
+
+    // Move away horizontally to create space for U-turn
+    const horizontalSpace = Math.max(
+      overshoot * 2,
+      Math.abs(end.x - start.x) + overshoot,
+    )
+    const midX =
+      end.x > start.x ? start.x - horizontalSpace : start.x + horizontalSpace
+
+    expanded.push({ x: midX, y: start.y + startDir * overshoot })
+
+    // Approach end from its required direction
+    const endOrient = orientationOf(p2, end)
+    const endApproachY =
+      endOrient === "vertical"
+        ? end.y > p2.y
+          ? end.y - overshoot
+          : end.y + overshoot
+        : end.y
+
+    expanded.push({ x: midX, y: endApproachY })
+    expanded.push({ x: end.x, y: endApproachY })
+  }
+
+  expanded.push({ ...end })
+  return expanded
+}
+
 /** True if segment [a,b] is axis-aligned (horizontal or vertical). */
 const isAxisAligned = (a: Point, b: Point): boolean =>
   Math.abs(a.x - b.x) < EPS || Math.abs(a.y - b.y) < EPS
@@ -155,21 +272,27 @@ export const generateElbowVariants = ({
   assertOrthogonalPolyline(elbow)
 
   const nPts = elbow.length
-  const nSegs = nPts - 1
 
   // No interior segments to move if path is too short.
-  if (nSegs < 5) {
+  if (nPts < 4) {
     return {
       elbowVariants: [elbow.map((p) => ({ ...p }))],
       movableSegments: [],
     }
+  } else if (nPts === 4) {
+    const needsUTurn = checkIfUTurnNeeded(elbow)
+    if (needsUTurn) {
+      const expandedElbow = expandToUTurn(elbow)
+      // Recursively call with the expanded path
+      return generateElbowVariants({ baseElbow: expandedElbow, guidelines })
+    }
   }
 
   // 2) Choose which segments are allowed to move.
-  //    We avoid segments adjacent to the first and last segment:
-  //    movable indices i in [2 .. (nPts - 4)] inclusive (segment i connects P[i] -> P[i+1]).
-  const firstMovableIndex = 2
-  const lastMovableIndex = nPts - 4
+  //    We avoid moving the very first and last segments of the:
+  //    movable indices i in [1 .. (nPts - 3)] inclusive (segment i connects P[i] -> P[i+1]).
+  const firstMovableIndex = 1
+  const lastMovableIndex = nPts - 3
 
   const movableSegments: MovableSegment[] = []
   const movableIdx: number[] = []

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

@@ -0,0 +1,139 @@
+import type {
+  ChipId,
+  InputChip,
+  InputPin,
+  InputProblem,
+  PinId,
+} from "lib/types/InputProblem"
+import { getPinDirection } from "./getPinDirection"
+
+type ChipPin = InputPin & { chipId: ChipId }
+
+/**
+ * A line that should not be crossed by a trace segment.
+ * This is used to prevent traces from crossing through the center of a chip when
+ * connecting pins on that same chip. Right now this is only enabled when a chip
+ * has multiple pins on at least one side.
+ */
+export type RestrictedCenterLine = {
+  x?: number
+  y?: number
+  axes: Set<"x" | "y">
+}
+
+export const getRestrictedCenterLines = (params: {
+  pins: Array<InputPin & { chipId: string }>
+  inputProblem: InputProblem
+  pinIdMap: Map<PinId, ChipPin>
+  chipMap: Record<string, InputChip>
+}): Map<ChipId, RestrictedCenterLine> => {
+  const { pins, inputProblem, pinIdMap, chipMap } = params
+
+  // Determine set of related pin IDs (closure over directConnections) for both endpoints
+  const findAllDirectlyConnectedPins = (startPinId: string) => {
+    const visited = new Set<string>()
+    const queue: string[] = [startPinId]
+    visited.add(startPinId)
+    const directConns = inputProblem.directConnections || []
+    while (queue.length) {
+      const cur = queue.shift()!
+      for (const dc of directConns) {
+        if (dc.pinIds.includes(cur)) {
+          for (const p of dc.pinIds) {
+            if (!visited.has(p)) {
+              visited.add(p)
+              queue.push(p)
+            }
+          }
+        }
+      }
+    }
+    return visited
+  }
+
+  const p0 = pins[0].pinId
+  const p1 = pins[1].pinId
+  const relatedPinIds = new Set<string>([
+    ...findAllDirectlyConnectedPins(p0),
+    ...findAllDirectlyConnectedPins(p1),
+  ])
+
+  const restrictedCenterLines = new Map<ChipId, RestrictedCenterLine>()
+
+  // Collect facing-signs per chip
+  const chipFacingMap = new Map<
+    string,
+    {
+      hasXPos?: boolean
+      hasXNeg?: boolean
+      hasYPos?: boolean
+      hasYNeg?: boolean
+      center: { x: number; y: number }
+      counts?: { xPos: number; xNeg: number; yPos: number; yNeg: number }
+    }
+  >()
+
+  const chipsOfFacingPins = new Set<string>(pins.map((p) => p.chipId))
+
+  for (const pinId of relatedPinIds) {
+    const pin = pinIdMap.get(pinId)
+    if (!pin) continue
+    const chip = chipMap[pin.chipId]
+    if (!chip) continue
+    const facing = pin._facingDirection ?? getPinDirection(pin, chip)
+    let entry = chipFacingMap.get(chip.chipId)
+    if (!entry) {
+      entry = { center: chip.center }
+
+      const counts = { xPos: 0, xNeg: 0, yPos: 0, yNeg: 0 }
+      for (const cp of chip.pins) {
+        const cpFacing = cp._facingDirection ?? getPinDirection(cp, chip)
+        if (cpFacing === "x+") counts.xPos++
+        if (cpFacing === "x-") counts.xNeg++
+        if (cpFacing === "y+") counts.yPos++
+        if (cpFacing === "y-") counts.yNeg++
+      }
+      entry.counts = counts
+
+      chipFacingMap.set(chip.chipId, entry)
+    }
+    if (facing === "x+") entry.hasXPos = true
+    if (facing === "x-") entry.hasXNeg = true
+    if (facing === "y+") entry.hasYPos = true
+    if (facing === "y-") entry.hasYNeg = true
+  }
+
+  // Only mark a center as restricted on an axis if both signs for that axis
+  // are present among related pins on the chip.
+  for (const [chipId, faces] of chipFacingMap) {
+    const axes = new Set<"x" | "y">()
+    const rcl: RestrictedCenterLine = { axes }
+
+    // determine whether any side on this chip has more than one pin
+    const counts = faces.counts
+    const anySideHasMultiplePins = !!(
+      counts &&
+      (counts.xPos > 1 || counts.xNeg > 1 || counts.yPos > 1 || counts.yNeg > 1)
+    )
+
+    const skipCenterRestriction =
+      !anySideHasMultiplePins && chipsOfFacingPins.has(chipId)
+
+    if (!skipCenterRestriction) {
+      if (faces.hasXPos && faces.hasXNeg) {
+        rcl.x = faces.center.x
+        axes.add("x")
+      }
+      if (faces.hasYPos && faces.hasYNeg) {
+        rcl.y = faces.center.y
+        axes.add("y")
+      }
+    }
+
+    if (axes.size > 0) {
+      restrictedCenterLines.set(chipId, rcl)
+    }
+  }
+
+  return restrictedCenterLines
+}

package/package.json

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