@tscircuit/schematic-trace-solver 0.0.185 → 0.0.187

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;
@@ -13829,17 +13915,16 @@ var pathsIntersect = (firstPath, secondPath) => {
   }
   return false;
 };
-var preserveAttachedLabelConnectorJunctions = ({
+var preserveAttachedTraceJunctions = ({
   originalTrace,
   candidateTrace,
-  traces,
-  netLabelConnectorTraceIds
+  traces
 }) => {
   let outputTraces = traces.map(
     (trace) => trace.mspPairId === originalTrace.mspPairId ? candidateTrace : trace
   );
   for (const connector of traces) {
-    if (connector.mspPairId === originalTrace.mspPairId || !netLabelConnectorTraceIds.has(connector.mspPairId) || connector.globalConnNetId !== originalTrace.globalConnNetId || !pathsIntersect(originalTrace.tracePath, connector.tracePath) || pathsIntersect(candidateTrace.tracePath, connector.tracePath)) {
+    if (connector.mspPairId === originalTrace.mspPairId || connector.globalConnNetId !== originalTrace.globalConnNetId || !pathsIntersect(originalTrace.tracePath, connector.tracePath) || pathsIntersect(candidateTrace.tracePath, connector.tracePath)) {
       continue;
     }
     const endpointIndex = [0, connector.tracePath.length - 1].find(
@@ -13850,6 +13935,11 @@ var preserveAttachedLabelConnectorJunctions = ({
     );
     if (endpointIndex === void 0) return null;
     const originalJunction = connector.tracePath[endpointIndex];
+    if (connector.pins.some(
+      (pin) => nearlyEqual(pin.x, originalJunction.x) && nearlyEqual(pin.y, originalJunction.y)
+    )) {
+      return null;
+    }
     const movedJunction = getMovedAnchorPointForReroute(
       originalJunction,
       originalTrace.tracePath,
@@ -14228,11 +14318,10 @@ var alignSameNetJunctions = ({
             netLabelPlacements: outputNetLabelPlacements,
             attachedLabelIndexes
           });
-          const candidateTraces = preserveAttachedLabelConnectorJunctions({
+          const candidateTraces = preserveAttachedTraceJunctions({
             originalTrace: branchTrace,
             candidateTrace,
-            traces: outputTraces,
-            netLabelConnectorTraceIds
+            traces: outputTraces
           });
           if (!candidateTraces) continue;
           if (!candidateIsClear({
@@ -14247,7 +14336,7 @@ var alignSameNetJunctions = ({
             continue;
           }
           const movedConnectorsAreClear = candidateTraces.every((trace) => {
-            if (trace.mspPairId === branchTrace.mspPairId || !netLabelConnectorTraceIds.has(trace.mspPairId)) {
+            if (trace.mspPairId === branchTrace.mspPairId) {
               return true;
             }
             const originalConnector = outputTraces.find(

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

@@ -648,20 +648,18 @@ const pathsIntersect = (firstPath: Point[], secondPath: Point[]) => {
 }
 
 /**
- * Keep generated label connectors joined when their host trace moves. Only a
+ * Keep same-net branches joined when their host trace moves. Only a
  * connector endpoint is projected, and only along its existing first/last
  * segment, so the label and the rest of its route stay fixed.
  */
-const preserveAttachedLabelConnectorJunctions = ({
+const preserveAttachedTraceJunctions = ({
   originalTrace,
   candidateTrace,
   traces,
-  netLabelConnectorTraceIds,
 }: {
   originalTrace: SolvedTracePath
   candidateTrace: SolvedTracePath
   traces: SolvedTracePath[]
-  netLabelConnectorTraceIds: ReadonlySet<MspConnectionPairId>
 }): SolvedTracePath[] | null => {
   let outputTraces = traces.map((trace) =>
     trace.mspPairId === originalTrace.mspPairId ? candidateTrace : trace,
@@ -670,7 +668,6 @@ const preserveAttachedLabelConnectorJunctions = ({
   for (const connector of traces) {
     if (
       connector.mspPairId === originalTrace.mspPairId ||
-      !netLabelConnectorTraceIds.has(connector.mspPairId) ||
       connector.globalConnNetId !== originalTrace.globalConnNetId ||
       !pathsIntersect(originalTrace.tracePath, connector.tracePath) ||
       pathsIntersect(candidateTrace.tracePath, connector.tracePath)
@@ -686,6 +683,16 @@ const preserveAttachedLabelConnectorJunctions = ({
     )
     if (endpointIndex === undefined) return null
     const originalJunction = connector.tracePath[endpointIndex]!
+    // Component pins are fixed; reject a rail move that would detach one.
+    if (
+      connector.pins.some(
+        (pin) =>
+          nearlyEqual(pin.x, originalJunction.x) &&
+          nearlyEqual(pin.y, originalJunction.y),
+      )
+    ) {
+      return null
+    }
     const movedJunction = getMovedAnchorPointForReroute(
       originalJunction,
       originalTrace.tracePath,
@@ -1250,11 +1257,10 @@ export const alignSameNetJunctions = ({
             netLabelPlacements: outputNetLabelPlacements,
             attachedLabelIndexes,
           })
-          const candidateTraces = preserveAttachedLabelConnectorJunctions({
+          const candidateTraces = preserveAttachedTraceJunctions({
             originalTrace: branchTrace,
             candidateTrace,
             traces: outputTraces,
-            netLabelConnectorTraceIds,
           })
           if (!candidateTraces) continue
           if (
@@ -1272,10 +1278,7 @@ export const alignSameNetJunctions = ({
           }
 
           const movedConnectorsAreClear = candidateTraces.every((trace) => {
-            if (
-              trace.mspPairId === branchTrace.mspPairId ||
-              !netLabelConnectorTraceIds.has(trace.mspPairId)
-            ) {
+            if (trace.mspPairId === branchTrace.mspPairId) {
               return true
             }
             const originalConnector = outputTraces.find(

package/package.json

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

package/site/bug-reports/bug-report-20260907T083336Z.page.tsx

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