@tscircuit/schematic-trace-solver 0.0.178 → 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;
@@ -900,6 +900,12 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private evaluateCandidate;
     private recordCandidateResult;
     private getCandidateConnectorTrace;
+    /**
+     * A laterally shifted label can branch directly from the interior of its
+     * existing host trace. Prefer that tee over running a new connector beside
+     * the host trace from the old label anchor.
+     */
+    private findProjectedConnectorSourceOnHostTrace;
     private isStandaloneSinglePinNetLabel;
     private labelIntersectsDifferentNetTrace;
     private getSearchStartAnchor;
@@ -910,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,
@@ -9784,11 +9841,16 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         x: baseAnchor.x + direction.x * distance7,
         y: baseAnchor.y + direction.y * distance7
       };
+      const projectedConnectorSource = connectorSource ?? (phase === "lateral-shift" ? this.findProjectedConnectorSourceOnHostTrace(
+        label,
+        anchorPoint,
+        orientation
+      ) : void 0);
       const candidate = this.createCandidate(
         label,
         anchorPoint,
         orientation,
-        connectorSource
+        projectedConnectorSource
       );
       const result = this.evaluateCandidate(
         candidate,
@@ -9842,6 +9904,13 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         candidate.anchorPoint
       ]);
     }
+    if (candidate.connectorSource) {
+      return getConnectorTracePath(
+        candidate.connectorSource,
+        candidate.anchorPoint,
+        candidate.orientation
+      );
+    }
     if (candidate.phase === "lateral-shift") {
       const chipOutwardDir = this.crowdedPortOnlyLabelIndices.has(labelIndex) ? this.getChipOutwardDirection(label.anchorPoint) : (() => {
         const orientDir = dir(candidate.orientation);
@@ -9861,11 +9930,41 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       ]);
     }
     return getConnectorTracePath(
-      candidate.connectorSource ?? label.anchorPoint,
+      label.anchorPoint,
       candidate.anchorPoint,
       candidate.orientation
     );
   }
