@tscircuit/schematic-trace-solver 0.0.129 → 0.0.131

package/dist/index.d.ts

@@ -621,6 +621,7 @@ declare class LongDistancePairSolver extends BaseSolver {
     private netConnMap;
     private newlyConnectedPinIds;
     private allSolvedTraces;
+    private maxMspPairDistance;
     constructor(params: {
         inputProblem: InputProblem;
         alreadySolvedTraces: SolvedTracePath[];
@@ -778,6 +779,7 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     currentLabelIndex: number | null;
     currentLabel: NetLabelPlacement | null;
     currentCandidateResults: EvaluatedCandidate[];
+    private crowdedPortOnlyLabelIndices;
     blockedStandaloneLabelIndex: number | null;
     blockedStandaloneLabelTargetAnchorX: number | null;
     private traceMap;
@@ -792,13 +794,16 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
         netLabelPlacements: NetLabelPlacement[];
     };
     private getProcessableLabelIndices;
+    private sortCrowdedTopBankByPin;
     private shouldProcessLabel;
+    private getCrowdedPortOnlyLabelIndices;
     private processLabel;
     private applyCandidate;
     private addConnectorTrace;
     private finish;
     private setCurrentLabel;
     private findCorrectedCandidate;
+    private findValidCrowdedTopVerticalFanoutCandidate;
     private hasTraceContinuingInOrientation;
     private findValidRotatedCandidate;
     private findValidTraceAnchorCandidate;
@@ -841,10 +846,12 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private hasOppositeVerticalRailOnSameChipSide;
     private getSingleChipSideForNetConnection;
     private isPortOnlyLabel;
+    private shouldIgnorePendingCrowdedLabel;
     private intersectsAnyOtherNetLabel;
     private sharesChipBoundary;
     private getChipSideForPoint;
     private getPerpendicularOutwardDirection;
+    private getChipOutwardDirection;
     private getContainingChipSide;
     private getOutsideChipSide;
     private getNearestChipSide;

package/dist/index.js

@@ -4618,6 +4618,7 @@ var NEAREST_NEIGHBOR_COUNT = 3;
 var distance3 = (p1, p2) => {
   return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
 };
+var manhattanDistance = (p1, p2) => Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y);
 var LongDistancePairSolver = class extends BaseSolver {
   constructor(params) {
     super();
@@ -4625,6 +4626,7 @@ var LongDistancePairSolver = class extends BaseSolver {
     const { inputProblem, primaryMspConnectionPairs, alreadySolvedTraces } = this.params;
     this.inputProblem = inputProblem;
     this.allSolvedTraces = [...alreadySolvedTraces];
+    this.maxMspPairDistance = inputProblem.maxMspPairDistance ?? DEFAULT_MAX_MSP_PAIR_DISTANCE;
     const primaryConnectedPinIds = /* @__PURE__ */ new Set();
     for (const pair of primaryMspConnectionPairs) {
       primaryConnectedPinIds.add(pair.pins[0].pinId);
@@ -4660,6 +4662,12 @@ var LongDistancePairSolver = class extends BaseSolver {
         const neighbors = allPinIdsInNet.filter((otherPinId) => otherPinId !== unconnectedPinId).flatMap((otherPinId) => {
           const targetPin = pinMap.get(otherPinId);
           if (!targetPin) return [];
+          const isNamedTwoPinConnection = inputProblem.netConnections.some(
+            (connection) => connection.pinIds.length === 2 && connection.pinIds.includes(sourcePin.pinId) && connection.pinIds.includes(targetPin.pinId)
+          );
+          if (isNamedTwoPinConnection && manhattanDistance(sourcePin, targetPin) > this.maxMspPairDistance) {
+            return [];
+          }
           return [
             {
               pin: targetPin,
@@ -4694,6 +4702,7 @@ var LongDistancePairSolver = class extends BaseSolver {
   netConnMap;
   newlyConnectedPinIds = /* @__PURE__ */ new Set();
   allSolvedTraces = [];
+  maxMspPairDistance;
   getConstructorParams() {
     return this.params;
   }
@@ -8053,6 +8062,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   currentLabelIndex = null;
   currentLabel = null;
   currentCandidateResults = [];
+  crowdedPortOnlyLabelIndices = /* @__PURE__ */ new Set();
   blockedStandaloneLabelIndex = null;
   blockedStandaloneLabelTargetAnchorX = null;
   traceMap;
@@ -8071,6 +8081,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     this.pinMap = getPinMap(params.inputProblem);
     this.chipObstacleSpatialIndex = params.inputProblem._chipObstacleSpatialIndex ?? new ChipObstacleSpatialIndex(params.inputProblem.chips);
     this.maxSearchDistance = getMaxSearchDistance(params.inputProblem);
+    this.crowdedPortOnlyLabelIndices = this.getCrowdedPortOnlyLabelIndices();
     this.queuedLabelIndices = this.getProcessableLabelIndices();
     this.setCurrentLabel(this.queuedLabelIndices[0] ?? null);
   }
@@ -8098,10 +8109,11 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   getProcessableLabelIndices() {
     const indices = [];
     for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
-      if (this.shouldProcessLabel(this.outputNetLabelPlacements[i])) {
+      if (this.shouldProcessLabel(this.outputNetLabelPlacements[i], i)) {
         indices.push(i);
       }
     }
+    this.sortCrowdedTopBankByPin(indices);
     const blockedStandaloneLabelIndex = indices.find((index) => {
       const label = this.outputNetLabelPlacements[index];
       const orientations = this.getAvailableOrientations(label);
@@ -8150,9 +8162,87 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return indices;
   }
-  shouldProcessLabel(label) {
+  sortCrowdedTopBankByPin(indices) {
+    const slotsByChip = /* @__PURE__ */ new Map();
+    for (let slot = 0; slot < indices.length; slot++) {
+      const labelIndex = indices[slot];
+      if (!this.crowdedPortOnlyLabelIndices.has(labelIndex)) continue;
+      const label = this.outputNetLabelPlacements[labelIndex];
+      if (this.getChipSideForPoint(label.anchorPoint) !== "top") continue;
+      const pin = this.pinMap[label.pinIds[0]];
+      if (!pin) continue;
+      const slots = slotsByChip.get(pin.chipId) ?? [];
+      slots.push(slot);
+      slotsByChip.set(pin.chipId, slots);
+    }
+    for (const slots of slotsByChip.values()) {
+      const labelIndices = slots.map((slot) => indices[slot]).sort((a, b) => {
+        const aPin = this.pinMap[this.outputNetLabelPlacements[a].pinIds[0]];
+        const bPin = this.pinMap[this.outputNetLabelPlacements[b].pinIds[0]];
+        return aPin.x - bPin.x;
+      });
+      for (let position = 0; position < slots.length; position++) {
+        indices[slots[position]] = labelIndices[position];
+      }
+    }
+  }
+  shouldProcessLabel(label, labelIndex) {
     const orientations = this.getAvailableOrientations(label);
-    return orientations.length > 0 && !orientations.includes(label.orientation);
+    if (orientations.length === 0) return false;
+    if (!orientations.includes(label.orientation)) return true;
+    if (!this.crowdedPortOnlyLabelIndices.has(labelIndex)) return false;
+    const bounds = getRectBounds(label.center, label.width, label.height);
+    return this.outputNetLabelPlacements.some((otherLabel, otherIndex) => {
+      if (otherIndex === labelIndex) return false;
+      if (otherLabel.globalConnNetId === label.globalConnNetId) return false;
+      return rectsOverlap2(
+        bounds,
+        getRectBounds(otherLabel.center, otherLabel.width, otherLabel.height)
+      );
+    });
+  }
+  getCrowdedPortOnlyLabelIndices() {
+    const labelIndicesByChipAndSide = /* @__PURE__ */ new Map();
+    for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
+      const label = this.outputNetLabelPlacements[i];
+      if (!this.isPortOnlyLabel(label)) continue;
+      if (!this.isStandaloneSinglePinNetLabel(label)) continue;
+      if (this.getAvailableOrientations(label).length === 0) continue;
+      const pin = this.pinMap[label.pinIds[0]];
+      if (!pin) continue;
+      const chipSide = this.getChipSideForPoint(label.anchorPoint);
+      if (!chipSide) continue;
+      const labelIndicesBySide = labelIndicesByChipAndSide.get(pin.chipId) ?? /* @__PURE__ */ new Map();
+      const labelIndices = labelIndicesBySide.get(chipSide) ?? [];
+      labelIndices.push(i);
+      labelIndicesBySide.set(chipSide, labelIndices);
+      labelIndicesByChipAndSide.set(pin.chipId, labelIndicesBySide);
+    }
+    const crowdedIndices = /* @__PURE__ */ new Set();
+    for (const labelIndicesBySide of labelIndicesByChipAndSide.values()) {
+      for (const labelIndices of labelIndicesBySide.values()) {
+        const hasWrongOrientation = labelIndices.some((index) => {
+          const label = this.outputNetLabelPlacements[index];
+          return !this.getAvailableOrientations(label).includes(
+            label.orientation
+          );
+        });
+        const hasOverlap = labelIndices.some((index, position) => {
+          const label = this.outputNetLabelPlacements[index];
+          const bounds = getRectBounds(label.center, label.width, label.height);
+          return labelIndices.slice(position + 1).some((otherIndex) => {
+            const other = this.outputNetLabelPlacements[otherIndex];
+            return rectsOverlap2(
+              bounds,
+              getRectBounds(other.center, other.width, other.height)
+            );
+          });
+        });
+        if (!hasWrongOrientation || !hasOverlap) continue;
+        for (const index of labelIndices) crowdedIndices.add(index);
+      }
+    }
+    return crowdedIndices;
   }
   processLabel(labelIndex) {
     const label = this.outputNetLabelPlacements[labelIndex];
@@ -8171,7 +8261,11 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   }
   addConnectorTrace(label, candidate, labelIndex) {
     if (candidate.phase === "trace-anchor") return;
-    const tracePath = this.getCandidateConnectorTrace(label, candidate);
+    const tracePath = this.getCandidateConnectorTrace(
+      label,
+      candidate,
+      labelIndex
+    );
     if (tracePath.length < 2) return;
     const mspPairId = `available-net-orientation-${labelIndex}-${label.netId ?? label.globalConnNetId}`;
     const connectorTrace = {
@@ -8200,6 +8294,14 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   findCorrectedCandidate(label, labelIndex) {
     const orientations = this.getAvailableOrientations(label);
     const requiredOrientation = orientations[0];
+    if (this.crowdedPortOnlyLabelIndices.has(labelIndex) && this.getChipSideForPoint(label.anchorPoint) === "top" && isYOrientation(requiredOrientation)) {
+      const topFanoutCandidate = this.findValidCrowdedTopVerticalFanoutCandidate(
+        label,
+        labelIndex,
+        requiredOrientation
+      );
+      if (topFanoutCandidate) return topFanoutCandidate;
+    }
     const netConnection = this.inputProblem.netConnections.find(
       (connection) => connection.netId === label.netId
     );
@@ -8254,6 +8356,77 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       labelIndex
     );
   }
+  findValidCrowdedTopVerticalFanoutCandidate(label, labelIndex, orientation) {
+    const pin = this.pinMap[label.pinIds[0]];
+    const chip = pin ? this.chipObstacleSpatialIndex.chips.find(
+      (candidate) => candidate.chipId === pin.chipId
+    ) : void 0;
+    if (!chip) return null;
+    const { width, height } = getDimsForOrientation({
+      orientation,
+      netLabelWidth: this.getNetLabelWidth(label),
+      netLabelHeight: this.getNetLabelHeight(label)
+    });
+    const nextPinToRight = this.outputNetLabelPlacements.map((otherLabel, index) => ({
+      index,
+      pin: this.pinMap[otherLabel.pinIds[0]]
+    })).filter(
+      ({ index, pin: otherPin }) => this.crowdedPortOnlyLabelIndices.has(index) && otherPin?.chipId === pin.chipId && otherPin.x > pin.x + EPS11
+    ).sort((a, b) => a.pin.x - b.pin.x)[0]?.pin;
+    if (orientation === "y-" && nextPinToRight) return null;
+    const anchorX = orientation === "y-" ? Math.max(
+      label.anchorPoint.x + LABEL_SEARCH_STEP,
+      chip.bounds.maxX + width / 2 + LABEL_TRACE_CLEARANCE2
+    ) : Math.min(
+      label.anchorPoint.x,
+      (nextPinToRight?.x ?? chip.bounds.maxX) - LABEL_SEARCH_STEP - width / 2
+    );
+    let highestPlacedLabelY = chip.bounds.maxY;
+    let lowestUpFacingLabelY = Number.POSITIVE_INFINITY;
+    let highestUpFacingLabelY = Number.NEGATIVE_INFINITY;
+    for (let index = 0; index < this.outputNetLabelPlacements.length; index++) {
+      if (index === labelIndex) continue;
+      if (!this.crowdedPortOnlyLabelIndices.has(index)) continue;
+      if (this.queuedLabelIndices.includes(index)) continue;
+      const placedLabel = this.outputNetLabelPlacements[index];
+      const placedBounds = getRectBounds(
+        placedLabel.center,
+        placedLabel.width,
+        placedLabel.height
+      );
+      highestPlacedLabelY = Math.max(highestPlacedLabelY, placedBounds.maxY);
+      if (placedLabel.orientation !== "y+") continue;
+      lowestUpFacingLabelY = Math.min(lowestUpFacingLabelY, placedBounds.minY);
+      highestUpFacingLabelY = Math.max(highestUpFacingLabelY, placedBounds.maxY);
+    }
+    const stackedAnchorY = highestPlacedLabelY + LABEL_SEARCH_STEP + (orientation === "y-" ? height : 0);
+    const hasUpFacingStack = Number.isFinite(lowestUpFacingLabelY) && Number.isFinite(highestUpFacingLabelY);
+    const centeredAnchorY = hasUpFacingStack ? (lowestUpFacingLabelY + highestUpFacingLabelY) / 2 : stackedAnchorY;
+    const anchorYs = orientation === "y-" ? [centeredAnchorY, stackedAnchorY] : [stackedAnchorY];
+    for (const anchorY of anchorYs) {
+      if (anchorY - label.anchorPoint.y > this.maxSearchDistance + EPS11) {
+        continue;
+      }
+      const candidate = this.createCandidate(
+        label,
+        { x: anchorX, y: anchorY },
+        orientation
+      );
+      const result = this.evaluateCandidate(
+        candidate,
+        label,
+        labelIndex,
+        "lateral-shift",
+        anchorY - label.anchorPoint.y,
+        anchorX - label.anchorPoint.x
+      );
+      this.currentCandidateResults.push(result);
+      if (result.status !== "valid") continue;
+      result.selected = true;
+      return result;
+    }
+    return null;
+  }
   hasTraceContinuingInOrientation(label, orientation) {
     const direction = dir(orientation);
     return Object.values(this.traceMap).some((trace) => {
@@ -8521,12 +8694,22 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       })
     };
   }
-  getCandidateConnectorTrace(label, candidate) {
+  getCandidateConnectorTrace(label, candidate, labelIndex) {
+    if (this.crowdedPortOnlyLabelIndices.has(labelIndex) && this.getChipSideForPoint(label.anchorPoint) === "top" && isYOrientation(candidate.orientation)) {
+      return simplifyOrthogonalPath([
+        label.anchorPoint,
+        { x: label.anchorPoint.x, y: candidate.anchorPoint.y },
+        candidate.anchorPoint
+      ]);
+    }
     if (candidate.phase === "lateral-shift") {
-      const orientDir = dir(candidate.orientation);
+      const chipOutwardDir = this.crowdedPortOnlyLabelIndices.has(labelIndex) ? this.getChipOutwardDirection(label.anchorPoint) : (() => {
+        const orientDir = dir(candidate.orientation);
+        return { x: -orientDir.x, y: -orientDir.y };
+      })();
       const kickedSource = {
-        x: label.anchorPoint.x - orientDir.x * LABEL_SEARCH_STEP,
-        y: label.anchorPoint.y - orientDir.y * LABEL_SEARCH_STEP
+        x: label.anchorPoint.x + chipOutwardDir.x * LABEL_SEARCH_STEP,
+        y: label.anchorPoint.y + chipOutwardDir.y * LABEL_SEARCH_STEP
       };
       return simplifyOrthogonalPath([
         label.anchorPoint,
@@ -8741,11 +8924,15 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       });
       if (nonChipBoundsStatus !== "valid") return nonChipBoundsStatus;
     }
-    const connectorTrace = this.getCandidateConnectorTrace(label, {
-      anchorPoint: candidate.anchorPoint,
-      orientation: candidate.orientation,
-      phase
-    });
+    const connectorTrace = this.getCandidateConnectorTrace(
+      label,
+      {
+        anchorPoint: candidate.anchorPoint,
+        orientation: candidate.orientation,
+        phase
+      },
+      labelIndex
+    );
     for (const chip of this.chipObstacleSpatialIndex.chips) {
       if (tracePathCrossesAnyBounds(connectorTrace, chip.bounds)) {
         return "chip-collision";
@@ -8753,6 +8940,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
       if (i === labelIndex) continue;
+      if (this.shouldIgnorePendingCrowdedLabel(labelIndex, i)) continue;
       const otherLabel = this.outputNetLabelPlacements[i];
       if (tracePathIntersectsBounds(
         connectorTrace,
@@ -8891,9 +9079,13 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   isPortOnlyLabel(label) {
     return label.mspConnectionPairIds.length === 0;
   }
+  shouldIgnorePendingCrowdedLabel(labelIndex, otherLabelIndex) {
+    return this.crowdedPortOnlyLabelIndices.has(labelIndex) && this.crowdedPortOnlyLabelIndices.has(otherLabelIndex) && this.queuedLabelIndices.includes(otherLabelIndex);
+  }
   intersectsAnyOtherNetLabel(bounds, labelIndex) {
     for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
       if (i === labelIndex) continue;
+      if (this.shouldIgnorePendingCrowdedLabel(labelIndex, i)) continue;
       const label = this.outputNetLabelPlacements[i];
       const otherBounds = getRectBounds(label.center, label.width, label.height);
       if (i === this.blockedStandaloneLabelIndex && isYOrientation(label.orientation)) {
@@ -8951,6 +9143,20 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return { x: 0, y: 0 };
   }
+  getChipOutwardDirection(point) {
+    switch (this.getChipSideForPoint(point)) {
+      case "left":
+        return { x: -1, y: 0 };
+      case "right":
+        return { x: 1, y: 0 };
+      case "bottom":
+        return { x: 0, y: -1 };
+      case "top":
+        return { x: 0, y: 1 };
+      default:
+        return { x: 0, y: 0 };
+    }
+  }
   getContainingChipSide(point) {
     let nearestSide = null;
     let nearestDistance = Number.POSITIVE_INFINITY;