@tscircuit/schematic-trace-solver 0.0.197 → 0.0.199

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;

package/dist/index.js

@@ -10274,7 +10274,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         result.selected = true;
         return result;
       }
-      if (stopOnTraceCollision && result.status === "trace-collision") break;
+      if (stopOnTraceCollision && result.status === "trace-collision" && (!projectedConnectorSource || orientation !== "y-" || !this.isGroundLabel(label)))
+        break;
     }
     return null;
   }
@@ -11181,6 +11182,7 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
   queuedCornerCandidates = [];
   shouldAdvanceToNextLabel = false;
   traceMap;
+  netLabelConnectorTraceIds;
   constructor(params) {
     super();
     this.inputProblem = params.inputProblem;
@@ -11190,6 +11192,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 +11200,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 +11252,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 +11337,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 +11394,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(
@@ -18710,7 +18788,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/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -1172,7 +1172,16 @@ export class AvailableNetOrientationSolver extends BaseSolver {
         result.selected = true
         return result
       }
-      if (stopOnTraceCollision && result.status === "trace-collision") break
+      // A downward ground branch projected onto its existing trace can reach a
+      // clear position below a crossing trace.
+      if (
+        stopOnTraceCollision &&
+        result.status === "trace-collision" &&
+        (!projectedConnectorSource ||
+          orientation !== "y-" ||
+          !this.isGroundLabel(label))
+      )
+        break
     }
 
     return null

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.197",
+  "version": "0.0.199",
   "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/bug-report-20260916T054012Z.page.tsx

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