@tscircuit/schematic-trace-solver 0.0.118 → 0.0.120

package/dist/index.d.ts

@@ -721,12 +721,13 @@ interface AvailableNetOrientationSolverParams {
 type CandidateLabel = {
     orientation: FacingDirection;
     anchorPoint: Point;
+    connectorSource?: Point;
     center: Point;
     width: number;
     height: number;
 };
 type CandidateStatus$2 = "valid" | "chip-collision" | "text-collision" | "trace-collision" | "trace-clearance-violation" | "netlabel-collision";
-type CandidatePhase = "rotate" | "trace-anchor" | "shift" | "lateral-shift";
+type CandidatePhase = "rotate" | "trace-anchor" | "outward-trace-anchor" | "shift" | "lateral-shift";
 type EvaluatedCandidate = CandidateLabel & {
     status: CandidateStatus$2;
     selected: boolean;
@@ -768,6 +769,7 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private hasTraceContinuingInOrientation;
     private findValidRotatedCandidate;
     private findValidTraceAnchorCandidate;
+    private findValidOutwardTraceAnchorCandidate;
     private getTraceAnchorCandidatePoints;
     private getAvailableOrientations;
     private findValidShiftedCandidate;
@@ -801,6 +803,10 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private getLabelTraceClearanceBounds;
     private shouldCheckTraceClearanceForLabel;
     private hasRoutedLabelOnSameNet;
+    private isOutwardHorizontalFallback;
+    private hasPortOnlyLabelOnSameNet;
+    private hasOppositeVerticalRailOnSameChipSide;
+    private getSingleChipSideForNetConnection;
     private isPortOnlyLabel;
     private intersectsAnyOtherNetLabel;
     private sharesChipBoundary;

package/dist/index.js

@@ -7995,9 +7995,20 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   findCorrectedCandidate(label, labelIndex) {
     const orientations = this.getAvailableOrientations(label);
     const requiredOrientation = orientations[0];
-    const isTwoPinNet = this.inputProblem.netConnections.some(
-      (connection) => connection.netId === label.netId && connection.pinIds.length === 2
+    const netConnection = this.inputProblem.netConnections.find(
+      (connection) => connection.netId === label.netId
     );
+    const isTwoPinNet = netConnection?.pinIds.length === 2;
+    const isDistanceSplitVerticalRail = (netConnection?.pinIds.length ?? 0) > 2 && isYOrientation(requiredOrientation) && this.hasPortOnlyLabelOnSameNet(label);
+    const isPairedSameSidePowerRail = isYOrientation(requiredOrientation) && this.hasOppositeVerticalRailOnSameChipSide(label, requiredOrientation);
+    if (orientations.length === 1 && isYOrientation(requiredOrientation) && this.isOutwardHorizontalFallback(label) && this.hasTraceContinuingInOrientation(label, requiredOrientation) && (isDistanceSplitVerticalRail || isPairedSameSidePowerRail)) {
+      const traceAnchorCandidate2 = this.findValidOutwardTraceAnchorCandidate(
+        label,
+        requiredOrientation,
+        labelIndex
+      );
+      if (traceAnchorCandidate2) return traceAnchorCandidate2;
+    }
     if (isTwoPinNet && orientations.length === 1 && isYOrientation(requiredOrientation) && this.hasTraceContinuingInOrientation(label, requiredOrientation)) {
       const alignedCandidate = this.findValidCandidateInShiftColumn({
         label,
@@ -8099,6 +8110,72 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return null;
   }
+  findValidOutwardTraceAnchorCandidate(label, orientation, labelIndex) {
+    const direction = dir(orientation);
+    const candidatePoints = this.getTraceAnchorCandidatePoints(label).sort(
+      (a, b) => {
+        const aAlongDirection = a.x * direction.x + a.y * direction.y;
+        const bAlongDirection = b.x * direction.x + b.y * direction.y;
+        return bAlongDirection - aAlongDirection;
+      }
+    );
+    for (const connectorSource of candidatePoints) {
+      const preservedColumnAnchor = this.getSearchStartAnchor(
+        label,
+        orientation
+      );
+      const preservedColumnCandidate = this.createCandidate(
+        label,
+        {
+          x: preservedColumnAnchor.x,
+          y: connectorSource.y
+        },
+        orientation,
+        connectorSource
+      );
+      const preservedColumnResult = this.evaluateCandidate(
+        preservedColumnCandidate,
+        label,
+        labelIndex,
+        "outward-trace-anchor"
+      );
+      this.currentCandidateResults.push(preservedColumnResult);
+      if (preservedColumnResult.status === "valid") {
+        preservedColumnResult.selected = true;
+        return preservedColumnResult;
+      }
+      const outwardDirection = this.getPerpendicularOutwardDirection(
+        connectorSource,
+        orientation
+      );
+      if (outwardDirection.x === 0 && outwardDirection.y === 0) continue;
+      for (let distance5 = LABEL_SEARCH_STEP; distance5 <= this.maxSearchDistance + EPS11; distance5 += LABEL_SEARCH_STEP) {
+        const anchorPoint = {
+          x: connectorSource.x + outwardDirection.x * distance5,
+          y: connectorSource.y + outwardDirection.y * distance5
+        };
+        const candidate = this.createCandidate(
+          label,
+          anchorPoint,
+          orientation,
+          connectorSource
+        );
+        const result = this.evaluateCandidate(
+          candidate,
+          label,
+          labelIndex,
+          "outward-trace-anchor",
+          distance5
+        );
+        this.currentCandidateResults.push(result);
+        if (result.status === "valid") {
+          result.selected = true;
+          return result;
+        }
+      }
+    }
+    return null;
+  }
   getTraceAnchorCandidatePoints(label) {
     const seen = /* @__PURE__ */ new Set();
     const points = [];
@@ -8256,7 +8333,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       ]);
     }
     return getConnectorTracePath(
-      label.anchorPoint,
+      candidate.connectorSource ?? label.anchorPoint,
       candidate.anchorPoint,
       candidate.orientation
     );
@@ -8390,7 +8467,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return this.getSearchDistanceLimit(label, orientation);
   }
-  createCandidate(label, anchorPoint, orientation) {
+  createCandidate(label, anchorPoint, orientation, connectorSource) {
     const { width, height } = getDimsForOrientation({
       orientation,
       netLabelWidth: this.getNetLabelWidth(label),
@@ -8399,6 +8476,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     return {
       orientation,
       anchorPoint,
+      connectorSource,
       width,
       height,
       center: getCenterFromAnchor(anchorPoint, orientation, width, height)
@@ -8552,6 +8630,59 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return false;
   }
+  isOutwardHorizontalFallback(label) {
+    const chipSide = this.getChipSideForPoint(label.anchorPoint);
+    return chipSide === "left" && label.orientation === "x-" || chipSide === "right" && label.orientation === "x+";
+  }
+  hasPortOnlyLabelOnSameNet(label) {
+    return this.outputNetLabelPlacements.some(
+      (otherLabel) => otherLabel !== label && otherLabel.globalConnNetId === label.globalConnNetId && this.isPortOnlyLabel(otherLabel)
+    );
+  }
+  hasOppositeVerticalRailOnSameChipSide(label, orientation) {
+    const currentConnection = this.inputProblem.netConnections.find(
+      (connection) => connection.netId === label.netId
+    );
+    if (!currentConnection) return false;
+    const currentSide = this.getSingleChipSideForNetConnection(currentConnection);
+    if (!currentSide) return false;
+    const oppositeOrientation = orientation === "y+" ? "y-" : "y+";
+    return this.inputProblem.netConnections.some((connection) => {
+      if (connection === currentConnection || connection.pinIds.length < 2) {
+        return false;
+      }
+      const availableOrientations = this.inputProblem.availableNetLabelOrientations[connection.netId] ?? [];
+      if (availableOrientations.length !== 1 || availableOrientations[0] !== oppositeOrientation) {
+        return false;
+      }
+      const connectionSide = this.getSingleChipSideForNetConnection(connection);
+      return connectionSide?.chipId === currentSide.chipId && connectionSide.side === currentSide.side;
+    });
+  }
+  getSingleChipSideForNetConnection(connection) {
+    if (connection.pinIds.length < 2) return null;
+    const pins = connection.pinIds.map((pinId) => this.pinMap[pinId]);
+    if (pins.some((pin) => !pin)) return null;
+    const chipIds = new Set(pins.map((pin) => pin.chipId));
+    if (chipIds.size !== 1) return null;
+    const chipId = pins[0].chipId;
+    const chip = this.chipObstacleSpatialIndex.chips.find(
+      (candidate) => candidate.chipId === chipId
+    );
+    if (!chip) return null;
+    const sides = new Set(
+      pins.map((pin) => {
+        if (Math.abs(pin.x - chip.bounds.minX) <= EPS11) return "left";
+        if (Math.abs(pin.x - chip.bounds.maxX) <= EPS11) return "right";
+        return null;
+      })
+    );
+    if (sides.size !== 1 || sides.has(null)) return null;
+    return {
+      chipId,
+      side: [...sides][0]
+    };
+  }
   isPortOnlyLabel(label) {
     return label.mspConnectionPairIds.length === 0;
   }

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -9,7 +9,11 @@ import {
   getRectBounds,
 } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
-import type { InputPin, InputProblem } from "lib/types/InputProblem"
+import type {
+  InputNetConnection,
+  InputPin,
+  InputProblem,
+} from "lib/types/InputProblem"
 import { dir, type FacingDirection } from "lib/utils/dir"
 import { rectIntersectsAnyTextBox } from "lib/utils/textBoxBounds"
 import { EPS, LABEL_SEARCH_STEP, WICK_CLEARANCE } from "./constants"
@@ -250,10 +254,35 @@ export class AvailableNetOrientationSolver extends BaseSolver {
   private findCorrectedCandidate(label: NetLabelPlacement, labelIndex: number) {
     const orientations = this.getAvailableOrientations(label)
     const requiredOrientation = orientations[0]!
-    const isTwoPinNet = this.inputProblem.netConnections.some(
-      (connection) =>
-        connection.netId === label.netId && connection.pinIds.length === 2,
+    const netConnection = this.inputProblem.netConnections.find(
+      (connection) => connection.netId === label.netId,
     )
+    const isTwoPinNet = netConnection?.pinIds.length === 2
+    const isDistanceSplitVerticalRail =
+      (netConnection?.pinIds.length ?? 0) > 2 &&
+      isYOrientation(requiredOrientation) &&
+      this.hasPortOnlyLabelOnSameNet(label)
+    const isPairedSameSidePowerRail =
+      isYOrientation(requiredOrientation) &&
+      this.hasOppositeVerticalRailOnSameChipSide(label, requiredOrientation)
+    if (
+      orientations.length === 1 &&
+      isYOrientation(requiredOrientation) &&
+      this.isOutwardHorizontalFallback(label) &&
+      this.hasTraceContinuingInOrientation(label, requiredOrientation) &&
+      (isDistanceSplitVerticalRail || isPairedSameSidePowerRail)
+    ) {
+      // Keep the established outward column, but attach at the furthest trace
+      // point in the required vertical direction. This places y+ labels above
+      // a rail and y- labels below it while using a short horizontal connector.
+      const traceAnchorCandidate = this.findValidOutwardTraceAnchorCandidate(
+        label,
+        requiredOrientation,
+        labelIndex,
+      )
+      if (traceAnchorCandidate) return traceAnchorCandidate
+    }
+
     if (
       isTwoPinNet &&
       orientations.length === 1 &&
@@ -390,6 +419,86 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return null
   }
 
+  private findValidOutwardTraceAnchorCandidate(
+    label: NetLabelPlacement,
+    orientation: FacingDirection,
+    labelIndex: number,
+  ) {
+    const direction = dir(orientation)
+    const candidatePoints = this.getTraceAnchorCandidatePoints(label).sort(
+      (a, b) => {
+        const aAlongDirection = a.x * direction.x + a.y * direction.y
+        const bAlongDirection = b.x * direction.x + b.y * direction.y
+        return bAlongDirection - aAlongDirection
+      },
+    )
+
+    for (const connectorSource of candidatePoints) {
+      const preservedColumnAnchor = this.getSearchStartAnchor(
+        label,
+        orientation,
+      )
+      const preservedColumnCandidate = this.createCandidate(
+        label,
+        {
+          x: preservedColumnAnchor.x,
+          y: connectorSource.y,
+        },
+        orientation,
+        connectorSource,
+      )
+      const preservedColumnResult = this.evaluateCandidate(
+        preservedColumnCandidate,
+        label,
+        labelIndex,
+        "outward-trace-anchor",
+      )
+      this.currentCandidateResults.push(preservedColumnResult)
+      if (preservedColumnResult.status === "valid") {
+        preservedColumnResult.selected = true
+        return preservedColumnResult
+      }
+
+      const outwardDirection = this.getPerpendicularOutwardDirection(
+        connectorSource,
+        orientation,
+      )
+      if (outwardDirection.x === 0 && outwardDirection.y === 0) continue
+
+      for (
+        let distance = LABEL_SEARCH_STEP;
+        distance <= this.maxSearchDistance + EPS;
+        distance += LABEL_SEARCH_STEP
+      ) {
+        const anchorPoint = {
+          x: connectorSource.x + outwardDirection.x * distance,
+          y: connectorSource.y + outwardDirection.y * distance,
+        }
+        const candidate = this.createCandidate(
+          label,
+          anchorPoint,
+          orientation,
+          connectorSource,
+        )
+        const result = this.evaluateCandidate(
+          candidate,
+          label,
+          labelIndex,
+          "outward-trace-anchor",
+          distance,
+        )
+        this.currentCandidateResults.push(result)
+
+        if (result.status === "valid") {
+          result.selected = true
+          return result
+        }
+      }
+    }
+
+    return null
+  }
+
   private getTraceAnchorCandidatePoints(label: NetLabelPlacement) {
     const seen = new Set<string>()
     const points: Point[] = []
@@ -592,7 +701,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     label: NetLabelPlacement,
     candidate: Pick<
       EvaluatedCandidate,
-      "anchorPoint" | "orientation" | "phase"
+      "anchorPoint" | "connectorSource" | "orientation" | "phase"
     >,
   ) {
     if (candidate.phase === "lateral-shift") {
@@ -612,7 +721,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     }
 
     return getConnectorTracePath(
-      label.anchorPoint,
+      candidate.connectorSource ?? label.anchorPoint,
       candidate.anchorPoint,
       candidate.orientation,
     )
@@ -810,6 +919,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     label: NetLabelPlacement,
     anchorPoint: Point,
     orientation: FacingDirection,
+    connectorSource?: Point,
   ): CandidateLabel {
     const { width, height } = getDimsForOrientation({
       orientation,
@@ -819,6 +929,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return {
       orientation,
       anchorPoint,
+      connectorSource,
       width,
       height,
       center: getCenterFromAnchor(anchorPoint, orientation, width, height),
@@ -1029,6 +1140,89 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return false
   }
 
+  private isOutwardHorizontalFallback(label: NetLabelPlacement) {
+    const chipSide = this.getChipSideForPoint(label.anchorPoint)
+    return (
+      (chipSide === "left" && label.orientation === "x-") ||
+      (chipSide === "right" && label.orientation === "x+")
+    )
+  }
+
+  private hasPortOnlyLabelOnSameNet(label: NetLabelPlacement) {
+    return this.outputNetLabelPlacements.some(
+      (otherLabel) =>
+        otherLabel !== label &&
+        otherLabel.globalConnNetId === label.globalConnNetId &&
+        this.isPortOnlyLabel(otherLabel),
+    )
+  }
+
+  private hasOppositeVerticalRailOnSameChipSide(
+    label: NetLabelPlacement,
+    orientation: "y+" | "y-",
+  ) {
+    const currentConnection = this.inputProblem.netConnections.find(
+      (connection) => connection.netId === label.netId,
+    )
+    if (!currentConnection) return false
+
+    const currentSide =
+      this.getSingleChipSideForNetConnection(currentConnection)
+    if (!currentSide) return false
+
+    const oppositeOrientation = orientation === "y+" ? "y-" : "y+"
+    return this.inputProblem.netConnections.some((connection) => {
+      if (connection === currentConnection || connection.pinIds.length < 2) {
+        return false
+      }
+      const availableOrientations =
+        this.inputProblem.availableNetLabelOrientations[connection.netId] ?? []
+      if (
+        availableOrientations.length !== 1 ||
+        availableOrientations[0] !== oppositeOrientation
+      ) {
+        return false
+      }
+
+      const connectionSide = this.getSingleChipSideForNetConnection(connection)
+      return (
+        connectionSide?.chipId === currentSide.chipId &&
+        connectionSide.side === currentSide.side
+      )
+    })
+  }
+
+  private getSingleChipSideForNetConnection(
+    connection: InputNetConnection,
+  ): { chipId: string; side: "left" | "right" } | null {
+    if (connection.pinIds.length < 2) return null
+
+    const pins = connection.pinIds.map((pinId) => this.pinMap[pinId])
+    if (pins.some((pin) => !pin)) return null
+    const chipIds = new Set(pins.map((pin) => pin!.chipId))
+    if (chipIds.size !== 1) return null
+
+    const chipId = pins[0]!.chipId
+    const chip = this.chipObstacleSpatialIndex.chips.find(
+      (candidate) => candidate.chipId === chipId,
+    )
+    if (!chip) return null
+
+    const sides = new Set(
+      pins.map((pin) => {
+        if (Math.abs(pin!.x - chip.bounds.minX) <= EPS) return "left"
+        if (Math.abs(pin!.x - chip.bounds.maxX) <= EPS) return "right"
+        return null
+      }),
+    )
+    if (sides.size !== 1 || sides.has(null)) return null
+
+    return {
+      chipId,
+      side: [...sides][0] as "left" | "right",
+    }
+  }
+
   private isPortOnlyLabel(label: NetLabelPlacement) {
     return label.mspConnectionPairIds.length === 0
   }

package/lib/solvers/AvailableNetOrientationSolver/types.ts

@@ -22,6 +22,7 @@ export type ChipSide = "left" | "right" | "top" | "bottom"
 export type CandidateLabel = {
   orientation: FacingDirection
   anchorPoint: Point
+  connectorSource?: Point
   center: Point
   width: number
   height: number
@@ -38,6 +39,7 @@ export type CandidateStatus =
 export type CandidatePhase =
   | "rotate"
   | "trace-anchor"
+  | "outward-trace-anchor"
   | "shift"
   | "lateral-shift"
 

package/package.json

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