@tscircuit/schematic-trace-solver 0.0.164 → 0.0.166

package/dist/index.d.ts

@@ -1394,11 +1394,15 @@ declare class NetLabelToTraceSolver extends BaseSolver {
     activeSubSolver: SchematicTraceSingleLineSolver2 | null;
     constructor(input: InlineNetLabelOutput);
     getConstructorParams(): [InlineNetLabelOutput];
-    private isEligiblePortOnlyDirectConnectionLabel;
+    private isPortOnlyFallbackLabel;
+    private isDirectConnectionLabel;
+    private getMultiPinNetConnection;
     private buildCandidatePairs;
+    private buildRoutedComponentCandidates;
     private isSupersededConnectorTrace;
     private routeIntersectsRemainingLabels;
     private tryAcceptCurrentRoute;
+    private areCandidatePinsAlreadyConnected;
     _step(): void;
     getOutput(): {
         traces: SolvedTracePath[];

package/dist/index.js

@@ -13009,6 +13009,214 @@ var alignSameNetJunctions = ({
   };
 };
 
+// lib/solvers/SameNetJunctionAlignmentSolver/collapseSameNetCycles.ts
+import { getSegmentIntersection as getSegmentIntersection4 } from "@tscircuit/math-utils/line-intersections";
+var TRACE_LENGTH_EPSILON = 1e-6;
+var getTracePathStartingAtPin = (trace, pin) => {
+  const pathStart = trace.tracePath[0];
+  const pathEnd = trace.tracePath.at(-1);
+  if (!pathStart || !pathEnd) return null;
+  if (pointsEqual(pathStart, pin)) return trace.tracePath;
+  if (pointsEqual(pathEnd, pin)) return [...trace.tracePath].reverse();
+  return null;
+};
+var getPerpendicularPathCrossings = (targetPath, donorPath) => {
+  const crossings = [];
+  const sharedEndpoint = targetPath[0];
+  for (let targetSegmentIndex = 0; targetSegmentIndex < targetPath.length - 1; targetSegmentIndex++) {
+    const targetStart = targetPath[targetSegmentIndex];
+    const targetEnd = targetPath[targetSegmentIndex + 1];
+    const targetOrientation = getRailOrientation(targetStart, targetEnd);
+    if (!targetOrientation) continue;
+    for (let donorSegmentIndex = 0; donorSegmentIndex < donorPath.length - 1; donorSegmentIndex++) {
+      const donorStart = donorPath[donorSegmentIndex];
+      const donorEnd = donorPath[donorSegmentIndex + 1];
+      const donorOrientation = getRailOrientation(donorStart, donorEnd);
+      if (!donorOrientation || donorOrientation === targetOrientation) continue;
+      const intersectionPoint = getSegmentIntersection4(
+        targetStart,
+        targetEnd,
+        donorStart,
+        donorEnd
+      );
+      if (!intersectionPoint || pointsEqual(intersectionPoint, sharedEndpoint)) {
+        continue;
+      }
+      crossings.push({
+        intersectionPoint,
+        targetSegmentIndex,
+        donorSegmentIndex
+      });
+    }
+  }
+  return crossings;
+};
+var buildCollapsedCyclePath = ({
+  targetTrace,
+  targetPath,
+  donorPath,
+  crossing
+}) => {
+  const pathFromSharedPin = simplifyPath([
+    ...donorPath.slice(0, crossing.donorSegmentIndex + 1),
+    crossing.intersectionPoint,
+    ...targetPath.slice(crossing.targetSegmentIndex + 1)
+  ]);
+  if (pointsEqual(targetTrace.tracePath[0], targetPath[0])) {
+    return pathFromSharedPin;
+  }
+  return pathFromSharedPin.reverse();
+};
+var getNetLabelPlacementsForCycleCollapse = ({
+  targetTrace,
+  tracePath,
+  netLabelPlacements
+}) => {
+  const candidateNetLabelPlacements = moveAttachedLabelsToReroutedTrace({
+    trace: targetTrace,
+    originalTracePath: targetTrace.tracePath,
+    reroutedTracePath: tracePath,
+    netLabelPlacements
+  });
+  for (let labelIndex = 0; labelIndex < netLabelPlacements.length; labelIndex++) {
+    const label = netLabelPlacements[labelIndex];
+    if (label.globalConnNetId !== targetTrace.globalConnNetId) continue;
+    if (!tracePathContainsPoint(targetTrace.tracePath, label.anchorPoint)) {
+      continue;
+    }
+    const candidateLabel = candidateNetLabelPlacements[labelIndex];
+    if (!tracePathContainsPoint(tracePath, candidateLabel.anchorPoint)) {
+      return null;
+    }
+  }
+  const otherNetLabelPlacements = candidateNetLabelPlacements.filter(
+    (label) => label.globalConnNetId !== targetTrace.globalConnNetId
+  );
+  if (pathIntersectsAnyNetLabel({
+    path: tracePath,
+    netLabelPlacements: otherNetLabelPlacements
+  })) {
+    return null;
+  }
+  const sameNetLabelPlacements = candidateNetLabelPlacements.filter(
+    (label) => label.globalConnNetId === targetTrace.globalConnNetId
+  );
+  if (pathEntersAnyNetLabel({
+    path: tracePath,
+    netLabelPlacements: sameNetLabelPlacements
+  })) {
+    return null;
+  }
+  return candidateNetLabelPlacements;
+};
+var candidateIsBetter = (candidate, bestCandidate) => {
+  if (!bestCandidate) return true;
+  const visibleLengthDelta = candidate.netVisibleLength - bestCandidate.netVisibleLength;
+  if (Math.abs(visibleLengthDelta) > TRACE_LENGTH_EPSILON) {
+    return visibleLengthDelta < 0;
+  }
+  return candidate.netVisibleSegmentCount < bestCandidate.netVisibleSegmentCount;
+};
+var getBestCycleCollapseCandidate = ({
+  targetTrace,
+  traces,
+  netLabelPlacements
+}) => {
+  const sameNetTraces = traces.filter(
+    (trace) => trace.globalConnNetId === targetTrace.globalConnNetId
+  );
+  const baselineNetVisibleLength = getVisibleTraceLength(sameNetTraces);
+  const baselineTargetVisibleLength = getVisibleTraceLength([targetTrace]);
+  let bestCandidate = null;
+  for (const donorTrace of sameNetTraces) {
+    if (donorTrace.mspPairId === targetTrace.mspPairId) continue;
+    const sharedPin = getSharedPin({
+      donorTrace,
+      branchTrace: targetTrace
+    });
+    if (!sharedPin) continue;
+    const targetPath = getTracePathStartingAtPin(targetTrace, sharedPin);
+    const donorPath = getTracePathStartingAtPin(donorTrace, sharedPin);
+    if (!targetPath || !donorPath) continue;
+    const crossings = getPerpendicularPathCrossings(targetPath, donorPath);
+    for (const crossing of crossings) {
+      const tracePath = buildCollapsedCyclePath({
+        targetTrace,
+        targetPath,
+        donorPath,
+        crossing
+      });
+      const candidateTrace = { ...targetTrace, tracePath };
+      const candidateTargetVisibleLength = getVisibleTraceLength([
+        candidateTrace
+      ]);
+      if (candidateTargetVisibleLength > baselineTargetVisibleLength + TRACE_LENGTH_EPSILON) {
+        continue;
+      }
+      const candidateNetLabelPlacements = getNetLabelPlacementsForCycleCollapse(
+        {
+          targetTrace,
+          tracePath,
+          netLabelPlacements
+        }
+      );
+      if (!candidateNetLabelPlacements) continue;
+      const candidateNetTraces = sameNetTraces.map((trace) => {
+        if (trace.mspPairId === targetTrace.mspPairId) return candidateTrace;
+        return trace;
+      });
+      const netVisibleLength = getVisibleTraceLength(candidateNetTraces);
+      if (netVisibleLength >= baselineNetVisibleLength - TRACE_LENGTH_EPSILON) {
+        continue;
+      }
+      const netVisibleSegmentCount = getVisibleTraceSegmentCount(candidateNetTraces);
+      const candidate = {
+        tracePath,
+        netLabelPlacements: candidateNetLabelPlacements,
+        netVisibleLength,
+        netVisibleSegmentCount
+      };
+      if (candidateIsBetter(candidate, bestCandidate)) {
+        bestCandidate = candidate;
+      }
+    }
+  }
+  return bestCandidate;
+};
+var collapseSameNetCycles = ({
+  traces,
+  netLabelPlacements
+}) => {
+  const outputTraces = [...traces];
+  let outputNetLabelPlacements = [...netLabelPlacements];
+  let collapsedCycleCount = 0;
+  let traceIndex = 0;
+  while (traceIndex < outputTraces.length) {
+    const targetTrace = outputTraces[traceIndex];
+    const candidate = getBestCycleCollapseCandidate({
+      targetTrace,
+      traces: outputTraces,
+      netLabelPlacements: outputNetLabelPlacements
+    });
+    if (!candidate) {
+      traceIndex++;
+      continue;
+    }
+    outputTraces[traceIndex] = {
+      ...targetTrace,
+      tracePath: candidate.tracePath
+    };
+    outputNetLabelPlacements = candidate.netLabelPlacements;
+    collapsedCycleCount++;
+    traceIndex = 0;
+  }
+  return {
+    traces: outputTraces,
+    netLabelPlacements: outputNetLabelPlacements,
+    collapsedCycleCount
+  };
+};
+
 // lib/solvers/SameNetJunctionAlignmentSolver/placeGroundRailLabelsAtOuterEnd.ts
 var placeGroundRailLabelsAtOuterEnd = ({
   inputProblem,
@@ -13090,14 +13298,19 @@ var SameNetJunctionAlignmentSolver = class extends BaseSolver {
     this.outputNetLabelPlacements = input.netLabelPlacements;
   }
   _step() {
-    const result = alignSameNetJunctions(this.input);
-    this.outputTraces = result.traces;
+    const alignment = alignSameNetJunctions(this.input);
+    const cycleCollapse = collapseSameNetCycles({
+      traces: alignment.traces,
+      netLabelPlacements: alignment.netLabelPlacements
+    });
+    this.outputTraces = cycleCollapse.traces;
     this.outputNetLabelPlacements = placeGroundRailLabelsAtOuterEnd({
       inputProblem: this.input.inputProblem,
-      traces: result.traces,
-      netLabelPlacements: result.netLabelPlacements
+      traces: cycleCollapse.traces,
+      netLabelPlacements: cycleCollapse.netLabelPlacements
     });
-    this.stats.alignedJunctionCount = result.alignedJunctionCount;
+    this.stats.alignedJunctionCount = alignment.alignedJunctionCount;
+    this.stats.collapsedCycleCount = cycleCollapse.collapsedCycleCount;
     this.solved = true;
   }
   getOutput() {
@@ -15051,6 +15264,8 @@ var getTraceRecoveryConnectivityMaps = (inputProblem) => {
 // lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts
 var AVAILABLE_NET_ORIENTATION_PREFIX = "available-net-orientation-";
 var RECOVERED_TRACE_PREFIX = "net-label-to-trace-";
+var MAX_NAMED_NET_RECOVERY_PERPENDICULAR_OFFSET = 0.05;
+var MAX_ROUTED_COMPONENT_RECOVERY_PERPENDICULAR_OFFSET = 0.25;
 var getCanonicalPairKey = (firstPinId, secondPinId) => [firstPinId, secondPinId].sort().join("--");
 var pathIntersectsRenderedLabel = (path, label) => {
   let width = label.width;
@@ -15071,12 +15286,21 @@ var pathIntersectsRenderedLabel = (path, label) => {
   }
   return false;
 };
-var getPerpendicularOffset = (firstPin, secondPin) => {
-  const xDistance = Math.abs(firstPin.x - secondPin.x);
-  const yDistance = Math.abs(firstPin.y - secondPin.y);
+var getPerpendicularOffset = (firstPoint, secondPoint) => {
+  const xDistance = Math.abs(firstPoint.x - secondPoint.x);
+  const yDistance = Math.abs(firstPoint.y - secondPoint.y);
   if (xDistance >= yDistance) return yDistance;
   return xDistance;
 };
+var arePinsCoFacingAlongSeparationAxis = (firstPin, secondPin) => {
+  if (firstPin._facingDirection !== secondPin._facingDirection) return false;
+  const xDistance = Math.abs(firstPin.x - secondPin.x);
+  const yDistance = Math.abs(firstPin.y - secondPin.y);
+  if (xDistance >= yDistance) {
+    return firstPin._facingDirection === "x+" || firstPin._facingDirection === "x-";
+  }
+  return firstPin._facingDirection === "y+" || firstPin._facingDirection === "y-";
+};
 var NetLabelToTraceSolver = class extends BaseSolver {
   constructor(input) {
     super();
@@ -15104,26 +15328,36 @@ var NetLabelToTraceSolver = class extends BaseSolver {
   getConstructorParams() {
     return [this.input];
   }
-  isEligiblePortOnlyDirectConnectionLabel(label, groundGlobalConnNetId) {
-    if (label.pinIds.length !== 1 || label.mspConnectionPairIds.length !== 0 || !label.netId || label.netId === "GND" || label.globalConnNetId === groundGlobalConnNetId) {
-      return false;
-    }
+  isPortOnlyFallbackLabel(label, groundGlobalConnNetIds) {
+    return !(label.pinIds.length !== 1 || label.mspConnectionPairIds.length !== 0 || !label.netId || groundGlobalConnNetIds.has(label.globalConnNetId));
+  }
+  isDirectConnectionLabel(label) {
+    if (!label.netId || label.pinIds.length !== 1) return false;
     const pinId = label.pinIds[0];
     return this.inputProblem.directConnections.some(
       (connection) => connection.netId === label.netId && connection.pinIds.includes(pinId)
     );
   }
+  getMultiPinNetConnection(label) {
+    if (!label.netId || label.pinIds.length !== 1) return void 0;
+    const pinId = label.pinIds[0];
+    return this.inputProblem.netConnections.find(
+      (connection) => connection.isGround === false && connection.pinIds.length > 2 && connection.netId === label.netId && connection.pinIds.includes(pinId)
+    );
+  }
   buildCandidatePairs() {
     const { netConnMap } = getConnectivityMapsFromInputProblem(
       this.inputProblem
     );
-    const groundGlobalConnNetId = netConnMap.getNetConnectedToId("GND") ?? void 0;
+    const groundGlobalConnNetIds = /* @__PURE__ */ new Set();
+    for (const connection of this.inputProblem.netConnections) {
+      if (!connection.isGround) continue;
+      const globalConnNetId = netConnMap.getNetConnectedToId(connection.netId);
+      if (globalConnNetId) groundGlobalConnNetIds.add(globalConnNetId);
+    }
     const labelsByGlobalNet = /* @__PURE__ */ new Map();
     for (const label of this.input.netLabelPlacements) {
-      if (!this.isEligiblePortOnlyDirectConnectionLabel(
-        label,
-        groundGlobalConnNetId
-      )) {
+      if (!this.isPortOnlyFallbackLabel(label, groundGlobalConnNetIds) || !this.isDirectConnectionLabel(label) && !this.getMultiPinNetConnection(label)) {
         continue;
       }
       const labels = labelsByGlobalNet.get(label.globalConnNetId) ?? [];
@@ -15139,6 +15373,16 @@ var NetLabelToTraceSolver = class extends BaseSolver {
           const firstPin = this.pinMap.get(firstLabel.pinIds[0]);
           const secondPin = this.pinMap.get(secondLabel.pinIds[0]);
           if (!firstPin || !secondPin) continue;
+          const perpendicularOffset = getPerpendicularOffset(
+            firstPin,
+            secondPin
+          );
+          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)) {
+            continue;
+          }
           if (arePinsInDifferentSchematicSections(
             this.inputProblem,
             firstPin,
@@ -15159,18 +15403,103 @@ var NetLabelToTraceSolver = class extends BaseSolver {
             firstLabel,
             secondLabel,
             pins: [firstPin, secondPin],
-            perpendicularOffset: getPerpendicularOffset(firstPin, secondPin),
+            perpendicularOffset,
             routeDistance: Math.abs(firstPin.x - secondPin.x) + Math.abs(firstPin.y - secondPin.y),
-            key: getCanonicalPairKey(firstPin.pinId, secondPin.pinId)
+            key: getCanonicalPairKey(firstPin.pinId, secondPin.pinId),
+            recoveryMode: "fallback_labels"
           });
         }
       }
     }
+    candidates.push(...this.buildRoutedComponentCandidates());
     candidates.sort(
       (first, second) => first.perpendicularOffset - second.perpendicularOffset || first.routeDistance - second.routeDistance || first.key.localeCompare(second.key)
     );
     return candidates;
   }
+  buildRoutedComponentCandidates() {
+    const { netConnMap } = getConnectivityMapsFromInputProblem(
+      this.inputProblem
+    );
+    const candidates = [];
+    for (const connection of this.inputProblem.netConnections) {
+      if (connection.pinIds.length <= 2 || connection.isGround !== false)
+        continue;
+      const globalConnNetId = netConnMap.getNetConnectedToId(connection.netId);
+      if (!globalConnNetId) continue;
+      const traceConnectedPinComponents = getTraceConnectedPinComponents({
+        pinIds: connection.pinIds,
+        traces: this.outputTraces.filter(
+          (trace) => trace.globalConnNetId === globalConnNetId
+        )
+      }).filter((component) => component.traces.length > 0);
+      for (let firstIndex = 0; firstIndex < traceConnectedPinComponents.length; firstIndex++) {
+        for (let secondIndex = firstIndex + 1; secondIndex < traceConnectedPinComponents.length; secondIndex++) {
+          const firstComponent = traceConnectedPinComponents[firstIndex];
+          const secondComponent = traceConnectedPinComponents[secondIndex];
+          const firstLabel = this.input.netLabelPlacements.find(
+            (label) => label.globalConnNetId === globalConnNetId && label.mspConnectionPairIds.length > 0 && label.pinIds.some(
+              (pinId) => firstComponent.pinIds.includes(pinId)
+            )
+          );
+          const secondLabel = this.input.netLabelPlacements.find(
+            (label) => label.globalConnNetId === globalConnNetId && label.mspConnectionPairIds.length > 0 && label.pinIds.some(
+              (pinId) => secondComponent.pinIds.includes(pinId)
+            )
+          );
+          if (!firstLabel || !secondLabel || firstLabel === secondLabel)
+            continue;
+          if (getPerpendicularOffset(
+            firstLabel.anchorPoint,
+            secondLabel.anchorPoint
+          ) > MAX_ROUTED_COMPONENT_RECOVERY_PERPENDICULAR_OFFSET) {
+            continue;
+          }
+          let bestCandidate;
+          for (const firstPinId of firstComponent.pinIds) {
+            for (const secondPinId of secondComponent.pinIds) {
+              const firstPin = this.pinMap.get(firstPinId);
+              const secondPin = this.pinMap.get(secondPinId);
+              if (!firstPin || !secondPin) continue;
+              const perpendicularOffset = getPerpendicularOffset(
+                firstPin,
+                secondPin
+              );
+              if (perpendicularOffset > MAX_ROUTED_COMPONENT_RECOVERY_PERPENDICULAR_OFFSET || arePinsCoFacingAlongSeparationAxis(firstPin, secondPin) || arePinsInDifferentSchematicSections(
+                this.inputProblem,
+                firstPin,
+                secondPin
+              ) || doesPairCrossRestrictedCenterLines({
+                inputProblem: this.inputProblem,
+                chipMap: this.chipMap,
+                pinIdMap: this.pinMap,
+                p1: firstPin,
+                p2: secondPin
+              })) {
+                continue;
+              }
+              const routeDistance = Math.abs(firstPin.x - secondPin.x) + Math.abs(firstPin.y - secondPin.y);
+              const candidate = {
+                firstLabel,
+                secondLabel,
+                pins: [firstPin, secondPin],
+                perpendicularOffset,
+                routeDistance,
+                key: getCanonicalPairKey(firstPin.pinId, secondPin.pinId),
+                recoveryMode: "routed_components",
+                netConnectionPinIds: connection.pinIds
+              };
+              if (!bestCandidate || candidate.routeDistance < bestCandidate.routeDistance || candidate.routeDistance === bestCandidate.routeDistance && (candidate.perpendicularOffset < bestCandidate.perpendicularOffset || candidate.perpendicularOffset === bestCandidate.perpendicularOffset && candidate.key.localeCompare(bestCandidate.key) < 0)) {
+                bestCandidate = candidate;
+              }
+            }
+          }
+          if (bestCandidate) candidates.push(bestCandidate);
+        }
+      }
+    }
+    return candidates;
+  }
   isSupersededConnectorTrace(trace, candidate) {
     if (!trace.mspPairId.startsWith(AVAILABLE_NET_ORIENTATION_PREFIX)) {
       return false;
@@ -15196,7 +15525,13 @@ var NetLabelToTraceSolver = class extends BaseSolver {
     const retainedTraces = this.outputTraces.filter(
       (trace) => !this.isSupersededConnectorTrace(trace, candidate)
     );
-    if (doesTraceOverlapWithExistingTraces(tracePath, retainedTraces) || this.routeIntersectsRemainingLabels(tracePath, candidate)) {
+    let collisionTraces = retainedTraces;
+    if (candidate.recoveryMode === "routed_components") {
+      collisionTraces = retainedTraces.filter(
+        (trace) => trace.globalConnNetId !== candidate.firstLabel.globalConnNetId
+      );
+    }
+    if (doesTraceOverlapWithExistingTraces(tracePath, collisionTraces) || this.routeIntersectsRemainingLabels(tracePath, candidate)) {
       return;
     }
     const [firstPin, secondPin] = candidate.pins;
@@ -15211,11 +15546,22 @@ var NetLabelToTraceSolver = class extends BaseSolver {
       pinIds: [firstPin.pinId, secondPin.pinId]
     };
     this.outputTraces = [...retainedTraces, recoveredTrace];
-    this.outputNetLabelPlacements = this.outputNetLabelPlacements.filter(
-      (label) => label !== candidate.firstLabel && label !== candidate.secondLabel
-    );
+    if (candidate.recoveryMode === "fallback_labels") {
+      this.outputNetLabelPlacements = this.outputNetLabelPlacements.filter(
+        (label) => label !== candidate.firstLabel && label !== candidate.secondLabel
+      );
+    }
     this.stats.recoveredTraceCount++;
   }
+  areCandidatePinsAlreadyConnected(candidate) {
+    if (!candidate.netConnectionPinIds) return false;
+    return getTraceConnectedPinComponents({
+      pinIds: candidate.netConnectionPinIds,
+      traces: this.outputTraces
+    }).some(
+      (component) => component.pinIds.includes(candidate.pins[0].pinId) && component.pinIds.includes(candidate.pins[1].pinId)
+    );
+  }
   _step() {
     if (this.activeSubSolver) {
       this.activeSubSolver.step();
@@ -15230,7 +15576,7 @@ var NetLabelToTraceSolver = class extends BaseSolver {
       return;
     }
     let candidate = this.queuedCandidates.shift();
-    while (candidate && (!this.outputNetLabelPlacements.includes(candidate.firstLabel) || !this.outputNetLabelPlacements.includes(candidate.secondLabel))) {
+    while (candidate && (!this.outputNetLabelPlacements.includes(candidate.firstLabel) || !this.outputNetLabelPlacements.includes(candidate.secondLabel) || this.areCandidatePinsAlreadyConnected(candidate))) {
       candidate = this.queuedCandidates.shift();
     }
     if (!candidate) {