@tscircuit/schematic-trace-solver 0.0.142 → 0.0.143

package/dist/index.d.ts

@@ -825,6 +825,7 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private findValidTraceAnchorCandidate;
     private findValidOutwardTraceAnchorCandidate;
     private getTraceAnchorCandidatePoints;
+    private sharesVerticalRailWithAny;
     private getAvailableOrientations;
     private findValidShiftedCandidate;
     /**

package/dist/index.js

@@ -8842,13 +8842,14 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   }
   findValidTraceAnchorCandidate(label, orientation, labelIndex) {
     const direction = dir(orientation);
-    const candidatePoints = this.getTraceAnchorCandidatePoints(label).sort(
-      (a, b) => {
-        const aAlongDirection = a.x * direction.x + a.y * direction.y;
-        const bAlongDirection = b.x * direction.x + b.y * direction.y;
-        return bAlongDirection - aAlongDirection;
-      }
-    );
+    const candidatePoints = this.getTraceAnchorCandidatePoints(
+      label,
+      orientation
+    ).sort((a, b) => {
+      const aAlongDirection = a.x * direction.x + a.y * direction.y;
+      const bAlongDirection = b.x * direction.x + b.y * direction.y;
+      return bAlongDirection - aAlongDirection;
+    });
     for (const anchorPoint of candidatePoints) {
       const candidate = this.createCandidate(label, anchorPoint, orientation);
       const result = this.evaluateCandidate(
@@ -8867,13 +8868,14 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   }
   findValidOutwardTraceAnchorCandidate(label, orientation, labelIndex) {
     const direction = dir(orientation);
-    const candidatePoints = this.getTraceAnchorCandidatePoints(label).sort(
-      (a, b) => {
-        const aAlongDirection = a.x * direction.x + a.y * direction.y;
-        const bAlongDirection = b.x * direction.x + b.y * direction.y;
-        return bAlongDirection - aAlongDirection;
-      }
-    );
+    const candidatePoints = this.getTraceAnchorCandidatePoints(
+      label,
+      orientation
+    ).sort((a, b) => {
+      const aAlongDirection = a.x * direction.x + a.y * direction.y;
+      const bAlongDirection = b.x * direction.x + b.y * direction.y;
+      return bAlongDirection - aAlongDirection;
+    });
     for (const connectorSource of candidatePoints) {
       const preservedColumnAnchor = this.getSearchStartAnchor(
         label,
@@ -8931,10 +8933,40 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return null;
   }
-  getTraceAnchorCandidatePoints(label) {
+  getTraceAnchorCandidatePoints(label, orientation) {
     const seen = /* @__PURE__ */ new Set();
     const points = [];
