@tscircuit/schematic-trace-solver 0.0.179 → 0.0.180

package/dist/index.d.ts

@@ -831,7 +831,7 @@ type CandidateLabel = {
     height: number;
 };
 type CandidateStatus$2 = "valid" | "chip-collision" | "text-collision" | "trace-collision" | "trace-clearance-violation" | "netlabel-collision";
-type CandidatePhase = "rotate" | "trace-anchor" | "connected-rail-shift" | "outward-trace-anchor" | "shift" | "lateral-shift";
+type CandidatePhase = "rotate" | "trace-anchor" | "connected-rail-shift" | "downward-ground-rail-extension" | "outward-trace-anchor" | "shift" | "lateral-shift";
 type EvaluatedCandidate = CandidateLabel & {
     status: CandidateStatus$2;
     selected: boolean;
@@ -916,7 +916,7 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private createCandidate;
     private getNetLabelHeight;
     private getCandidateStatus;
-    private isAcceptableTraceAnchorChipCollision;
+    private isAcceptableConnectedChipBoundaryOverlap;
     private staysOutsideConnectedPinRow;
     private getBoundsStatus;
     private isTraceTooCloseToLabel;

package/dist/index.js

@@ -7709,6 +7709,27 @@ var TraceCleanupSolver = class extends BaseSolver {
 };
 
 // lib/solvers/AvailableNetOrientationSolver/traces.ts
+var extendVerticalTracePathAtInteriorPoint = ({
+  tracePath,
+  sourcePoint,
+  extensionEndPoint
+}) => {
+  const sourceIndex = tracePath.findIndex(
+    (point) => pointsEqual(point, sourcePoint)
+  );
+  if (sourceIndex <= 0 || sourceIndex >= tracePath.length - 1) return null;
+  const extensionDirectionY = extensionEndPoint.y - sourcePoint.y;
+  const adjacentIndex = [sourceIndex - 1, sourceIndex + 1].find((index) => {
+    const point = tracePath[index];
+    return isVertical2(point, sourcePoint) && (point.y - sourcePoint.y) * extensionDirectionY < 0;
+  });
+  if (adjacentIndex === void 0) return null;
+  return tracePath.toSpliced(
+    Math.max(sourceIndex, adjacentIndex),
+    0,
+    extensionEndPoint
+  );
+};
 var getPinMap = (inputProblem) => {
   const pinMap = {};
   for (const chip of inputProblem.chips) {
@@ -9028,6 +9049,7 @@ function getPaddedBounds(bounds, padding) {
 
 // lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts
 var LABEL_TRACE_CLEARANCE2 = 0.1;
+var MIN_DOWNWARD_GROUND_RAIL_EXTENSION = 0.2;
 var CONNECTED_PIN_ROW_OVERLAP_TOLERANCE = 0.1;
 var AvailableNetOrientationSolver = class extends BaseSolver {
   inputProblem;
@@ -9267,6 +9289,20 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   }
   addConnectorTrace(label, candidate, labelIndex) {
     if (candidate.phase === "trace-anchor") return;
+    if (candidate.phase === "downward-ground-rail-extension") {
+      for (const mspPairId2 of label.mspConnectionPairIds) {
+        const hostTrace = this.traceMap[mspPairId2];
+        if (!hostTrace) continue;
+        const extendedTracePath = extendVerticalTracePathAtInteriorPoint({
+          tracePath: hostTrace.tracePath,
+          sourcePoint: label.anchorPoint,
+          extensionEndPoint: candidate.anchorPoint
+        });
+        if (!extendedTracePath) continue;
+        hostTrace.tracePath = extendedTracePath;
+        return;
+      }
+    }
     const tracePath = this.getCandidateConnectorTrace(
       label,
       candidate,
@@ -9313,6 +9349,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       (connection) => connection.netId === label.netId
     );
     const isTwoPinNet = netConnection?.pinIds.length === 2;
+    const isDownwardGroundRail = netConnection?.isGround && isXOrientation(label.orientation) && orientations.length === 1 && requiredOrientation === "y-" && this.hasTraceContinuingInOrientation(label, "y+");
     const isDistanceSplitVerticalRail = (netConnection?.pinIds.length ?? 0) > 2 && isYOrientation(requiredOrientation) && this.hasPortOnlyLabelOnSameNet(label);
     const textBlockedMultiPinRailTraces = this.getTextBlockedMultiPinRailTraces(
       label,
@@ -9370,6 +9407,26 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       labelIndex,
       orientations
     );
+    const rotatedCandidateNeedsLateralBranch = rotatedCandidate !== null && Math.abs(rotatedCandidate.anchorPoint.x - label.anchorPoint.x) > EPS13;
+    if (isDownwardGroundRail && rotatedCandidateNeedsLateralBranch) {
+      const downwardRailCandidate = this.findValidCandidateInShiftColumn({
+        label,
+        labelIndex,
+        orientation: requiredOrientation,
+        direction: dir(requiredOrientation),
+        baseAnchor: label.anchorPoint,
+        maxSearchDistance: this.getSearchDistanceLimit(
+          label,
+          requiredOrientation
+        ),
+        outwardDistance: 0,
+        phase: "downward-ground-rail-extension",
+        stopOnTraceCollision: false,
+        connectorSource: label.anchorPoint,
+        startDistance: MIN_DOWNWARD_GROUND_RAIL_EXTENSION
+      });
+      if (downwardRailCandidate) return downwardRailCandidate;
+    }
     if (rotatedCandidate) return rotatedCandidate;
     const traceAnchorCandidate = this.findValidTraceAnchorCandidate(
       label,
@@ -10096,7 +10153,12 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       label
     });
     if (boundsStatus !== "valid") {
-      if (phase !== "trace-anchor" && phase !== "connected-rail-shift" || boundsStatus !== "chip-collision" || !this.isAcceptableTraceAnchorChipCollision(candidate, label, bounds) || phase === "connected-rail-shift" && !this.staysOutsideConnectedPinRow({ candidate, label, bounds })) {
+      const canOverlapConnectedChipBoundary = phase === "trace-anchor" || phase === "connected-rail-shift" || phase === "downward-ground-rail-extension";
+      if (!canOverlapConnectedChipBoundary || boundsStatus !== "chip-collision" || !this.isAcceptableConnectedChipBoundaryOverlap(
+        candidate,
+        label,
+        bounds
+      ) || phase === "connected-rail-shift" && !this.staysOutsideConnectedPinRow({ candidate, label, bounds })) {
         return boundsStatus;
       }
       const nonChipBoundsStatus = this.getBoundsStatus({
@@ -10140,7 +10202,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return "valid";
   }
-  isAcceptableTraceAnchorChipCollision(candidate, label, bounds) {
+  isAcceptableConnectedChipBoundaryOverlap(candidate, label, bounds) {
     const collidingChips = this.chipObstacleSpatialIndex.getChipsInBounds(bounds);
     if (collidingChips.length === 0) return false;
     const labelChipIds = new Set(

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -41,7 +41,12 @@ import {
   tracePathIntersectsBounds,
 } from "./geometry"
 import { orderRoutedLabelsBeforeOverlappingPortLabels } from "./orderRoutedLabelsBeforeOverlappingPortLabels"
-import { getPinMap, getTracePins, toNetLabelPlacementPatch } from "./traces"
+import {
+  extendVerticalTracePathAtInteriorPoint,
+  getPinMap,
+  getTracePins,
+  toNetLabelPlacementPatch,
+} from "./traces"
 import type {
   AvailableNetOrientationSolverParams,
   Bounds,
@@ -55,6 +60,7 @@ import { visualizeAvailableNetOrientationSolver } from "./visualize"
 import { AvailableNetOrientationObstacleIndex } from "./AvailableNetOrientationObstacleIndex"
 
 const LABEL_TRACE_CLEARANCE = 0.1
+const MIN_DOWNWARD_GROUND_RAIL_EXTENSION = 0.2
 const CONNECTED_PIN_ROW_OVERLAP_TOLERANCE = 0.1
 
 export class AvailableNetOrientationSolver extends BaseSolver {
@@ -357,6 +363,21 @@ export class AvailableNetOrientationSolver extends BaseSolver {
   ) {
     if (candidate.phase === "trace-anchor") return
 
+    if (candidate.phase === "downward-ground-rail-extension") {
+      for (const mspPairId of label.mspConnectionPairIds) {
+        const hostTrace = this.traceMap[mspPairId]
+        if (!hostTrace) continue
+        const extendedTracePath = extendVerticalTracePathAtInteriorPoint({
+          tracePath: hostTrace.tracePath,
+          sourcePoint: label.anchorPoint,
+          extensionEndPoint: candidate.anchorPoint,
+        })
+        if (!extendedTracePath) continue
+        hostTrace.tracePath = extendedTracePath
+        return
+      }
+    }
+
     const tracePath = this.getCandidateConnectorTrace(
       label,
       candidate,
@@ -416,6 +437,12 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       (connection) => connection.netId === label.netId,
     )
     const isTwoPinNet = netConnection?.pinIds.length === 2
+    const isDownwardGroundRail =
+      netConnection?.isGround &&
+      isXOrientation(label.orientation) &&
+      orientations.length === 1 &&
+      requiredOrientation === "y-" &&
+      this.hasTraceContinuingInOrientation(label, "y+")
     const isDistanceSplitVerticalRail =
       (netConnection?.pinIds.length ?? 0) > 2 &&
       isYOrientation(requiredOrientation) &&
@@ -495,6 +522,30 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       labelIndex,
       orientations,
     )
+    const rotatedCandidateNeedsLateralBranch =
+      rotatedCandidate !== null &&
+      Math.abs(rotatedCandidate.anchorPoint.x - label.anchorPoint.x) > EPS
+
+    if (isDownwardGroundRail && rotatedCandidateNeedsLateralBranch) {
+      const downwardRailCandidate = this.findValidCandidateInShiftColumn({
+        label,
+        labelIndex,
+        orientation: requiredOrientation,
+        direction: dir(requiredOrientation),
+        baseAnchor: label.anchorPoint,
+        maxSearchDistance: this.getSearchDistanceLimit(
+          label,
+          requiredOrientation,
+        ),
+        outwardDistance: 0,
+        phase: "downward-ground-rail-extension",
+        stopOnTraceCollision: false,
+        connectorSource: label.anchorPoint,
+        startDistance: MIN_DOWNWARD_GROUND_RAIL_EXTENSION,
+      })
+      if (downwardRailCandidate) return downwardRailCandidate
+    }
+
     if (rotatedCandidate) return rotatedCandidate
 
     const traceAnchorCandidate = this.findValidTraceAnchorCandidate(
@@ -1525,10 +1576,18 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       label,
     })
     if (boundsStatus !== "valid") {
+      const canOverlapConnectedChipBoundary =
+        phase === "trace-anchor" ||
+        phase === "connected-rail-shift" ||
+        phase === "downward-ground-rail-extension"
       if (
-        (phase !== "trace-anchor" && phase !== "connected-rail-shift") ||
+        !canOverlapConnectedChipBoundary ||
         boundsStatus !== "chip-collision" ||
-        !this.isAcceptableTraceAnchorChipCollision(candidate, label, bounds) ||
+        !this.isAcceptableConnectedChipBoundaryOverlap(
+          candidate,
+          label,
+          bounds,
+        ) ||
         (phase === "connected-rail-shift" &&
           !this.staysOutsideConnectedPinRow({ candidate, label, bounds }))
       ) {
@@ -1587,7 +1646,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return "valid"
   }
 
-  private isAcceptableTraceAnchorChipCollision(
+  private isAcceptableConnectedChipBoundaryOverlap(
     candidate: CandidateLabel,
     label: NetLabelPlacement,
     bounds: Bounds,

package/lib/solvers/AvailableNetOrientationSolver/traces.ts

@@ -1,8 +1,44 @@
+import type { Point } from "@tscircuit/math-utils"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  isVertical,
+  pointsEqual,
+} from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
 import type { InputPin, InputProblem } from "lib/types/InputProblem"
 import type { CandidateLabel } from "./types"
 
+export const extendVerticalTracePathAtInteriorPoint = ({
+  tracePath,
+  sourcePoint,
+  extensionEndPoint,
+}: {
+  tracePath: Point[]
+  sourcePoint: Point
+  extensionEndPoint: Point
+}) => {
+  const sourceIndex = tracePath.findIndex((point) =>
+    pointsEqual(point, sourcePoint),
+  )
+  if (sourceIndex <= 0 || sourceIndex >= tracePath.length - 1) return null
+
+  const extensionDirectionY = extensionEndPoint.y - sourcePoint.y
+  const adjacentIndex = [sourceIndex - 1, sourceIndex + 1].find((index) => {
+    const point = tracePath[index]!
+    return (
+      isVertical(point, sourcePoint) &&
+      (point.y - sourcePoint.y) * extensionDirectionY < 0
+    )
+  })
+  if (adjacentIndex === undefined) return null
+
+  return tracePath.toSpliced(
+    Math.max(sourceIndex, adjacentIndex),
+    0,
+    extensionEndPoint,
+  )
+}
+
 export const getPinMap = (inputProblem: InputProblem) => {
   const pinMap: Record<string, InputPin & { chipId: string }> = {}
   for (const chip of inputProblem.chips) {

package/lib/solvers/AvailableNetOrientationSolver/types.ts

@@ -40,6 +40,7 @@ export type CandidatePhase =
   | "rotate"
   | "trace-anchor"
   | "connected-rail-shift"
+  | "downward-ground-rail-extension"
   | "outward-trace-anchor"
   | "shift"
   | "lateral-shift"

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/tscircuit/schematic-trace-solver.git"
   },
   "main": "dist/index.js",
-  "version": "0.0.179",
+  "version": "0.0.180",
   "type": "module",
   "scripts": {
     "start": "cosmos",