@tscircuit/schematic-trace-solver 0.0.179 → 0.0.181

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(
@@ -13220,11 +13282,26 @@ var getAlignedSharedEndpointRailPath = ({
   const donorDeparture = donorPath[1][donorDepartureAxis] - donorPath[0][donorDepartureAxis];
   const branchDeparture = branchPath[1][branchDepartureAxis] - branchPath[0][branchDepartureAxis];
   if (Math.sign(donorDeparture) !== Math.sign(branchDeparture)) return null;
-  const donorRailAxis = getSegmentAxis3(donorPath[1], donorPath[2]);
-  const branchRailAxis = getSegmentAxis3(branchPath[1], branchPath[2]);
+  let railIndex = 1;
+  let donorRailAxis = getSegmentAxis3(donorPath[1], donorPath[2]);
+  let branchRailAxis = getSegmentAxis3(branchPath[1], branchPath[2]);
   if (!donorRailAxis || donorRailAxis !== branchRailAxis || donorRailAxis === donorDepartureAxis) {
     return null;
   }
+  const firstRailsAreAligned = donorRailAxis === "x" && nearlyEqual(donorPath[1].y, branchPath[1].y) || donorRailAxis === "y" && nearlyEqual(donorPath[1].x, branchPath[1].x);
+  if (firstRailsAreAligned) {
+    railIndex++;
+    if (!donorPath[railIndex + 2] || !branchPath[railIndex + 2]) return null;
+    donorRailAxis = getSegmentAxis3(
+      donorPath[railIndex],
+      donorPath[railIndex + 1]
+    );
+    branchRailAxis = getSegmentAxis3(
+      branchPath[railIndex],
+      branchPath[railIndex + 1]
+    );
+    if (!donorRailAxis || donorRailAxis !== branchRailAxis) return null;
+  }
   let branchParallelRailCount = 0;
   for (let index = 1; index < branchPath.length - 2; index++) {
     if (getSegmentAxis3(branchPath[index], branchPath[index + 1]) === branchRailAxis) {
@@ -13233,25 +13310,25 @@ var getAlignedSharedEndpointRailPath = ({
   }
   if (branchParallelRailCount !== 1) return null;
   const railCoordinateAxis = donorRailAxis === "x" ? "y" : "x";
-  const donorCoordinate = donorPath[1][railCoordinateAxis];
-  const branchCoordinate = branchPath[1][railCoordinateAxis];
+  const donorCoordinate = donorPath[railIndex][railCoordinateAxis];
+  const branchCoordinate = branchPath[railIndex][railCoordinateAxis];
   const railOffset = Math.abs(donorCoordinate - branchCoordinate);
   if (nearlyEqual(donorCoordinate, branchCoordinate) || railOffset > MAX_SHARED_ENDPOINT_RAIL_OFFSET) {
     return null;
   }
   const donorRange = [
-    donorPath[1][donorRailAxis],
-    donorPath[2][donorRailAxis]
+    donorPath[railIndex][donorRailAxis],
+    donorPath[railIndex + 1][donorRailAxis]
   ].sort((a, b) => a - b);
   const branchRange = [
-    branchPath[1][branchRailAxis],
-    branchPath[2][branchRailAxis]
+    branchPath[railIndex][branchRailAxis],
+    branchPath[railIndex + 1][branchRailAxis]
   ].sort((a, b) => a - b);
   const railsTouchAfterAlignment = Math.min(donorRange[1], branchRange[1]) >= Math.max(donorRange[0], branchRange[0]) - 1e-6;
   if (!railsTouchAfterAlignment) return null;
   const candidateFromShared = simplifyPath(
     branchPath.map(
-      (point, index) => index === 1 || index === 2 ? { ...point, [railCoordinateAxis]: donorCoordinate } : point
+      (point, index) => index === railIndex || index === railIndex + 1 ? { ...point, [railCoordinateAxis]: donorCoordinate } : point
     )
   );
   return branchTrace.pins[0].pinId === sharedPin.pinId ? candidateFromShared : candidateFromShared.reverse();

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/lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts

@@ -375,8 +375,8 @@ const getAlignedParallelPinExitPath = ({
 }
 
 /**
- * Move the first movable rail of a branch onto the first rail of another
- * trace leaving the same endpoint. The two perpendicular rail intervals must
+ * Move the first divergent movable rail of a branch onto the matching rail of
+ * another trace leaving the same endpoint. The two rail intervals must
  * touch after the move; the caller then verifies that the combined visible
  * trace loses a segment and that the reroute is clear.
  */
@@ -419,8 +419,9 @@ const getAlignedSharedEndpointRailPath = ({
     branchPath[1]![branchDepartureAxis] - branchPath[0]![branchDepartureAxis]
   if (Math.sign(donorDeparture) !== Math.sign(branchDeparture)) return null
 
-  const donorRailAxis = getSegmentAxis(donorPath[1]!, donorPath[2]!)
-  const branchRailAxis = getSegmentAxis(branchPath[1]!, branchPath[2]!)
+  let railIndex = 1
+  let donorRailAxis = getSegmentAxis(donorPath[1]!, donorPath[2]!)
+  let branchRailAxis = getSegmentAxis(branchPath[1]!, branchPath[2]!)
   if (
     !donorRailAxis ||
     donorRailAxis !== branchRailAxis ||
@@ -428,6 +429,23 @@ const getAlignedSharedEndpointRailPath = ({
   ) {
     return null
   }
+  const firstRailsAreAligned =
+    (donorRailAxis === "x" && nearlyEqual(donorPath[1]!.y, branchPath[1]!.y)) ||
+    (donorRailAxis === "y" && nearlyEqual(donorPath[1]!.x, branchPath[1]!.x))
+  // An already-shared rail can lead into the nearby parallel pair to merge.
+  if (firstRailsAreAligned) {
+    railIndex++
+    if (!donorPath[railIndex + 2] || !branchPath[railIndex + 2]) return null
+    donorRailAxis = getSegmentAxis(
+      donorPath[railIndex]!,
+      donorPath[railIndex + 1]!,
+    )
+    branchRailAxis = getSegmentAxis(
+      branchPath[railIndex]!,
+      branchPath[railIndex + 1]!,
+    )
+    if (!donorRailAxis || donorRailAxis !== branchRailAxis) return null
+  }
   // A return bus has another rail with this orientation near its far
   // endpoint. Moving only the first rail would partially rewrite a shape that
   // must be evaluated as a whole by the endpoint-bus transformation.
@@ -443,8 +461,8 @@ const getAlignedSharedEndpointRailPath = ({
   if (branchParallelRailCount !== 1) return null
 
   const railCoordinateAxis = donorRailAxis === "x" ? "y" : "x"
-  const donorCoordinate = donorPath[1]![railCoordinateAxis]
-  const branchCoordinate = branchPath[1]![railCoordinateAxis]
+  const donorCoordinate = donorPath[railIndex]![railCoordinateAxis]
+  const branchCoordinate = branchPath[railIndex]![railCoordinateAxis]
   const railOffset = Math.abs(donorCoordinate - branchCoordinate)
   if (
     nearlyEqual(donorCoordinate, branchCoordinate) ||
@@ -454,12 +472,12 @@ const getAlignedSharedEndpointRailPath = ({
   }
 
   const donorRange = [
-    donorPath[1]![donorRailAxis],
-    donorPath[2]![donorRailAxis],
+    donorPath[railIndex]![donorRailAxis],
+    donorPath[railIndex + 1]![donorRailAxis],
   ].sort((a, b) => a - b)
   const branchRange = [
-    branchPath[1]![branchRailAxis],
-    branchPath[2]![branchRailAxis],
+    branchPath[railIndex]![branchRailAxis],
+    branchPath[railIndex + 1]![branchRailAxis],
   ].sort((a, b) => a - b)
   const railsTouchAfterAlignment =
     Math.min(donorRange[1]!, branchRange[1]!) >=
@@ -468,7 +486,7 @@ const getAlignedSharedEndpointRailPath = ({
 
   const candidateFromShared = simplifyPath(
     branchPath.map((point, index) =>
-      index === 1 || index === 2
+      index === railIndex || index === railIndex + 1
         ? { ...point, [railCoordinateAxis]: donorCoordinate }
         : point,
     ),

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.181",
   "type": "module",
   "scripts": {
     "start": "cosmos",