+  /**
+   * A laterally shifted label can branch directly from the interior of its
+   * existing host trace. Prefer that tee over running a new connector beside
+   * the host trace from the old label anchor.
+   */
+  findProjectedConnectorSourceOnHostTrace(label, targetAnchor, orientation) {
+    const orientationDirection = dir(orientation);
+    const projectedSources = [];
+    for (const traceId of label.mspConnectionPairIds) {
+      const hostTrace = this.traceMap[traceId];
+      if (!hostTrace) continue;
+      for (let pointIndex = 0; pointIndex < hostTrace.tracePath.length - 1; pointIndex++) {
+        const start = hostTrace.tracePath[pointIndex];
+        const end = hostTrace.tracePath[pointIndex + 1];
+        const segmentIsPerpendicularToLabel = isYOrientation(orientation) ? Math.abs(start.y - end.y) <= EPS13 : Math.abs(start.x - end.x) <= EPS13;
+        if (!segmentIsPerpendicularToLabel) continue;
+        const source = isYOrientation(orientation) ? { x: targetAnchor.x, y: start.y } : { x: start.x, y: targetAnchor.y };
+        if (!tracePathContainsPoint([start, end], label.anchorPoint) || !tracePathContainsPoint([start, end], source)) {
+          continue;
+        }
+        const targetDistanceAlongOrientation = (targetAnchor.x - source.x) * orientationDirection.x + (targetAnchor.y - source.y) * orientationDirection.y;
+        if (targetDistanceAlongOrientation >= -EPS13) {
+          projectedSources.push(source);
+        }
+      }
+    }
+    return projectedSources.sort(
+      (first, second) => Math.abs(first.x - targetAnchor.x) + Math.abs(first.y - targetAnchor.y) - (Math.abs(second.x - targetAnchor.x) + Math.abs(second.y - targetAnchor.y))
+    )[0];
+  }
   isStandaloneSinglePinNetLabel(label) {
     return this.inputProblem.netConnections.some(
       (connection) => connection.netId === label.netId && connection.pinIds.length === 1 && connection.pinIds[0] === label.pinIds[0]
@@ -10054,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({
@@ -10069,6 +10173,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       label,
       {
         anchorPoint: candidate.anchorPoint,
+        connectorSource: phase === "lateral-shift" ? candidate.connectorSource : void 0,
         orientation: candidate.orientation,
         phase
       },
@@ -10097,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(
@@ -1076,11 +1127,20 @@ export class AvailableNetOrientationSolver extends BaseSolver {
         x: baseAnchor.x + direction.x * distance,
         y: baseAnchor.y + direction.y * distance,
       }
+      const projectedConnectorSource =
+        connectorSource ??
+        (phase === "lateral-shift"
+          ? this.findProjectedConnectorSourceOnHostTrace(
+              label,
+              anchorPoint,
+              orientation,
+            )
+          : undefined)
       const candidate = this.createCandidate(
         label,
         anchorPoint,
         orientation,
-        connectorSource,
+        projectedConnectorSource,
       )
       const result = this.evaluateCandidate(
         candidate,
@@ -1163,6 +1223,14 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       ])
     }
 
+    if (candidate.connectorSource) {
+      return getConnectorTracePath(
+        candidate.connectorSource,
+        candidate.anchorPoint,
+        candidate.orientation,
+      )
+    }
+
     if (candidate.phase === "lateral-shift") {
       const chipOutwardDir = this.crowdedPortOnlyLabelIndices.has(labelIndex)
         ? this.getChipOutwardDirection(label.anchorPoint)
@@ -1185,12 +1253,69 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     }
 
     return getConnectorTracePath(
-      candidate.connectorSource ?? label.anchorPoint,
+      label.anchorPoint,
       candidate.anchorPoint,
       candidate.orientation,
     )
   }
 
+  /**
+   * A laterally shifted label can branch directly from the interior of its
+   * existing host trace. Prefer that tee over running a new connector beside
+   * the host trace from the old label anchor.
+   */
+  private findProjectedConnectorSourceOnHostTrace(
+    label: NetLabelPlacement,
+    targetAnchor: Point,
+    orientation: FacingDirection,
+  ): Point | undefined {
+    const orientationDirection = dir(orientation)
+    const projectedSources: Point[] = []
+
+    for (const traceId of label.mspConnectionPairIds) {
+      const hostTrace = this.traceMap[traceId]
+      if (!hostTrace) continue
+
+      for (
+        let pointIndex = 0;
+        pointIndex < hostTrace.tracePath.length - 1;
+        pointIndex++
+      ) {
+        const start = hostTrace.tracePath[pointIndex]!
+        const end = hostTrace.tracePath[pointIndex + 1]!
+        const segmentIsPerpendicularToLabel = isYOrientation(orientation)
+          ? Math.abs(start.y - end.y) <= EPS
+          : Math.abs(start.x - end.x) <= EPS
+        if (!segmentIsPerpendicularToLabel) continue
+
+        const source = isYOrientation(orientation)
+          ? { x: targetAnchor.x, y: start.y }
+          : { x: start.x, y: targetAnchor.y }
+        if (
+          !tracePathContainsPoint([start, end], label.anchorPoint) ||
+          !tracePathContainsPoint([start, end], source)
+        ) {
+          continue
+        }
+
+        const targetDistanceAlongOrientation =
+          (targetAnchor.x - source.x) * orientationDirection.x +
+          (targetAnchor.y - source.y) * orientationDirection.y
+        if (targetDistanceAlongOrientation >= -EPS) {
+          projectedSources.push(source)
+        }
+      }
+    }
+
+    return projectedSources.sort(
+      (first, second) =>
+        Math.abs(first.x - targetAnchor.x) +
+        Math.abs(first.y - targetAnchor.y) -
+        (Math.abs(second.x - targetAnchor.x) +
+          Math.abs(second.y - targetAnchor.y)),
+    )[0]
+  }
+
   private isStandaloneSinglePinNetLabel(label: NetLabelPlacement) {
     return this.inputProblem.netConnections.some(
       (connection) =>
@@ -1451,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 }))
       ) {
@@ -1474,6 +1607,8 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       label,
       {
         anchorPoint: candidate.anchorPoint,
+        connectorSource:
+          phase === "lateral-shift" ? candidate.connectorSource : undefined,
         orientation: candidate.orientation,
         phase,
       },
@@ -1511,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.178",
+  "version": "0.0.180",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/site/bug-reports/bug-report-20260902T092101Z.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/bug-reports/bug-report-20260902T092101Z/bug-report-20260902T092101Z.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />

package/site/bug-reports/bug-report-20260902T092425Z.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/bug-reports/bug-report-20260902T092425Z/bug-report-20260902T092425Z.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />