@tscircuit/schematic-trace-solver 0.0.183 → 0.0.185

package/dist/index.js

@@ -12659,6 +12659,7 @@ ${c.status}`
 
 // lib/solvers/UnroutedTraceRecoverySolver/UnroutedTraceRecoverySolver.ts
 import { distance as distance6, doSegmentsIntersect as doSegmentsIntersect3 } from "@tscircuit/math-utils";
+import { calculateElbow as calculateElbow3 } from "calculate-elbow";
 var ROUTE_CLEARANCE = 0.2;
 var COORDINATE_TOLERANCE = 1e-9;
 var GROUND_NET_ID = "GND";
@@ -12711,7 +12712,7 @@ var getOuterBounds = (obstacles) => {
     maxY: Math.max(...obstacles.map((obstacle) => obstacle.maxY))
   };
 };
-var getPerimeterCandidates = ({
+var getPinConnectionCandidates = ({
   connectionPair,
   obstacles
 }) => {
@@ -12733,7 +12734,13 @@ var getPerimeterCandidates = ({
     outerBounds.minX - ROUTE_CLEARANCE,
     outerBounds.maxX + ROUTE_CLEARANCE
   ];
-  const candidates = [];
+  const candidates = [
+    calculateElbow3(
+      { ...firstPin, facingDirection: firstPin._facingDirection },
+      { ...secondPin, facingDirection: secondPin._facingDirection },
+      { overshoot: ROUTE_CLEARANCE }
+    )
+  ];
   for (const channelY of horizontalChannels) {
     candidates.push(
       removeConsecutiveDuplicatePoints([
@@ -13053,11 +13060,11 @@ var UnroutedTraceRecoverySolver = class extends BaseSolver {
       obstacles,
       maxConnectionDistance: this.maxConnectionDistance
     });
-    const perimeterCandidates = getPerimeterCandidates({
+    const pinConnectionCandidates = getPinConnectionCandidates({
       connectionPair,
       obstacles
     });
-    const candidates = [...junctionCandidates, ...perimeterCandidates];
+    const candidates = [...junctionCandidates, ...pinConnectionCandidates];
     const rejectComponentBoundaryTravel = hasParallelFailedConnection({
       connectionPair,
       failedConnectionPairs: this.failedConnectionPairs
@@ -13230,24 +13237,228 @@ var findNearestSharedPinExitRail = ({
   return nearestRail;
 };
 
+// lib/solvers/SameNetJunctionAlignmentSolver/getSharedPin.ts
+var getSharedPin = ({
+  donorTrace,
+  branchTrace
+}) => {
+  const branchPinIds = new Set(branchTrace.pins.map((pin) => pin.pinId));
+  return donorTrace.pins.find((pin) => branchPinIds.has(pin.pinId)) ?? null;
+};
+
+// lib/solvers/SameNetJunctionAlignmentSolver/collapseRedundantSharedEndpointStubs.ts
+var getSegmentAxis3 = (start, end) => {
+  if (nearlyEqual(start.x, end.x)) return "y";
+  if (nearlyEqual(start.y, end.y)) return "x";
+  return null;
+};
+var getPathFromSharedPin = ({
+  trace,
+  sharedPinId
+}) => {
+  const tracePath = simplifyPath(trace.tracePath);
+  if (trace.pins[0]?.pinId === sharedPinId) return tracePath;
+  return tracePath.reverse();
+};
+var traceCanLoseSharedPrefix = ({
+  trace,
+  sharedPrefix,
+  netLabelPlacements
+}) => {
+  return !netLabelPlacements.some(
+    (label) => label.mspConnectionPairIds.includes(trace.mspPairId) && tracePathContainsPoint(sharedPrefix, label.anchorPoint)
+  );
+};
+var getTraceWithoutSharedPrefix = ({
+  trace,
+  pathFromSharedPin,
+  sharedPinId,
+  branchPoint
+}) => {
+  const branchSegmentIndex = pathFromSharedPin.findIndex((point, index) => {
+    const nextPoint = pathFromSharedPin[index + 1];
+    if (!nextPoint) return false;
+    return tracePathContainsPoint([point, nextPoint], branchPoint);
+  });
+  if (branchSegmentIndex < 0) return null;
+  const pathFromJunction = simplifyPath([
+    branchPoint,
+    ...pathFromSharedPin.slice(branchSegmentIndex + 1)
+  ]);
+  let tracePath = pathFromJunction;
+  if (trace.pins[0]?.pinId !== sharedPinId) {
+    tracePath = pathFromJunction.reverse();
+  }
+  return { ...trace, tracePath };
+};
+var collapseRedundantSharedEndpointStubs = ({
+  traces,
+  netLabelPlacements,
+  netLabelConnectorTraceIds,
+  multiPinNetPinIds
+}) => {
+  const outputTraces = [...traces];
+  for (let firstIndex = 0; firstIndex < outputTraces.length; firstIndex++) {
+    const firstTrace = outputTraces[firstIndex];
+    if (netLabelConnectorTraceIds.has(firstTrace.mspPairId)) continue;
+    for (let secondIndex = firstIndex + 1; secondIndex < outputTraces.length; secondIndex++) {
+      const secondTrace = outputTraces[secondIndex];
+      if (netLabelConnectorTraceIds.has(secondTrace.mspPairId) || firstTrace.globalConnNetId !== secondTrace.globalConnNetId) {
+        continue;
+      }
+      const sharedPin = getSharedPin({
+        donorTrace: firstTrace,
+        branchTrace: secondTrace
+      });
+      if (!sharedPin || !multiPinNetPinIds.has(sharedPin.pinId)) continue;
+      const firstPath = getPathFromSharedPin({
+        trace: firstTrace,
+        sharedPinId: sharedPin.pinId
+      });
+      const secondPath = getPathFromSharedPin({
+        trace: secondTrace,
+        sharedPinId: sharedPin.pinId
+      });
+      if (firstPath.length < 2 || secondPath.length < 2) continue;
+      const departureAxis = getSegmentAxis3(firstPath[0], firstPath[1]);
+      const secondDepartureAxis = getSegmentAxis3(secondPath[0], secondPath[1]);
+      if (!departureAxis || departureAxis !== secondDepartureAxis) continue;
+      const firstDepartureDirection = firstPath[1][departureAxis] - firstPath[0][departureAxis];
+      const secondDepartureDirection = secondPath[1][departureAxis] - secondPath[0][departureAxis];
+      if (!pointsEqual2(firstPath[1], secondPath[1]) && Math.sign(firstDepartureDirection) === Math.sign(secondDepartureDirection)) {
+        let traceIndexToCollapse2 = secondIndex;
+        let traceToCollapse2 = secondTrace;
+        let pathToCollapse2 = secondPath;
+        if (Math.abs(firstDepartureDirection) < Math.abs(secondDepartureDirection)) {
+          traceIndexToCollapse2 = firstIndex;
+          traceToCollapse2 = firstTrace;
+          pathToCollapse2 = firstPath;
+        }
+        const branchPoint2 = pathToCollapse2[1];
+        if (!traceCanLoseSharedPrefix({
+          trace: traceToCollapse2,
+          sharedPrefix: [pathToCollapse2[0], branchPoint2],
+          netLabelPlacements
+        })) {
+          if (traceIndexToCollapse2 === firstIndex) {
+            traceIndexToCollapse2 = secondIndex;
+            traceToCollapse2 = secondTrace;
+            pathToCollapse2 = secondPath;
+          } else {
+            traceIndexToCollapse2 = firstIndex;
+            traceToCollapse2 = firstTrace;
+            pathToCollapse2 = firstPath;
+          }
+        }
+        if (!traceCanLoseSharedPrefix({
+          trace: traceToCollapse2,
+          sharedPrefix: [pathToCollapse2[0], branchPoint2],
+          netLabelPlacements
+        })) {
+          continue;
+        }
+        const collapsedTrace2 = getTraceWithoutSharedPrefix({
+          trace: traceToCollapse2,
+          pathFromSharedPin: pathToCollapse2,
+          sharedPinId: sharedPin.pinId,
+          branchPoint: branchPoint2
+        });
+        if (!collapsedTrace2) continue;
+        outputTraces[traceIndexToCollapse2] = collapsedTrace2;
+        break;
+      }
+      if (firstPath.length < 3 || secondPath.length < 3) continue;
+      if (!pointsEqual2(firstPath[1], secondPath[1])) continue;
+      const railAxis = getSegmentAxis3(firstPath[1], firstPath[2]);
+      const secondRailAxis = getSegmentAxis3(secondPath[1], secondPath[2]);
+      if (!railAxis || railAxis !== secondRailAxis || railAxis === departureAxis) {
+        continue;
+      }
+      const firstRailDirection = firstPath[2][railAxis] - firstPath[1][railAxis];
+      const secondRailDirection = secondPath[2][railAxis] - secondPath[1][railAxis];
+      const railsHaveSameDirection = Math.sign(firstRailDirection) === Math.sign(secondRailDirection);
+      const sharedStub = firstPath.slice(0, 2);
+      if (!railsHaveSameDirection && !nearlyEqual(
+        Math.abs(firstRailDirection),
+        Math.abs(secondRailDirection)
+      ) && netLabelPlacements.some(
+        (label) => label.globalConnNetId === firstTrace.globalConnNetId && tracePathContainsPoint(sharedStub, label.anchorPoint)
+      )) {
+        continue;
+      }
+      let traceIndexToCollapse = secondIndex;
+      let traceToCollapse = secondTrace;
+      let pathToCollapse = secondPath;
+      let branchPoint = firstPath[1];
+      if (railsHaveSameDirection && Math.abs(firstRailDirection) < Math.abs(secondRailDirection)) {
+        traceIndexToCollapse = firstIndex;
+        traceToCollapse = firstTrace;
+        pathToCollapse = firstPath;
+        branchPoint = firstPath[2];
+      } else if (railsHaveSameDirection) {
+        branchPoint = secondPath[2];
+      }
+      const sharedPrefix = [pathToCollapse[0], pathToCollapse[1], branchPoint];
+      if (!traceCanLoseSharedPrefix({
+        trace: traceToCollapse,
+        sharedPrefix,
+        netLabelPlacements
+      })) {
+        if (traceIndexToCollapse === firstIndex) {
+          traceIndexToCollapse = secondIndex;
+          traceToCollapse = secondTrace;
+          pathToCollapse = secondPath;
+        } else {
+          traceIndexToCollapse = firstIndex;
+          traceToCollapse = firstTrace;
+          pathToCollapse = firstPath;
+        }
+      }
+      if (!traceCanLoseSharedPrefix({
+        trace: traceToCollapse,
+        sharedPrefix: [pathToCollapse[0], pathToCollapse[1], branchPoint],
+        netLabelPlacements
+      })) {
+        continue;
+      }
+      const collapsedTrace = getTraceWithoutSharedPrefix({
+        trace: traceToCollapse,
+        pathFromSharedPin: pathToCollapse,
+        sharedPinId: sharedPin.pinId,
+        branchPoint
+      });
+      if (!collapsedTrace) continue;
+      outputTraces[traceIndexToCollapse] = collapsedTrace;
+      break;
+    }
+  }
+  return outputTraces;
+};
+
 // lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts
 var MAX_ALIGNED_LOAD_PIN_OFFSET = 0.2;
 var MAX_SAME_NET_LABEL_BOUNDARY_RAIL_OFFSET = 0.2;
 var MAX_SHARED_PIN_RAIL_OFFSET = 0.05;
 var MAX_SHARED_ENDPOINT_RAIL_OFFSET = 0.8;
 var MIN_RETURN_STEM_LENGTH = 0.05;
-var getSegmentAxis3 = (start, end) => {
+var getMultiPinNetPinIds = (inputProblem) => {
+  const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
+  const inputPinIds = new Set(
+    inputProblem.chips.flatMap((chip) => chip.pins.map((pin) => pin.pinId))
+  );
+  return new Set(
+    [...inputPinIds].filter((pinId) => {
+      const globalNetId = netConnMap.getNetConnectedToId(pinId);
+      if (!globalNetId) return false;
+      return netConnMap.getIdsConnectedToNet(globalNetId).filter((connectedId) => inputPinIds.has(connectedId)).length > 2;
+    })
+  );
+};
+var getSegmentAxis4 = (start, end) => {
   if (isHorizontal2(start, end)) return "x";
   if (isVertical2(start, end)) return "y";
   return null;
 };
-var getSharedPin = ({
-  donorTrace,
-  branchTrace
-}) => {
-  const branchPinIds = new Set(branchTrace.pins.map((pin) => pin.pinId));
-  return donorTrace.pins.find((pin) => branchPinIds.has(pin.pinId)) ?? null;
-};
 var getOtherPin = ({
   trace,
   sharedPin
@@ -13473,8 +13684,8 @@ var getAlignedSharedEndpointRailPath = ({
   const donorPath = pathFromShared(donorTrace);
   const branchPath = pathFromShared(branchTrace);
   if (donorPath.length < 3 || branchPath.length < 4) return null;
-  const donorDepartureAxis = getSegmentAxis3(donorPath[0], donorPath[1]);
-  const branchDepartureAxis = getSegmentAxis3(branchPath[0], branchPath[1]);
+  const donorDepartureAxis = getSegmentAxis4(donorPath[0], donorPath[1]);
+  const branchDepartureAxis = getSegmentAxis4(branchPath[0], branchPath[1]);
   if (!donorDepartureAxis || donorDepartureAxis !== branchDepartureAxis) {
     return null;
   }
@@ -13482,8 +13693,8 @@ var getAlignedSharedEndpointRailPath = ({
   const branchDeparture = branchPath[1][branchDepartureAxis] - branchPath[0][branchDepartureAxis];
   if (Math.sign(donorDeparture) !== Math.sign(branchDeparture)) return null;
   let railIndex = 1;
-  let donorRailAxis = getSegmentAxis3(donorPath[1], donorPath[2]);
-  let branchRailAxis = getSegmentAxis3(branchPath[1], branchPath[2]);
+  let donorRailAxis = getSegmentAxis4(donorPath[1], donorPath[2]);
+  let branchRailAxis = getSegmentAxis4(branchPath[1], branchPath[2]);
   if (!donorRailAxis || donorRailAxis !== branchRailAxis || donorRailAxis === donorDepartureAxis) {
     return null;
   }
@@ -13491,11 +13702,11 @@ var getAlignedSharedEndpointRailPath = ({
   if (firstRailsAreAligned) {
     railIndex++;
     if (!donorPath[railIndex + 2] || !branchPath[railIndex + 2]) return null;
-    donorRailAxis = getSegmentAxis3(
+    donorRailAxis = getSegmentAxis4(
       donorPath[railIndex],
       donorPath[railIndex + 1]
     );
-    branchRailAxis = getSegmentAxis3(
+    branchRailAxis = getSegmentAxis4(
       branchPath[railIndex],
       branchPath[railIndex + 1]
     );
@@ -13503,7 +13714,7 @@ var getAlignedSharedEndpointRailPath = ({
   }
   let branchParallelRailCount = 0;
   for (let index = 1; index < branchPath.length - 2; index++) {
-    if (getSegmentAxis3(branchPath[index], branchPath[index + 1]) === branchRailAxis) {
+    if (getSegmentAxis4(branchPath[index], branchPath[index + 1]) === branchRailAxis) {
       branchParallelRailCount++;
     }
   }
@@ -13545,13 +13756,13 @@ var getAlignedAttachedLabelConnectorPath = ({
     const junction = connectorPath[0];
     const turn = connectorPath[1];
     const railEnd = connectorPath[2];
-    const departureAxis = getSegmentAxis3(junction, turn);
-    const railAxis = getSegmentAxis3(turn, railEnd);
+    const departureAxis = getSegmentAxis4(junction, turn);
+    const railAxis = getSegmentAxis4(turn, railEnd);
     if (!departureAxis || !railAxis || departureAxis === railAxis) return null;
     const donorSegmentIndex = donorTrace.tracePath.findIndex(
       (point, index, path) => {
         const next = path[index + 1];
-        return next && getSegmentAxis3(point, next) === departureAxis && tracePathContainsPoint([point, next], junction) && tracePathContainsPoint([point, next], turn);
+        return next && getSegmentAxis4(point, next) === departureAxis && tracePathContainsPoint([point, next], junction) && tracePathContainsPoint([point, next], turn);
       }
     );
     if (donorSegmentIndex < 0) return null;
@@ -13564,7 +13775,7 @@ var getAlignedAttachedLabelConnectorPath = ({
       donorSegmentIndex > 0 ? [donorTrace.tracePath[donorSegmentIndex - 1], donorSegmentStart] : null,
       donorSegmentIndex + 2 < donorTrace.tracePath.length ? [donorSegmentEnd, donorTrace.tracePath[donorSegmentIndex + 2]] : null
     ].flatMap(
-      (segment) => segment && getSegmentAxis3(segment[0], segment[1]) === railAxis ? [segment] : []
+      (segment) => segment && getSegmentAxis4(segment[0], segment[1]) === railAxis ? [segment] : []
     );
     if (adjacentDonorRails.length === 0) return null;
     const railCoordinateAxis = railAxis === "x" ? "y" : "x";
@@ -13647,7 +13858,7 @@ var preserveAttachedLabelConnectorJunctions = ({
     if (!movedJunction) return null;
     const neighborIndex = endpointIndex === 0 ? 1 : endpointIndex - 1;
     const neighbor = connector.tracePath[neighborIndex];
-    if (!neighbor || getSegmentAxis3(originalJunction, neighbor) !== getSegmentAxis3(movedJunction, neighbor)) {
+    if (!neighbor || getSegmentAxis4(originalJunction, neighbor) !== getSegmentAxis4(movedJunction, neighbor)) {
       return null;
     }
     const movedConnector = {
@@ -14070,6 +14281,13 @@ var alignSameNetJunctions = ({
       }
     }
   }
+  const collapsedSharedEndpointStubs = collapseRedundantSharedEndpointStubs({
+    traces: outputTraces,
+    netLabelPlacements: outputNetLabelPlacements,
+    netLabelConnectorTraceIds,
+    multiPinNetPinIds: getMultiPinNetPinIds(inputProblem)
+  });
+  outputTraces = collapsedSharedEndpointStubs;
   return {
     traces: outputTraces,
     netLabelPlacements: outputNetLabelPlacements,

package/lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts

@@ -2,6 +2,7 @@ import type { Point } from "@tscircuit/math-utils"
 import { getSegmentIntersection } from "@tscircuit/math-utils/line-intersections"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
 import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import { getConnectivityMapsFromInputProblem } from "lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem"
 import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import { isPathCollidingWithObstacles } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
@@ -20,7 +21,7 @@ import {
   isVertical,
   nearlyEqual,
 } from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
-import type { InputPin, InputProblem } from "lib/types/InputProblem"
+import type { InputPin, InputProblem, PinId } from "lib/types/InputProblem"
 import { doesPathCoincideWithTraces } from "lib/utils/doesPathCoincideWithTraces"
 import {
   pathEntersAnyNetLabel,
@@ -31,6 +32,8 @@ import {
   getPinFacingAxis,
   isCoordinateOnPinFacingSide,
 } from "./findNearestSharedPinExitRail"
+import { collapseRedundantSharedEndpointStubs } from "./collapseRedundantSharedEndpointStubs"
+import { getSharedPin } from "./getSharedPin"
 
 interface AlignSameNetJunctionsInput {
   inputProblem: InputProblem
@@ -57,23 +60,30 @@ const MAX_SHARED_PIN_RAIL_OFFSET = 0.05
 const MAX_SHARED_ENDPOINT_RAIL_OFFSET = 0.8
 const MIN_RETURN_STEM_LENGTH = 0.05
 
+const getMultiPinNetPinIds = (inputProblem: InputProblem) => {
+  const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem)
+  const inputPinIds = new Set<PinId>(
+    inputProblem.chips.flatMap((chip) => chip.pins.map((pin) => pin.pinId)),
+  )
+  return new Set(
+    [...inputPinIds].filter((pinId) => {
+      const globalNetId = netConnMap.getNetConnectedToId(pinId)
+      if (!globalNetId) return false
+      return (
+        netConnMap
+          .getIdsConnectedToNet(globalNetId)
+          .filter((connectedId) => inputPinIds.has(connectedId)).length > 2
+      )
+    }),
+  )
+}
+
 const getSegmentAxis = (start: Point, end: Point) => {
   if (isHorizontal(start, end)) return "x" as const
   if (isVertical(start, end)) return "y" as const
   return null
 }
 
-export const getSharedPin = ({
-  donorTrace,
-  branchTrace,
-}: {
-  donorTrace: SolvedTracePath
-  branchTrace: SolvedTracePath
-}): (InputPin & { chipId: string }) | null => {
-  const branchPinIds = new Set(branchTrace.pins.map((pin) => pin.pinId))
-  return donorTrace.pins.find((pin) => branchPinIds.has(pin.pinId)) ?? null
-}
-
 const getOtherPin = ({
   trace,
   sharedPin,
@@ -1301,6 +1311,14 @@ export const alignSameNetJunctions = ({
     }
   }
 
+  const collapsedSharedEndpointStubs = collapseRedundantSharedEndpointStubs({
+    traces: outputTraces,
+    netLabelPlacements: outputNetLabelPlacements,
+    netLabelConnectorTraceIds,
+    multiPinNetPinIds: getMultiPinNetPinIds(inputProblem),
+  })
+  outputTraces = collapsedSharedEndpointStubs
+
   return {
     traces: outputTraces,
     netLabelPlacements: outputNetLabelPlacements,