@tscircuit/schematic-trace-solver 0.0.196 → 0.0.198

package/dist/index.d.ts

@@ -963,6 +963,7 @@ interface RailNetLabelCornerPlacementSolverParams {
     inputProblem: InputProblem;
     traces: SolvedTracePath[];
     netLabelPlacements: NetLabelPlacement[];
+    netLabelConnectorTraceIds?: ReadonlySet<string>;
 }
 type TraceCornerCandidate = {
     anchorPoint: Point;
@@ -996,6 +997,7 @@ declare class RailNetLabelCornerPlacementSolver extends BaseSolver {
     private queuedCornerCandidates;
     private shouldAdvanceToNextLabel;
     private traceMap;
+    private netLabelConnectorTraceIds;
     constructor(params: RailNetLabelCornerPlacementSolverParams);
     getConstructorParams(): ConstructorParameters<typeof RailNetLabelCornerPlacementSolver>[0];
     _step(): void;
@@ -1015,6 +1017,8 @@ declare class RailNetLabelCornerPlacementSolver extends BaseSolver {
     private intersectsAnyChip;
     private intersectsAnyOtherNetLabel;
     private getCornerCandidatesForLabel;
+    private getStraightConnectorCandidates;
+    private isComponentAdjacentCorner;
     private isConfiguredRailLabel;
     private isLabelCrossedByOtherNetTrace;
     private pointsEqual;
@@ -1451,6 +1455,7 @@ declare class NetLabelToTraceSolver extends BaseSolver {
     private isPortOnlyFallbackLabel;
     private isDirectConnectionLabel;
     private getMultiPinNetConnection;
+    private getTwoPinNetConnection;
     private buildCandidatePairs;
     private buildRoutedComponentCandidates;
     private isSupersededConnectorTrace;

package/dist/index.js

@@ -11181,6 +11181,7 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
   queuedCornerCandidates = [];
   shouldAdvanceToNextLabel = false;
   traceMap;
+  netLabelConnectorTraceIds;
   constructor(params) {
     super();
     this.inputProblem = params.inputProblem;
@@ -11190,6 +11191,7 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
     this.traceMap = Object.fromEntries(
       params.traces.map((trace) => [trace.mspPairId, trace])
     );
+    this.netLabelConnectorTraceIds = params.netLabelConnectorTraceIds ?? /* @__PURE__ */ new Set();
     this.queuedLabelIndices = this.getProcessableLabelIndices();
     this.prepareNextLabel();
   }
@@ -11197,7 +11199,8 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
     return {
       inputProblem: this.inputProblem,
       traces: this.traces,
-      netLabelPlacements: this.netLabelPlacements
+      netLabelPlacements: this.netLabelPlacements,
+      netLabelConnectorTraceIds: this.netLabelConnectorTraceIds
     };
   }
   _step() {
@@ -11248,7 +11251,10 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
     this.currentLabelIndex = labelIndex;
     this.currentLabel = label;
     this.currentCandidateResults = [];
-    this.queuedCornerCandidates = this.getCornerCandidatesForLabel(label);
+    this.queuedCornerCandidates = [
+      ...this.getStraightConnectorCandidates(label),
+      ...this.getCornerCandidatesForLabel(label)
+    ];
     return true;
   }
   advanceToNextLabel() {
@@ -11330,7 +11336,7 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
   }
   shouldProcessLabel(label) {
     const isVerticalRailLabel = label.orientation === "y+" || label.orientation === "y-";
-    return isVerticalRailLabel && this.getCornerCandidatesForLabel(label).length > 0;
+    return isVerticalRailLabel && (this.getStraightConnectorCandidates(label).length > 0 || this.getCornerCandidatesForLabel(label).length > 0);
   }
   intersectsAnyChip(bounds) {
     return this.inputProblem.chips.some(
@@ -11387,6 +11393,77 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
       ...railAlignedCandidates.sort((a, b) => a.distance - b.distance)
     ];
   }
+  getStraightConnectorCandidates(label) {
+    if (label.pinIds.length !== 2 || !this.isConfiguredRailLabel(label)) {
+      return [];
+    }
+    const pins = this.inputProblem.chips.flatMap((chip) => chip.pins).filter((pin) => label.pinIds.includes(pin.pinId));
+    if (pins.length !== 2 || pins[0]._facingDirection !== pins[1]._facingDirection || pins[0]._facingDirection !== "x+" && pins[0]._facingDirection !== "x-" || Math.abs(pins[0].y - pins[1].y) > EPS8) {
+      return [];
+    }
+    const configuredOrientations = this.inputProblem.availableNetLabelOrientations[label.netId];
+    if (configuredOrientations?.length !== 1 || configuredOrientations[0] !== label.orientation) {
+      return [];
+    }
+    const netConnection = this.inputProblem.netConnections.find(
+      (connection) => connection.netId === label.netId
+    );
+    if (netConnection?.isGround) return [];
+    const connector = this.traces.find(
+      (trace) => this.netLabelConnectorTraceIds.has(trace.mspPairId) && trace.globalConnNetId === label.globalConnNetId && label.pinIds.every((pinId) => trace.pinIds.includes(pinId)) && trace.tracePath.length >= 2 && (this.pointsEqual(trace.tracePath[0], label.anchorPoint) || this.pointsEqual(trace.tracePath.at(-1), label.anchorPoint))
+    );
+    if (!connector) return [];
+    const sourcePoint = this.pointsEqual(
+      connector.tracePath[0],
+      label.anchorPoint
+    ) ? connector.tracePath.at(-1) : connector.tracePath[0];
+    if (!this.isComponentAdjacentCorner(label, sourcePoint)) return [];
+    const direction = label.orientation === "y+" ? 1 : -1;
+    const maxSearchDistance = Math.min(
+      getMaxSearchDistance(this.inputProblem),
+      label.height * 2
+    );
+    for (let distance7 = WICK_CLEARANCE + LABEL_SEARCH_STEP; distance7 <= maxSearchDistance + EPS8; distance7 += LABEL_SEARCH_STEP) {
+      const anchorPoint = {
+        x: sourcePoint.x,
+        y: sourcePoint.y + direction * distance7
+      };
+      const center = getCenterFromAnchor(
+        anchorPoint,
+        label.orientation,
+        label.width,
+        label.height
+      );
+      if (this.intersectsAnyChip(getRectBounds(center, label.width, label.height))) {
+        continue;
+      }
+      return [
+        {
+          anchorPoint,
+          traceId: connector.mspPairId,
+          distance: getDistance(anchorPoint, label.anchorPoint),
+          pinAligned: true,
+          reroutedTracePath: [sourcePoint, anchorPoint]
+        }
+      ];
+    }
+    return [];
+  }
+  isComponentAdjacentCorner(label, corner) {
+    return label.mspConnectionPairIds.some((traceId) => {
+      const trace = this.traceMap[traceId];
+      if (!trace || trace.tracePath.length < 2) return false;
+      return [
+        { point: trace.tracePath[0], neighbor: trace.tracePath[1] },
+        {
+          point: trace.tracePath.at(-1),
+          neighbor: trace.tracePath.at(-2)
+        }
+      ].some(
+        ({ point, neighbor }) => this.pointsEqual(neighbor, corner) && trace.pins.some((pin) => this.pointsEqual(pin, point))
+      );
+    });
+  }
   isConfiguredRailLabel(label) {
     if (!label.netId) return false;
     return this.inputProblem.availableNetLabelOrientations[label.netId]?.some(
@@ -17900,6 +17977,23 @@ var getTraceRecoveryConnectivityMaps = (inputProblem) => {
   return { chipMap, pinMap };
 };
 
+// lib/solvers/NetLabelToTraceSolver/getSimpleElbowPath.ts
+var getSimpleElbowPath = (first, second) => {
+  const firstDirection = dir(first._facingDirection);
+  const secondDirection = dir(second._facingDirection);
+  if (firstDirection.x * secondDirection.x || firstDirection.y * secondDirection.y)
+    return void 0;
+  const elbow = firstDirection.x ? { x: second.x, y: first.y } : { x: first.x, y: second.y };
+  for (const [pin, direction] of [
+    [first, firstDirection],
+    [second, secondDirection]
+  ]) {
+    if ((elbow.x - pin.x) * direction.x + (elbow.y - pin.y) * direction.y <= 1e-6)
+      return void 0;
+  }
+  return [{ x: first.x, y: first.y }, elbow, { x: second.x, y: second.y }];
+};
+
 // lib/solvers/NetLabelToTraceSolver/reduceTraceCrossings.ts
 var EPS18 = 1e-9;
 var isHorizontal4 = (start, end) => Math.abs(start.y - end.y) < EPS18;
@@ -18074,6 +18168,11 @@ var NetLabelToTraceSolver = class extends BaseSolver {
       (connection) => connection.isGround === false && connection.pinIds.length > 2 && connection.netId === label.netId && connection.pinIds.includes(pinId)
     );
   }
+  getTwoPinNetConnection(label) {
+    return this.inputProblem.netConnections.find(
+      (connection) => !connection.isGround && connection.pinIds.length === 2 && connection.netId === label.netId && connection.pinIds.includes(label.pinIds[0])
+    );
+  }
   buildCandidatePairs() {
     const { netConnMap } = getConnectivityMapsFromInputProblem(
       this.inputProblem
@@ -18086,7 +18185,7 @@ var NetLabelToTraceSolver = class extends BaseSolver {
     }
     const labelsByGlobalNet = /* @__PURE__ */ new Map();
     for (const label of this.input.netLabelPlacements) {
-      if (!this.isPortOnlyFallbackLabel(label, groundGlobalConnNetIds) || !this.isDirectConnectionLabel(label) && !this.getMultiPinNetConnection(label)) {
+      if (!this.isPortOnlyFallbackLabel(label, groundGlobalConnNetIds) || !this.isDirectConnectionLabel(label) && !this.getMultiPinNetConnection(label) && !this.getTwoPinNetConnection(label)) {
         continue;
       }
       const labels = labelsByGlobalNet.get(label.globalConnNetId) ?? [];
@@ -18110,7 +18209,9 @@ var NetLabelToTraceSolver = class extends BaseSolver {
           const bothLabelsBelongToDirectConnections = this.isDirectConnectionLabel(firstLabel) && this.isDirectConnectionLabel(secondLabel);
           const firstMultiPinNetConnection = this.getMultiPinNetConnection(firstLabel);
           const secondMultiPinNetConnection = this.getMultiPinNetConnection(secondLabel);
-          if (!bothLabelsBelongToDirectConnections && (!firstMultiPinNetConnection || firstMultiPinNetConnection !== secondMultiPinNetConnection || perpendicularOffset > MAX_NAMED_NET_RECOVERY_PERPENDICULAR_OFFSET)) {
+          const twoPinNetConnection = this.getTwoPinNetConnection(firstLabel);
+          const simpleElbowPath = !bothLabelsBelongToDirectConnections && twoPinNetConnection && firstPin.chipId !== secondPin.chipId && twoPinNetConnection === this.getTwoPinNetConnection(secondLabel) ? getSimpleElbowPath(firstPin, secondPin) : void 0;
+          if (!simpleElbowPath && !bothLabelsBelongToDirectConnections && (!firstMultiPinNetConnection || firstMultiPinNetConnection !== secondMultiPinNetConnection || perpendicularOffset > MAX_NAMED_NET_RECOVERY_PERPENDICULAR_OFFSET)) {
             continue;
           }
           if (arePinsInDifferentSchematicSections(
@@ -18136,7 +18237,8 @@ var NetLabelToTraceSolver = class extends BaseSolver {
             perpendicularOffset,
             routeDistance: Math.abs(firstPin.x - secondPin.x) + Math.abs(firstPin.y - secondPin.y),
             key: getCanonicalPairKey(firstPin.pinId, secondPin.pinId),
-            recoveryMode: "fallback_labels"
+            recoveryMode: "fallback_labels",
+            simpleElbowPath
           });
         }
       }
@@ -18298,6 +18400,16 @@ var NetLabelToTraceSolver = class extends BaseSolver {
         (trace) => trace.globalConnNetId !== candidate.firstLabel.globalConnNetId
       );
     }
+    if (candidate.simpleElbowPath) {
+      tracePath = candidate.simpleElbowPath;
+      if (findFirstCollision(tracePath, this.activeSubSolver.obstacles) || collisionTraces.reduce(
+        (count, trace) => count + findPerpendicularPathCrossings(tracePath, trace.tracePath, {
+          includeTerminalSegments: true
+        }).length,
+        0
+      ) > 1)
+        return;
+    }
     if (doesTraceRecoveryPathConflict(tracePath, collisionTraces) || this.routeIntersectsRemainingLabels(tracePath, candidate)) {
       return;
     }
@@ -18675,7 +18787,8 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
             traces: Object.values(
               instance.postLabelTraceOverlapShiftSolver.correctedTraceMap
             ),
-            netLabelPlacements: instance.availableNetOrientationSolver.outputNetLabelPlacements
+            netLabelPlacements: instance.availableNetOrientationSolver.outputNetLabelPlacements,
+            netLabelConnectorTraceIds: instance.availableNetOrientationSolver.netLabelConnectorTraceIds
           }
         ];
       }

package/lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts

@@ -27,6 +27,8 @@ import {
   type InlineNetLabelPlacement,
   visualizeInlineNetLabelOutput,
 } from "../InlineNetLabelSolver/InlineNetLabelSolver"
+import { getSimpleElbowPath } from "./getSimpleElbowPath"
+import { findPerpendicularPathCrossings } from "../TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles"
 import { reduceTraceCrossings } from "./reduceTraceCrossings"
 
 type GlobalConnNetId = NetLabelPlacement["globalConnNetId"]
@@ -43,6 +45,7 @@ interface CandidatePair {
     | "routed_components"
     | "routed_direct_connection"
   netConnectionPinIds?: PinId[]
+  simpleElbowPath?: Point[]
 }
 
 const RECOVERED_TRACE_PREFIX = "net-label-to-trace-"
@@ -153,6 +156,16 @@ export class NetLabelToTraceSolver extends BaseSolver {
     )
   }
 
+  private getTwoPinNetConnection(label: NetLabelPlacement) {
+    return this.inputProblem.netConnections.find(
+      (connection) =>
+        !connection.isGround &&
+        connection.pinIds.length === 2 &&
+        connection.netId === label.netId &&
+        connection.pinIds.includes(label.pinIds[0]!),
+    )
+  }
+
   private buildCandidatePairs() {
     const { netConnMap } = getConnectivityMapsFromInputProblem(
       this.inputProblem,
@@ -169,7 +182,8 @@ export class NetLabelToTraceSolver extends BaseSolver {
       if (
         !this.isPortOnlyFallbackLabel(label, groundGlobalConnNetIds) ||
         (!this.isDirectConnectionLabel(label) &&
-          !this.getMultiPinNetConnection(label))
+          !this.getMultiPinNetConnection(label) &&
+          !this.getTwoPinNetConnection(label))
       ) {
         continue
       }
@@ -203,7 +217,16 @@ export class NetLabelToTraceSolver extends BaseSolver {
             this.getMultiPinNetConnection(firstLabel)
           const secondMultiPinNetConnection =
             this.getMultiPinNetConnection(secondLabel)
+          const twoPinNetConnection = this.getTwoPinNetConnection(firstLabel)
+          const simpleElbowPath =
+            !bothLabelsBelongToDirectConnections &&
+            twoPinNetConnection &&
+            firstPin.chipId !== secondPin.chipId &&
+            twoPinNetConnection === this.getTwoPinNetConnection(secondLabel)
+              ? getSimpleElbowPath(firstPin, secondPin)
+              : undefined
           if (
+            !simpleElbowPath &&
             !bothLabelsBelongToDirectConnections &&
             (!firstMultiPinNetConnection ||
               firstMultiPinNetConnection !== secondMultiPinNetConnection ||
@@ -242,6 +265,7 @@ export class NetLabelToTraceSolver extends BaseSolver {
               Math.abs(firstPin.y - secondPin.y),
             key: getCanonicalPairKey(firstPin.pinId, secondPin.pinId),
             recoveryMode: "fallback_labels",
+            simpleElbowPath,
           })
         }
       }
@@ -474,6 +498,23 @@ export class NetLabelToTraceSolver extends BaseSolver {
           trace.globalConnNetId !== candidate.firstLabel.globalConnNetId,
       )
     }
+    // Only recover a named two-pin elbow when the shortest, direction-respecting
+    // path is clear. Do not replace labels with obstacle detours or many hops.
+    if (candidate.simpleElbowPath) {
+      tracePath = candidate.simpleElbowPath
+      if (
+        findFirstCollision(tracePath, this.activeSubSolver!.obstacles) ||
+        collisionTraces.reduce(
+          (count, trace) =>
+            count +
+            findPerpendicularPathCrossings(tracePath!, trace.tracePath, {
+              includeTerminalSegments: true,
+            }).length,
+          0,
+        ) > 1
+      )
+        return
+    }
     if (
       doesTraceRecoveryPathConflict(tracePath, collisionTraces) ||
       this.routeIntersectsRemainingLabels(tracePath, candidate)

package/lib/solvers/NetLabelToTraceSolver/getSimpleElbowPath.ts

@@ -0,0 +1,31 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { TraceRecoveryPin } from "lib/solvers/NetLabelTraceRecovery/getTraceRecoveryConnectivityMaps"
+import { dir } from "lib/utils/dir"
+
+/** The single elbow reached by extending both pins outwards, if it exists. */
+export const getSimpleElbowPath = (
+  first: TraceRecoveryPin,
+  second: TraceRecoveryPin,
+): Point[] | undefined => {
+  const firstDirection = dir(first._facingDirection)
+  const secondDirection = dir(second._facingDirection)
+  if (
+    firstDirection.x * secondDirection.x ||
+    firstDirection.y * secondDirection.y
+  )
+    return undefined
+  const elbow = firstDirection.x
+    ? { x: second.x, y: first.y }
+    : { x: first.x, y: second.y }
+  for (const [pin, direction] of [
+    [first, firstDirection],
+    [second, secondDirection],
+  ] as const) {
+    if (
+      (elbow.x - pin.x) * direction.x + (elbow.y - pin.y) * direction.y <=
+      1e-6
+    )
+      return undefined
+  }
+  return [{ x: first.x, y: first.y }, elbow, { x: second.x, y: second.y }]
+}

package/lib/solvers/RailNetLabelCornerPlacementSolver/RailNetLabelCornerPlacementSolver.ts

@@ -1,9 +1,14 @@
 import type { GraphicsObject } from "graphics-debug"
 import type { Point } from "@tscircuit/math-utils"
 import {
+  getMaxSearchDistance,
   segmentCrossesBoundsInterior,
   traceCrossesBoundsInterior,
 } from "lib/solvers/AvailableNetOrientationSolver/geometry"
+import {
+  LABEL_SEARCH_STEP,
+  WICK_CLEARANCE,
+} from "lib/solvers/AvailableNetOrientationSolver/constants"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import { moveAttachedLabelsToReroutedTrace } from "lib/solvers/Example28Solver/labelMovement"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
@@ -51,6 +56,7 @@ export class RailNetLabelCornerPlacementSolver extends BaseSolver {
   private queuedCornerCandidates: TraceCornerCandidate[] = []
   private shouldAdvanceToNextLabel = false
   private traceMap: Record<string, SolvedTracePath>
+  private netLabelConnectorTraceIds: ReadonlySet<string>
 
   constructor(params: RailNetLabelCornerPlacementSolverParams) {
     super()
@@ -61,6 +67,8 @@ export class RailNetLabelCornerPlacementSolver extends BaseSolver {
     this.traceMap = Object.fromEntries(
       params.traces.map((trace) => [trace.mspPairId, trace]),
     )
+    this.netLabelConnectorTraceIds =
+      params.netLabelConnectorTraceIds ?? new Set()
     this.queuedLabelIndices = this.getProcessableLabelIndices()
     this.prepareNextLabel()
   }
@@ -72,6 +80,7 @@ export class RailNetLabelCornerPlacementSolver extends BaseSolver {
       inputProblem: this.inputProblem,
       traces: this.traces,
       netLabelPlacements: this.netLabelPlacements,
+      netLabelConnectorTraceIds: this.netLabelConnectorTraceIds,
     }
   }
 
@@ -135,7 +144,10 @@ export class RailNetLabelCornerPlacementSolver extends BaseSolver {
     this.currentLabelIndex = labelIndex
     this.currentLabel = label
     this.currentCandidateResults = []
-    this.queuedCornerCandidates = this.getCornerCandidatesForLabel(label)
+    this.queuedCornerCandidates = [
+      ...this.getStraightConnectorCandidates(label),
+      ...this.getCornerCandidatesForLabel(label),
+    ]
 
     return true
   }
@@ -250,7 +262,9 @@ export class RailNetLabelCornerPlacementSolver extends BaseSolver {
     const isVerticalRailLabel =
       label.orientation === "y+" || label.orientation === "y-"
     return (
-      isVerticalRailLabel && this.getCornerCandidatesForLabel(label).length > 0
+      isVerticalRailLabel &&
+      (this.getStraightConnectorCandidates(label).length > 0 ||
+        this.getCornerCandidatesForLabel(label).length > 0)
     )
   }
 
@@ -323,6 +337,118 @@ export class RailNetLabelCornerPlacementSolver extends BaseSolver {
     ]
   }
 
+  private getStraightConnectorCandidates(
+    label: NetLabelPlacement,
+  ): TraceCornerCandidate[] {
+    if (label.pinIds.length !== 2 || !this.isConfiguredRailLabel(label)) {
+      return []
+    }
+
+    const pins = this.inputProblem.chips
+      .flatMap((chip) => chip.pins)
+      .filter((pin) => label.pinIds.includes(pin.pinId))
+    if (
+      pins.length !== 2 ||
+      pins[0]!._facingDirection !== pins[1]!._facingDirection ||
+      (pins[0]!._facingDirection !== "x+" &&
+        pins[0]!._facingDirection !== "x-") ||
+      Math.abs(pins[0]!.y - pins[1]!.y) > EPS
+    ) {
+      return []
+    }
+
+    const configuredOrientations =
+      this.inputProblem.availableNetLabelOrientations[label.netId!]
+    if (
+      configuredOrientations?.length !== 1 ||
+      configuredOrientations[0] !== label.orientation
+    ) {
+      return []
+    }
+
+    const netConnection = this.inputProblem.netConnections.find(
+      (connection) => connection.netId === label.netId,
+    )
+    if (netConnection?.isGround) return []
+
+    const connector = this.traces.find(
+      (trace) =>
+        this.netLabelConnectorTraceIds.has(trace.mspPairId) &&
+        trace.globalConnNetId === label.globalConnNetId &&
+        label.pinIds.every((pinId) => trace.pinIds.includes(pinId)) &&
+        trace.tracePath.length >= 2 &&
+        (this.pointsEqual(trace.tracePath[0]!, label.anchorPoint) ||
+          this.pointsEqual(trace.tracePath.at(-1)!, label.anchorPoint)),
+    )
+    if (!connector) return []
+
+    const sourcePoint = this.pointsEqual(
+      connector.tracePath[0]!,
+      label.anchorPoint,
+    )
+      ? connector.tracePath.at(-1)!
+      : connector.tracePath[0]!
+    if (!this.isComponentAdjacentCorner(label, sourcePoint)) return []
+
+    const direction = label.orientation === "y+" ? 1 : -1
+    const maxSearchDistance = Math.min(
+      getMaxSearchDistance(this.inputProblem),
+      label.height * 2,
+    )
+    for (
+      let distance = WICK_CLEARANCE + LABEL_SEARCH_STEP;
+      distance <= maxSearchDistance + EPS;
+      distance += LABEL_SEARCH_STEP
+    ) {
+      const anchorPoint = {
+        x: sourcePoint.x,
+        y: sourcePoint.y + direction * distance,
+      }
+      const center = getCenterFromAnchor(
+        anchorPoint,
+        label.orientation,
+        label.width,
+        label.height,
+      )
+      if (
+        this.intersectsAnyChip(getRectBounds(center, label.width, label.height))
+      ) {
+        continue
+      }
+
+      return [
+        {
+          anchorPoint,
+          traceId: connector.mspPairId,
+          distance: getDistance(anchorPoint, label.anchorPoint),
+          pinAligned: true,
+          reroutedTracePath: [sourcePoint, anchorPoint],
+        },
+      ]
+    }
+
+    return []
+  }
+
+  private isComponentAdjacentCorner(label: NetLabelPlacement, corner: Point) {
+    return label.mspConnectionPairIds.some((traceId) => {
+      const trace = this.traceMap[traceId]
+      if (!trace || trace.tracePath.length < 2) return false
+
+      return [
+        { point: trace.tracePath[0]!, neighbor: trace.tracePath[1]! },
+        {
+          point: trace.tracePath.at(-1)!,
+          neighbor: trace.tracePath.at(-2)!,
+        },
+      ].some(
+        ({ point, neighbor }) =>
+          this.pointsEqual(neighbor, corner) &&
+          trace.pins.some((pin) => this.pointsEqual(pin, point)),
+      )
+    })
+  }
+
   private isConfiguredRailLabel(label: NetLabelPlacement) {
     if (!label.netId) return false
     return this.inputProblem.availableNetLabelOrientations[label.netId]?.some(

package/lib/solvers/RailNetLabelCornerPlacementSolver/types.ts

@@ -7,6 +7,7 @@ export interface RailNetLabelCornerPlacementSolverParams {
   inputProblem: InputProblem
   traces: SolvedTracePath[]
   netLabelPlacements: NetLabelPlacement[]
+  netLabelConnectorTraceIds?: ReadonlySet<string>
 }
 
 export type Bounds = {

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -402,6 +402,8 @@ export class SchematicTracePipelineSolver extends BaseSolver {
             ),
             netLabelPlacements:
               instance.availableNetOrientationSolver!.outputNetLabelPlacements,
+            netLabelConnectorTraceIds:
+              instance.availableNetOrientationSolver!.netLabelConnectorTraceIds,
           },
         ]
       },

package/package.json

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

package/site/SchematicTracePipelineSolver/repro-am3352-sheet3-power-rails.page.tsx

@@ -0,0 +1,7 @@
+import type { InputProblem } from "lib/types/InputProblem"
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import input from "../../tests/repros/assets/repro-am3352-sheet3-power-rails.input.json"
+
+export default () => (
+  <PipelineDebugger inputProblem={structuredClone(input) as InputProblem} />
+)

package/site/bug-reports/bug-report-20260911T195723Z.page.tsx

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

package/site/bug-reports/enc-scl-hop.page.tsx

@@ -0,0 +1,6 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/assets/enc-scl-hop.json"
+
+export default () => (
+  <PipelineDebugger inputProblem={inputProblem as any} hideRatsNet />
+)