@tscircuit/schematic-trace-solver 0.0.182 → 0.0.184

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,

package/lib/solvers/SameNetJunctionAlignmentSolver/collapseRedundantSharedEndpointStubs.ts

@@ -0,0 +1,267 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { PinId } from "lib/types/InputProblem"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  nearlyEqual,
+  pointsEqual,
+} from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
+import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+import { tracePathContainsPoint } from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
+import { getSharedPin } from "./getSharedPin"
+
+const getSegmentAxis = (start: Point, end: Point) => {
+  if (nearlyEqual(start.x, end.x)) return "y" as const
+  if (nearlyEqual(start.y, end.y)) return "x" as const
+  return null
+}
+
+const getPathFromSharedPin = ({
+  trace,
+  sharedPinId,
+}: {
+  trace: SolvedTracePath
+  sharedPinId: PinId
+}) => {
+  const tracePath = simplifyPath(trace.tracePath)
+  if (trace.pins[0]?.pinId === sharedPinId) return tracePath
+  return tracePath.reverse()
+}
+
+const traceCanLoseSharedPrefix = ({
+  trace,
+  sharedPrefix,
+  netLabelPlacements,
+}: {
+  trace: SolvedTracePath
+  sharedPrefix: Point[]
+  netLabelPlacements: NetLabelPlacement[]
+}) => {
+  return !netLabelPlacements.some(
+    (label) =>
+      label.mspConnectionPairIds.includes(trace.mspPairId) &&
+      tracePathContainsPoint(sharedPrefix, label.anchorPoint),
+  )
+}
+
+const getTraceWithoutSharedPrefix = ({
+  trace,
+  pathFromSharedPin,
+  sharedPinId,
+  branchPoint,
+}: {
+  trace: SolvedTracePath
+  pathFromSharedPin: Point[]
+  sharedPinId: PinId
+  branchPoint: Point
+}) => {
+  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 }
+}
+
+export const collapseRedundantSharedEndpointStubs = ({
+  traces,
+  netLabelPlacements,
+  netLabelConnectorTraceIds,
+  multiPinNetPinIds,
+}: {
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+  netLabelConnectorTraceIds: ReadonlySet<MspConnectionPairId>
+  multiPinNetPinIds: ReadonlySet<PinId>
+}) => {
+  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 = getSegmentAxis(firstPath[0]!, firstPath[1]!)
+      const secondDepartureAxis = getSegmentAxis(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 (
+        !pointsEqual(firstPath[1]!, secondPath[1]!) &&
+        Math.sign(firstDepartureDirection) ===
+          Math.sign(secondDepartureDirection)
+      ) {
+        let traceIndexToCollapse = secondIndex
+        let traceToCollapse = secondTrace
+        let pathToCollapse = secondPath
+        if (
+          Math.abs(firstDepartureDirection) < Math.abs(secondDepartureDirection)
+        ) {
+          traceIndexToCollapse = firstIndex
+          traceToCollapse = firstTrace
+          pathToCollapse = firstPath
+        }
+        const branchPoint = pathToCollapse[1]!
+        if (
+          !traceCanLoseSharedPrefix({
+            trace: traceToCollapse,
+            sharedPrefix: [pathToCollapse[0]!, branchPoint],
+            netLabelPlacements,
+          })
+        ) {
+          if (traceIndexToCollapse === firstIndex) {
+            traceIndexToCollapse = secondIndex
+            traceToCollapse = secondTrace
+            pathToCollapse = secondPath
+          } else {
+            traceIndexToCollapse = firstIndex
+            traceToCollapse = firstTrace
+            pathToCollapse = firstPath
+          }
+        }
+        if (
+          !traceCanLoseSharedPrefix({
+            trace: traceToCollapse,
+            sharedPrefix: [pathToCollapse[0]!, branchPoint],
+            netLabelPlacements,
+          })
+        ) {
+          continue
+        }
+        const collapsedTrace = getTraceWithoutSharedPrefix({
+          trace: traceToCollapse,
+          pathFromSharedPin: pathToCollapse,
+          sharedPinId: sharedPin.pinId,
+          branchPoint,
+        })
+        if (!collapsedTrace) continue
+        outputTraces[traceIndexToCollapse] = collapsedTrace
+        break
+      }
+      if (firstPath.length < 3 || secondPath.length < 3) continue
+      if (!pointsEqual(firstPath[1]!, secondPath[1]!)) continue
+
+      const railAxis = getSegmentAxis(firstPath[1]!, firstPath[2]!)
+      const secondRailAxis = getSegmentAxis(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
+}

package/lib/solvers/SameNetJunctionAlignmentSolver/collapseSameNetCycles.ts

@@ -11,7 +11,7 @@ import {
   pointsEqual,
 } from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
 import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
-import { getSharedPin } from "./alignSameNetJunctions"
+import { getSharedPin } from "./getSharedPin"
 import {
   pathEntersAnyNetLabel,
   pathIntersectsAnyNetLabel,

package/lib/solvers/SameNetJunctionAlignmentSolver/getSharedPin.ts

@@ -0,0 +1,13 @@
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputPin } from "lib/types/InputProblem"
+
+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
+}

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver.ts

@@ -11,6 +11,7 @@ import { SchematicTraceSingleLineSolver2 } from "./SchematicTraceSingleLineSolve
 import type { Guideline } from "../GuidelinesSolver/GuidelinesSolver"
 import { visualizeGuidelines } from "../GuidelinesSolver/visualizeGuidelines"
 import type { Point } from "@tscircuit/math-utils"
+import { getPinDirectionCandidates } from "./SchematicTraceSingleLineSolver/getPinDirection"
 
 const shouldPreferExteriorDetours = ({
   connectionPair,
@@ -62,6 +63,7 @@ export class SchematicTraceLinesSolver extends BaseSolver {
   chipMap: Record<string, InputChip>
 
   currentConnectionPair: MspConnectionPair | null = null
+  retryingWithoutNetLabelClearance = false
 
   solvedTracePaths: Array<SolvedTracePath> = []
   failedConnectionPairs: Array<MspConnectionPair & { error?: string }> = []
@@ -101,6 +103,7 @@ export class SchematicTraceLinesSolver extends BaseSolver {
     if (this.activeSubSolver?.solved) {
       this.solvedTracePaths.push({
         ...this.currentConnectionPair!,
+        pins: this.activeSubSolver.pins,
         tracePath: this.activeSubSolver!.solvedTracePath!,
         mspConnectionPairIds: [this.currentConnectionPair!.mspPairId],
         pinIds: [
@@ -110,8 +113,33 @@ export class SchematicTraceLinesSolver extends BaseSolver {
       })
       this.activeSubSolver = null
       this.currentConnectionPair = null
+      this.retryingWithoutNetLabelClearance = false
     }
     if (this.activeSubSolver?.failed) {
+      if (
+        this.currentConnectionPair &&
+        !this.retryingWithoutNetLabelClearance &&
+        this.activeSubSolver.hasAmbiguousPinDirections
+      ) {
+        const connectionPair = this.currentConnectionPair
+        this.retryingWithoutNetLabelClearance = true
+        this.activeSubSolver = new SchematicTraceSingleLineSolver2({
+          inputProblem: this.inputProblem,
+          pins: connectionPair.pins.map((pin) => ({
+            ...pin,
+          })) as MspConnectionPair["pins"],
+          connectionPair,
+          chipMap: this.chipMap,
+          preferExteriorDetours: shouldPreferExteriorDetours({
+            connectionPair,
+            allConnectionPairs: this.mspConnectionPairs,
+            inputProblem: this.inputProblem,
+          }),
+          reserveNetLabelClearance: false,
+        })
+        return
+      }
+
       // Record the failure for this connection and continue to the next pair
       if (this.currentConnectionPair) {
         this.failedConnectionPairs.push({
@@ -121,6 +149,7 @@ export class SchematicTraceLinesSolver extends BaseSolver {
       }
       this.activeSubSolver = null
       this.currentConnectionPair = null
+      this.retryingWithoutNetLabelClearance = false
       // Do not fail the whole solver; proceed to schedule the next pair
     }
 
@@ -137,8 +166,22 @@ export class SchematicTraceLinesSolver extends BaseSolver {
     }
 
     this.currentConnectionPair = connectionPair
-
-    const { pins } = connectionPair
+    this.retryingWithoutNetLabelClearance = false
+
+    // Corner pins can legitimately face either adjacent edge. Keep their
+    // inferred direction local to this route so solving one branch cannot
+    // constrain a later branch that shares the same corner pin. Pins with one
+    // geometric direction retain the established shared representation.
+    const hasAmbiguousCornerPin = connectionPair.pins.some((pin) => {
+      if (pin._facingDirection) return false
+      const chip = this.chipMap[pin.chipId]
+      return chip && getPinDirectionCandidates(pin, chip).length > 1
+    })
+    const pins = hasAmbiguousCornerPin
+      ? (connectionPair.pins.map((pin) => ({
+          ...pin,
+        })) as MspConnectionPair["pins"])
+      : connectionPair.pins
 
     this.activeSubSolver = new SchematicTraceSingleLineSolver2({
       inputProblem: this.inputProblem,

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection.ts

@@ -1,9 +1,12 @@
 import type { InputChip, InputPin } from "lib/types/InputProblem"
 
-export const getPinDirection = (
+export type PinDirection = "x+" | "x-" | "y+" | "y-"
+
+export const getPinDirectionCandidates = (
   pin: InputPin,
   chip: InputChip,
-): "x+" | "x-" | "y+" | "y-" => {
+  connectedPin?: InputPin,
+): PinDirection[] => {
   // Determine what edge the pin lies on
   const { x, y } = pin
   const { center, width, height } = chip
@@ -26,17 +29,62 @@ export const getPinDirection = (
     xMinusDistance,
   )
 
-  if (minDistance === yPlusDistance) {
-    return "y+"
-  }
+  // Preserve the established single-direction result as the primary choice.
+  // Candidate routing may treat nearly equal edge distances as an ambiguous
+  // corner, but context-free callers (such as visualization) should not change
+  // direction solely because the candidate comparison uses a tolerance.
+  const primaryDirection: PinDirection =
+    minDistance === yPlusDistance
+      ? "y+"
+      : minDistance === yMinusDistance
+        ? "y-"
+        : minDistance === xPlusDistance
+          ? "x+"
+          : "x-"
+
+  const matchingDirections = [
+    { direction: "y+" as const, distance: yPlusDistance },
+    { direction: "y-" as const, distance: yMinusDistance },
+    { direction: "x+" as const, distance: xPlusDistance },
+    { direction: "x-" as const, distance: xMinusDistance },
+  ]
+    .filter(({ distance }) => Math.abs(distance - minDistance) <= 1e-9)
+    .map(({ direction }) => direction)
+
+  const closestDirections = [
+    primaryDirection,
+    ...matchingDirections.filter((direction) => direction !== primaryDirection),
+  ]
 
-  if (minDistance === yMinusDistance) {
-    return "y-"
+  if (!connectedPin || closestDirections.length <= 1) {
+    return closestDirections
   }
 
-  if (minDistance === xPlusDistance) {
-    return "x+"
+  const xDistance = connectedPin.x - pin.x
+  const yDistance = connectedPin.y - pin.y
+  const directionTowardConnectedPin: PinDirection =
+    Math.abs(xDistance) >= Math.abs(yDistance)
+      ? xDistance >= 0
+        ? "x+"
+        : "x-"
+      : yDistance >= 0
+        ? "y+"
+        : "y-"
+
+  if (!closestDirections.includes(directionTowardConnectedPin)) {
+    return closestDirections
   }
 
-  return "x-"
+  return [
+    directionTowardConnectedPin,
+    ...closestDirections.filter(
+      (direction) => direction !== directionTowardConnectedPin,
+    ),
+  ]
 }
+
+export const getPinDirection = (
+  pin: InputPin,
+  chip: InputChip,
+  connectedPin?: InputPin,
+): PinDirection => getPinDirectionCandidates(pin, chip, connectedPin)[0]!