@tscircuit/schematic-trace-solver 0.0.184 → 0.0.186

package/dist/index.d.ts

@@ -936,6 +936,16 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private hasOppositeVerticalRailOnSameChipSide;
     private getSingleChipSideForNetConnection;
     private isPortOnlyLabel;
+    private getNetConnectionForLabel;
+    private isGroundLabel;
+    /**
+     * A vertical-only input stores its text extent in netLabelHeight. If its
+     * initial port-only placement is horizontal, use that extent for collision
+     * checks without changing the placement dimensions returned by the solver.
+     */
+    private getHorizontalConstraintMismatchBounds;
+    private includeHorizontalConstraintMismatches;
+    private getLabelBoundsForCollisionWithGround;
     private shouldIgnorePendingCrowdedLabel;
     private intersectsAnyOtherNetLabel;
     private sharesChipBoundary;

package/dist/index.js

@@ -9413,6 +9413,17 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     if (this.getTextBlockedMultiPinRailTraces(label, orientations[0])) {
       return true;
     }
+    const hasSingleVerticalOrientation = orientations.length === 1 && isYOrientation(orientations[0]);
+    if (hasSingleVerticalOrientation && this.isGroundLabel(label)) {
+      const bounds2 = getRectBounds(label.center, label.width, label.height);
+      const overlapsHorizontalConstraintMismatch = this.outputNetLabelPlacements.some((otherLabel, otherIndex) => {
+        if (otherIndex === labelIndex) return false;
+        if (otherLabel.globalConnNetId === label.globalConnNetId) return false;
+        const otherBounds = this.getHorizontalConstraintMismatchBounds(otherLabel);
+        return otherBounds ? rectsOverlap2(bounds2, otherBounds) : false;
+      });
+      if (overlapsHorizontalConstraintMismatch) return true;
+    }
     if (!this.crowdedPortOnlyLabelIndices.has(labelIndex)) return false;
     const bounds = getRectBounds(label.center, label.width, label.height);
     return this.outputNetLabelPlacements.some((otherLabel, otherIndex) => {
@@ -10386,15 +10397,17 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         return "text-collision";
       }
     }