-    for (const traceId of label.mspConnectionPairIds ?? []) {
+    const connectedTraceIds = new Set(label.mspConnectionPairIds ?? []);
+    if (isYOrientation(orientation)) {
+      const connectedPinIds = /* @__PURE__ */ new Set();
+      for (const traceId of connectedTraceIds) {
+        for (const pinId of this.traceMap[traceId]?.pinIds ?? []) {
+          connectedPinIds.add(pinId);
+        }
+      }
+      let foundConnectedTrace = true;
+      while (foundConnectedTrace) {
+        foundConnectedTrace = false;
+        for (const trace of Object.values(this.traceMap)) {
+          if (connectedTraceIds.has(trace.mspPairId)) continue;
+          if (trace.mspPairId.startsWith("available-net-orientation-")) continue;
+          if (trace.globalConnNetId !== label.globalConnNetId) continue;
+          if (!trace.pinIds.some((pinId) => connectedPinIds.has(pinId)))
+            continue;
+          const connectedTraces = [...connectedTraceIds].flatMap((traceId) => {
+            const connectedTrace = this.traceMap[traceId];
+            return connectedTrace ? [connectedTrace] : [];
+          });
+          if (!this.sharesVerticalRailWithAny(trace, connectedTraces)) {
+            continue;
+          }
+          connectedTraceIds.add(trace.mspPairId);
+          for (const pinId of trace.pinIds) connectedPinIds.add(pinId);
+          foundConnectedTrace = true;
+        }
+      }
+    }
+    for (const traceId of connectedTraceIds) {
       const trace = this.traceMap[traceId];
       if (!trace) continue;
       for (const point of trace.tracePath) {
@@ -8946,6 +8978,26 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return points;
   }
+  sharesVerticalRailWithAny(trace, otherTraces) {
+    const verticalRailXs = /* @__PURE__ */ new Set();
+    for (const otherTrace of otherTraces) {
+      for (let i = 0; i < otherTrace.tracePath.length - 1; i++) {
+        const start = otherTrace.tracePath[i];
+        const end = otherTrace.tracePath[i + 1];
+        if (Math.abs(start.x - end.x) <= EPS12 && Math.abs(start.y - end.y) > EPS12) {
+          verticalRailXs.add(start.x);
+        }
+      }
+    }
+    for (let i = 0; i < trace.tracePath.length - 1; i++) {
+      const start = trace.tracePath[i];
+      const end = trace.tracePath[i + 1];
+      if (Math.abs(start.x - end.x) <= EPS12 && Math.abs(start.y - end.y) > EPS12 && [...verticalRailXs].some((x) => Math.abs(x - start.x) <= EPS12)) {
+        return true;
+      }
+    }
+    return false;
+  }
   getAvailableOrientations(label) {
     const effectiveNetId = label.netId ?? label.globalConnNetId;
     return this.inputProblem.availableNetLabelOrientations[effectiveNetId] ?? [];

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -635,13 +635,14 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     labelIndex: number,
   ) {
     const direction = dir(orientation)
-    const candidatePoints = this.getTraceAnchorCandidatePoints(label).sort(
-      (a, b) => {
-        const aAlongDirection = a.x * direction.x + a.y * direction.y
-        const bAlongDirection = b.x * direction.x + b.y * direction.y
-        return bAlongDirection - aAlongDirection
-      },
-    )
+    const candidatePoints = this.getTraceAnchorCandidatePoints(
+      label,
+      orientation,
+    ).sort((a, b) => {
+      const aAlongDirection = a.x * direction.x + a.y * direction.y
+      const bAlongDirection = b.x * direction.x + b.y * direction.y
+      return bAlongDirection - aAlongDirection
+    })
 
     for (const anchorPoint of candidatePoints) {
       const candidate = this.createCandidate(label, anchorPoint, orientation)
@@ -668,13 +669,14 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     labelIndex: number,
   ) {
     const direction = dir(orientation)
-    const candidatePoints = this.getTraceAnchorCandidatePoints(label).sort(
-      (a, b) => {
-        const aAlongDirection = a.x * direction.x + a.y * direction.y
-        const bAlongDirection = b.x * direction.x + b.y * direction.y
-        return bAlongDirection - aAlongDirection
-      },
-    )
+    const candidatePoints = this.getTraceAnchorCandidatePoints(
+      label,
+      orientation,
+    ).sort((a, b) => {
+      const aAlongDirection = a.x * direction.x + a.y * direction.y
+      const bAlongDirection = b.x * direction.x + b.y * direction.y
+      return bAlongDirection - aAlongDirection
+    })
 
     for (const connectorSource of candidatePoints) {
       const preservedColumnAnchor = this.getSearchStartAnchor(
@@ -742,11 +744,52 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return null
   }
 
-  private getTraceAnchorCandidatePoints(label: NetLabelPlacement) {
+  private getTraceAnchorCandidatePoints(
+    label: NetLabelPlacement,
+    orientation: FacingDirection,
+  ) {
     const seen = new Set<string>()
     const points: Point[] = []
+    const connectedTraceIds = new Set(label.mspConnectionPairIds ?? [])
+
+    if (isYOrientation(orientation)) {
+      const connectedPinIds = new Set<string>()
+      for (const traceId of connectedTraceIds) {
+        for (const pinId of this.traceMap[traceId]?.pinIds ?? []) {
+          connectedPinIds.add(pinId)
+        }
+      }
+
+      // Multi-pin rails are routed as a chain of pairwise traces. Follow the
+      // pairs only when they share both a pin and an aligned vertical rail,
+      // which identifies one continuous rail. A shared pin alone can join
+      // unrelated branches whose rail offsets are far apart; walking those
+      // branches would extend the label connector across the schematic.
+      let foundConnectedTrace = true
+      while (foundConnectedTrace) {
+        foundConnectedTrace = false
+        for (const trace of Object.values(this.traceMap)) {
+          if (connectedTraceIds.has(trace.mspPairId)) continue
+          if (trace.mspPairId.startsWith("available-net-orientation-")) continue
+          if (trace.globalConnNetId !== label.globalConnNetId) continue
+          if (!trace.pinIds.some((pinId) => connectedPinIds.has(pinId)))
+            continue
+          const connectedTraces = [...connectedTraceIds].flatMap((traceId) => {
+            const connectedTrace = this.traceMap[traceId]
+            return connectedTrace ? [connectedTrace] : []
+          })
+          if (!this.sharesVerticalRailWithAny(trace, connectedTraces)) {
+            continue
+          }
+
+          connectedTraceIds.add(trace.mspPairId)
+          for (const pinId of trace.pinIds) connectedPinIds.add(pinId)
+          foundConnectedTrace = true
+        }
+      }
+    }
 
-    for (const traceId of label.mspConnectionPairIds ?? []) {
+    for (const traceId of connectedTraceIds) {
       const trace = this.traceMap[traceId]
       if (!trace) continue
       for (const point of trace.tracePath) {
@@ -760,6 +803,39 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return points
   }
 
+  private sharesVerticalRailWithAny(
+    trace: SolvedTracePath,
+    otherTraces: SolvedTracePath[],
+  ) {
+    const verticalRailXs = new Set<number>()
+    for (const otherTrace of otherTraces) {
+      for (let i = 0; i < otherTrace.tracePath.length - 1; i++) {
+        const start = otherTrace.tracePath[i]!
+        const end = otherTrace.tracePath[i + 1]!
+        if (
+          Math.abs(start.x - end.x) <= EPS &&
+          Math.abs(start.y - end.y) > EPS
+        ) {
+          verticalRailXs.add(start.x)
+        }
+      }
+    }
+
+    for (let i = 0; i < trace.tracePath.length - 1; i++) {
+      const start = trace.tracePath[i]!
+      const end = trace.tracePath[i + 1]!
+      if (
+        Math.abs(start.x - end.x) <= EPS &&
+        Math.abs(start.y - end.y) > EPS &&
+        [...verticalRailXs].some((x) => Math.abs(x - start.x) <= EPS)
+      ) {
+        return true
+      }
+    }
+
+    return false
+  }
+
   private getAvailableOrientations(label: NetLabelPlacement) {
     const effectiveNetId = label.netId ?? label.globalConnNetId
     return this.inputProblem.availableNetLabelOrientations[effectiveNetId] ?? []

package/package.json

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