-    for (const i of this.obstacleIndex.getLabelIndicesNearTracePath(
-      connectorTrace
-    )) {
+    const nearbyLabelIndices = this.includeHorizontalConstraintMismatches(
+      this.obstacleIndex.getLabelIndicesNearTracePath(connectorTrace),
+      this.isGroundLabel(label)
+    );
+    for (const i of nearbyLabelIndices) {
       if (i === labelIndex) continue;
       if (this.shouldIgnorePendingCrowdedLabel(labelIndex, i)) continue;
       const otherLabel = this.outputNetLabelPlacements[i];
       if (tracePathIntersectsBounds(
         connectorTrace,
-        getRectBounds(otherLabel.center, otherLabel.width, otherLabel.height)
+        this.getLabelBoundsForCollisionWithGround(otherLabel, label)
       )) {
         return "netlabel-collision";
       }
@@ -10445,7 +10458,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     if (this.isTraceTooCloseToLabel(bounds, label)) {
       return "trace-clearance-violation";
     }
-    if (this.intersectsAnyOtherNetLabel(bounds, labelIndex)) {
+    if (this.intersectsAnyOtherNetLabel(bounds, labelIndex, label)) {
       return "netlabel-collision";
     }
     return "valid";
@@ -10645,22 +10658,95 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   isPortOnlyLabel(label) {
     return label.mspConnectionPairIds.length === 0;
   }
+  getNetConnectionForLabel(label) {
+    return label.netId ? this.inputProblem.netConnections.find(
+      (connection) => connection.netId === label.netId
+    ) : this.inputProblem.netConnections.find(
+      (connection) => connection.pinIds.some((pinId) => label.pinIds.includes(pinId))
+    );
+  }
+  isGroundLabel(label) {
+    return this.getNetConnectionForLabel(label)?.isGround === true;
+  }
+  /**
+   * A vertical-only input stores its text extent in netLabelHeight. If its
+   * initial port-only placement is horizontal, use that extent for collision
+   * checks without changing the placement dimensions returned by the solver.
+   */
+  getHorizontalConstraintMismatchBounds(label) {
+    if (!this.isPortOnlyLabel(label)) return null;
+    if (label.orientation !== "x+" && label.orientation !== "x-") return null;
+    const effectiveNetId = label.netId ?? label.globalConnNetId;
+    const orientations = this.inputProblem.availableNetLabelOrientations[effectiveNetId] ?? [];
+    if (orientations.length === 0 || orientations.some((orientation) => !isYOrientation(orientation))) {
+      return null;
+    }
+    const renderedWidth = this.getNetConnectionForLabel(label)?.netLabelHeight;
+    if (renderedWidth === void 0 || renderedWidth <= label.width + label.height + EPS13) {
+      return null;
+    }
+    const placementBaseCenter = getCenterFromAnchor(
+      label.anchorPoint,
+      label.orientation,
+      label.width,
+      label.height
+    );
+    const renderedBaseCenter = getCenterFromAnchor(
+      label.anchorPoint,
+      label.orientation,
+      renderedWidth,
+      label.height
+    );
+    return getRectBounds(
+      {
+        x: renderedBaseCenter.x + label.center.x - placementBaseCenter.x,
+        y: renderedBaseCenter.y + label.center.y - placementBaseCenter.y
+      },
+      renderedWidth,
+      label.height
+    );
+  }
+  includeHorizontalConstraintMismatches(labelIndices, include) {
+    if (!include) return [...labelIndices].sort((a, b) => a - b);
+    const result = new Set(labelIndices);
+    for (let index = 0; index < this.outputNetLabelPlacements.length; index++) {
+      if (this.getHorizontalConstraintMismatchBounds(
+        this.outputNetLabelPlacements[index]
+      )) {
+        result.add(index);
+      }
+    }
+    return [...result].sort((a, b) => a - b);
+  }
+  getLabelBoundsForCollisionWithGround(label, currentLabel) {
+    if (this.isGroundLabel(currentLabel)) {
+      const adjustedBounds = this.getHorizontalConstraintMismatchBounds(label);
+      if (adjustedBounds) return adjustedBounds;
+    }
+    return getRectBounds(label.center, label.width, label.height);
+  }
   shouldIgnorePendingCrowdedLabel(labelIndex, otherLabelIndex) {
     return this.crowdedPortOnlyLabelIndices.has(labelIndex) && this.crowdedPortOnlyLabelIndices.has(otherLabelIndex) && this.queuedLabelIndices.includes(otherLabelIndex);
   }
-  intersectsAnyOtherNetLabel(bounds, labelIndex) {
+  intersectsAnyOtherNetLabel(bounds, labelIndex, currentLabel) {
     const searchBounds = {
       minX: bounds.minX - LABEL_SEARCH_STEP,
       minY: bounds.minY - LABEL_SEARCH_STEP,
       maxX: bounds.maxX + LABEL_SEARCH_STEP,
       maxY: bounds.maxY + LABEL_SEARCH_STEP
     };
-    const nearbyLabelIndices = this.obstacleIndex.getLabelIndicesInBounds(searchBounds).sort((a, b) => a - b);
+    const nearbyLabelIndices = this.includeHorizontalConstraintMismatches(
+      this.obstacleIndex.getLabelIndicesInBounds(searchBounds),
+      this.isGroundLabel(currentLabel)
+    );
     for (const i of nearbyLabelIndices) {
       if (i === labelIndex) continue;
       if (this.shouldIgnorePendingCrowdedLabel(labelIndex, i)) continue;
       const label = this.outputNetLabelPlacements[i];
-      const otherBounds = getRectBounds(label.center, label.width, label.height);
+      const otherBounds = this.getLabelBoundsForCollisionWithGround(
+        label,
+        currentLabel
+      );
       if (i === this.blockedStandaloneLabelIndex && isYOrientation(label.orientation)) {
         otherBounds.minX -= LABEL_SEARCH_STEP;
         otherBounds.maxX += LABEL_SEARCH_STEP;
@@ -12659,6 +12745,7 @@ ${c.status}`
 
 // lib/solvers/UnroutedTraceRecoverySolver/UnroutedTraceRecoverySolver.ts
 import { distance as distance6, doSegmentsIntersect as doSegmentsIntersect3 } from "@tscircuit/math-utils";
+import { calculateElbow as calculateElbow3 } from "calculate-elbow";
 var ROUTE_CLEARANCE = 0.2;
 var COORDINATE_TOLERANCE = 1e-9;
 var GROUND_NET_ID = "GND";
@@ -12711,7 +12798,7 @@ var getOuterBounds = (obstacles) => {
     maxY: Math.max(...obstacles.map((obstacle) => obstacle.maxY))
   };
 };
-var getPerimeterCandidates = ({
+var getPinConnectionCandidates = ({
   connectionPair,
   obstacles
 }) => {
@@ -12733,7 +12820,13 @@ var getPerimeterCandidates = ({
     outerBounds.minX - ROUTE_CLEARANCE,
     outerBounds.maxX + ROUTE_CLEARANCE
   ];
-  const candidates = [];
+  const candidates = [
+    calculateElbow3(
+      { ...firstPin, facingDirection: firstPin._facingDirection },
+      { ...secondPin, facingDirection: secondPin._facingDirection },
+      { overshoot: ROUTE_CLEARANCE }
+    )
+  ];
   for (const channelY of horizontalChannels) {
     candidates.push(
       removeConsecutiveDuplicatePoints([
@@ -13053,11 +13146,11 @@ var UnroutedTraceRecoverySolver = class extends BaseSolver {
       obstacles,
       maxConnectionDistance: this.maxConnectionDistance
     });
-    const perimeterCandidates = getPerimeterCandidates({
+    const pinConnectionCandidates = getPinConnectionCandidates({
       connectionPair,
       obstacles
     });
-    const candidates = [...junctionCandidates, ...perimeterCandidates];
+    const candidates = [...junctionCandidates, ...pinConnectionCandidates];
     const rejectComponentBoundaryTravel = hasParallelFailedConnection({
       connectionPair,
       failedConnectionPairs: this.failedConnectionPairs

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -268,6 +268,22 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     if (this.getTextBlockedMultiPinRailTraces(label, orientations[0]!)) {
       return true
     }
+
+    const hasSingleVerticalOrientation =
+      orientations.length === 1 && isYOrientation(orientations[0]!)
+    if (hasSingleVerticalOrientation && this.isGroundLabel(label)) {
+      const bounds = getRectBounds(label.center, label.width, label.height)
+      const overlapsHorizontalConstraintMismatch =
+        this.outputNetLabelPlacements.some((otherLabel, otherIndex) => {
+          if (otherIndex === labelIndex) return false
+          if (otherLabel.globalConnNetId === label.globalConnNetId) return false
+          const otherBounds =
+            this.getHorizontalConstraintMismatchBounds(otherLabel)
+          return otherBounds ? rectsOverlap(bounds, otherBounds) : false
+        })
+      if (overlapsHorizontalConstraintMismatch) return true
+    }
+
     if (!this.crowdedPortOnlyLabelIndices.has(labelIndex)) return false
 
     const bounds = getRectBounds(label.center, label.width, label.height)
@@ -1627,16 +1643,18 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       }
     }
 
-    for (const i of this.obstacleIndex.getLabelIndicesNearTracePath(
-      connectorTrace,
-    )) {
+    const nearbyLabelIndices = this.includeHorizontalConstraintMismatches(
+      this.obstacleIndex.getLabelIndicesNearTracePath(connectorTrace),
+      this.isGroundLabel(label),
+    )
+    for (const i of nearbyLabelIndices) {
       if (i === labelIndex) continue
       if (this.shouldIgnorePendingCrowdedLabel(labelIndex, i)) continue
       const otherLabel = this.outputNetLabelPlacements[i]!
       if (
         tracePathIntersectsBounds(
           connectorTrace,
-          getRectBounds(otherLabel.center, otherLabel.width, otherLabel.height),
+          this.getLabelBoundsForCollisionWithGround(otherLabel, label),
         )
       ) {
         return "netlabel-collision"
@@ -1719,7 +1737,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     if (this.isTraceTooCloseToLabel(bounds, label)) {
       return "trace-clearance-violation"
     }
-    if (this.intersectsAnyOtherNetLabel(bounds, labelIndex)) {
+    if (this.intersectsAnyOtherNetLabel(bounds, labelIndex, label)) {
       return "netlabel-collision"
     }
     return "valid"
@@ -2020,6 +2038,99 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return label.mspConnectionPairIds.length === 0
   }
 
+  private getNetConnectionForLabel(label: NetLabelPlacement) {
+    return label.netId
+      ? this.inputProblem.netConnections.find(
+          (connection) => connection.netId === label.netId,
+        )
+      : this.inputProblem.netConnections.find((connection) =>
+          connection.pinIds.some((pinId) => label.pinIds.includes(pinId)),
+        )
+  }
+
+  private isGroundLabel(label: NetLabelPlacement) {
+    return this.getNetConnectionForLabel(label)?.isGround === true
+  }
+
+  /**
+   * A vertical-only input stores its text extent in netLabelHeight. If its
+   * initial port-only placement is horizontal, use that extent for collision
+   * checks without changing the placement dimensions returned by the solver.
+   */
+  private getHorizontalConstraintMismatchBounds(label: NetLabelPlacement) {
+    if (!this.isPortOnlyLabel(label)) return null
+    if (label.orientation !== "x+" && label.orientation !== "x-") return null
+
+    const effectiveNetId = label.netId ?? label.globalConnNetId
+    const orientations =
+      this.inputProblem.availableNetLabelOrientations[effectiveNetId] ?? []
+    if (
+      orientations.length === 0 ||
+      orientations.some((orientation) => !isYOrientation(orientation))
+    ) {
+      return null
+    }
+
+    const renderedWidth = this.getNetConnectionForLabel(label)?.netLabelHeight
+    if (
+      renderedWidth === undefined ||
+      renderedWidth <= label.width + label.height + EPS
+    ) {
+      return null
+    }
+
+    const placementBaseCenter = getCenterFromAnchor(
+      label.anchorPoint,
+      label.orientation,
+      label.width,
+      label.height,
+    )
+    const renderedBaseCenter = getCenterFromAnchor(
+      label.anchorPoint,
+      label.orientation,
+      renderedWidth,
+      label.height,
+    )
+    return getRectBounds(
+      {
+        x: renderedBaseCenter.x + label.center.x - placementBaseCenter.x,
+        y: renderedBaseCenter.y + label.center.y - placementBaseCenter.y,
+      },
+      renderedWidth,
+      label.height,
+    )
+  }
+
+  private includeHorizontalConstraintMismatches(
+    labelIndices: number[],
+    include: boolean,
+  ) {
+    if (!include) return [...labelIndices].sort((a, b) => a - b)
+
+    const result = new Set(labelIndices)
+    for (let index = 0; index < this.outputNetLabelPlacements.length; index++) {
+      if (
+        this.getHorizontalConstraintMismatchBounds(
+          this.outputNetLabelPlacements[index]!,
+        )
+      ) {
+        result.add(index)
+      }
+    }
+    return [...result].sort((a, b) => a - b)
+  }
+
+  private getLabelBoundsForCollisionWithGround(
+    label: NetLabelPlacement,
+    currentLabel: NetLabelPlacement,
+  ) {
+    if (this.isGroundLabel(currentLabel)) {
+      const adjustedBounds = this.getHorizontalConstraintMismatchBounds(label)
+      if (adjustedBounds) return adjustedBounds
+    }
+    return getRectBounds(label.center, label.width, label.height)
+  }
+
   private shouldIgnorePendingCrowdedLabel(
     labelIndex: number,
     otherLabelIndex: number,
@@ -2031,22 +2142,30 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     )
   }
 
-  private intersectsAnyOtherNetLabel(bounds: Bounds, labelIndex: number) {
+  private intersectsAnyOtherNetLabel(
+    bounds: Bounds,
+    labelIndex: number,
+    currentLabel: NetLabelPlacement,
+  ) {
     const searchBounds = {
       minX: bounds.minX - LABEL_SEARCH_STEP,
       minY: bounds.minY - LABEL_SEARCH_STEP,
       maxX: bounds.maxX + LABEL_SEARCH_STEP,
       maxY: bounds.maxY + LABEL_SEARCH_STEP,
     }
-    const nearbyLabelIndices = this.obstacleIndex
-      .getLabelIndicesInBounds(searchBounds)
-      .sort((a, b) => a - b)
+    const nearbyLabelIndices = this.includeHorizontalConstraintMismatches(
+      this.obstacleIndex.getLabelIndicesInBounds(searchBounds),
+      this.isGroundLabel(currentLabel),
+    )
 
     for (const i of nearbyLabelIndices) {
       if (i === labelIndex) continue
       if (this.shouldIgnorePendingCrowdedLabel(labelIndex, i)) continue
       const label = this.outputNetLabelPlacements[i]!
-      const otherBounds = getRectBounds(label.center, label.width, label.height)
+      const otherBounds = this.getLabelBoundsForCollisionWithGround(
+        label,
+        currentLabel,
+      )
       if (
         i === this.blockedStandaloneLabelIndex &&
         isYOrientation(label.orientation)

package/lib/solvers/UnroutedTraceRecoverySolver/UnroutedTraceRecoverySolver.ts

@@ -1,5 +1,6 @@
 import type { Point } from "@tscircuit/math-utils"
 import { distance, doSegmentsIntersect } from "@tscircuit/math-utils"
+import { calculateElbow } from "calculate-elbow"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import { getConnectivityMapsFromInputProblem } from "lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem"
 import {
@@ -86,7 +87,7 @@ const getOuterBounds = (obstacles: ObstacleRect[]) => {
   }
 }
 
-const getPerimeterCandidates = ({
+const getPinConnectionCandidates = ({
   connectionPair,
   obstacles,
 }: {
@@ -111,7 +112,14 @@ const getPerimeterCandidates = ({
     outerBounds.minX - ROUTE_CLEARANCE,
     outerBounds.maxX + ROUTE_CLEARANCE,
   ]
-  const candidates: Point[][] = []
+  // Recovery uses actual text bounds, so try local elbows before the perimeter.
+  const candidates: Point[][] = [
+    calculateElbow(
+      { ...firstPin, facingDirection: firstPin._facingDirection! },
+      { ...secondPin, facingDirection: secondPin._facingDirection! },
+      { overshoot: ROUTE_CLEARANCE },
+    ),
+  ]
 
   for (const channelY of horizontalChannels) {
     candidates.push(
@@ -526,11 +534,11 @@ export class UnroutedTraceRecoverySolver extends BaseSolver {
       obstacles,
       maxConnectionDistance: this.maxConnectionDistance,
     })
-    const perimeterCandidates = getPerimeterCandidates({
+    const pinConnectionCandidates = getPinConnectionCandidates({
       connectionPair,
       obstacles,
     })
-    const candidates = [...junctionCandidates, ...perimeterCandidates]
+    const candidates = [...junctionCandidates, ...pinConnectionCandidates]
     const rejectComponentBoundaryTravel = hasParallelFailedConnection({
       connectionPair,
       failedConnectionPairs: this.failedConnectionPairs,

package/package.json

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

package/site/bug-reports/bug-report-20260905T041712Z.page.tsx

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