@tscircuit/schematic-trace-solver 0.0.115 → 0.0.117

package/lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts

@@ -0,0 +1,223 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { isPathCollidingWithObstacles } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+import {
+  getVisibleTraceLength,
+  getVisibleTraceSegmentCount,
+  isHorizontal,
+  nearlyEqual,
+} from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
+import type { InputPin, InputProblem } from "lib/types/InputProblem"
+import { doesPathCoincideWithTraces } from "lib/utils/doesPathCoincideWithTraces"
+import { pathIntersectsAnyNetLabel } from "./pathIntersectsAnyNetLabel"
+
+interface AlignSameNetJunctionsInput {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}
+
+interface HorizontalSegment {
+  start: Point
+  end: Point
+}
+
+const MAX_ALIGNED_LOAD_PIN_OFFSET = 0.2
+
+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,
+}: {
+  trace: SolvedTracePath
+  sharedPin: InputPin
+}) => trace.pins.find((pin) => pin.pinId !== sharedPin.pinId) ?? null
+
+const getLongestHorizontalSegment = (
+  trace: SolvedTracePath,
+): HorizontalSegment | null => {
+  let longest: HorizontalSegment | null = null
+  for (let index = 0; index < trace.tracePath.length - 1; index++) {
+    const start = trace.tracePath[index]!
+    const end = trace.tracePath[index + 1]!
+    if (!isHorizontal(start, end)) continue
+    if (
+      !longest ||
+      Math.abs(end.x - start.x) > Math.abs(longest.end.x - longest.start.x)
+    ) {
+      longest = { start, end }
+    }
+  }
+  return longest
+}
+
+const getJunctionPoint = ({
+  segment,
+  sharedPin,
+}: {
+  segment: HorizontalSegment
+  sharedPin: Point
+}) => {
+  const startDistance = Math.abs(segment.start.x - sharedPin.x)
+  const endDistance = Math.abs(segment.end.x - sharedPin.x)
+  if (startDistance <= endDistance) return segment.start
+  return segment.end
+}
+
+const railIsOnFacingSide = ({
+  railY,
+  pin,
+}: {
+  railY: number
+  pin: InputPin
+}) => {
+  if (pin._facingDirection === "y+") return railY > pin.y
+  return false
+}
+
+const getAlignedBranchPath = ({
+  donorTrace,
+  branchTrace,
+}: {
+  donorTrace: SolvedTracePath
+  branchTrace: SolvedTracePath
+}): Point[] | null => {
+  const sharedPin = getSharedPin({ donorTrace, branchTrace })
+  if (!sharedPin) return null
+  const donorOtherPin = getOtherPin({ trace: donorTrace, sharedPin })
+  if (!donorOtherPin) return null
+  const otherPin = getOtherPin({ trace: branchTrace, sharedPin })
+  if (!otherPin) return null
+  if (Math.abs(sharedPin.y - otherPin.y) > MAX_ALIGNED_LOAD_PIN_OFFSET) {
+    return null
+  }
+
+  const donorRail = getLongestHorizontalSegment(donorTrace)
+  if (!donorRail) return null
+  const branchRail = getLongestHorizontalSegment(branchTrace)
+  if (branchRail && nearlyEqual(branchRail.start.y, donorRail.start.y)) {
+    return null
+  }
+  if (!railIsOnFacingSide({ railY: donorRail.start.y, pin: otherPin })) {
+    return null
+  }
+
+  const junction = getJunctionPoint({ segment: donorRail, sharedPin })
+  const extendsDonorRail =
+    (donorOtherPin.x < junction.x && otherPin.x > junction.x) ||
+    (donorOtherPin.x > junction.x && otherPin.x < junction.x)
+  if (!extendsDonorRail) return null
+
+  const sharedToOther = simplifyPath([
+    { x: sharedPin.x, y: sharedPin.y },
+    { x: junction.x, y: sharedPin.y },
+    { x: junction.x, y: junction.y },
+    { x: otherPin.x, y: junction.y },
+    { x: otherPin.x, y: otherPin.y },
+  ])
+
+  if (branchTrace.pins[0].pinId === sharedPin.pinId) return sharedToOther
+  return [...sharedToOther].reverse()
+}
+
+const candidateIsClear = ({
+  candidateTrace,
+  traces,
+  inputProblem,
+  netLabelPlacements,
+}: {
+  candidateTrace: SolvedTracePath
+  traces: SolvedTracePath[]
+  inputProblem: InputProblem
+  netLabelPlacements: NetLabelPlacement[]
+}) => {
+  const obstacles = getObstacleRects(inputProblem)
+  if (isPathCollidingWithObstacles(candidateTrace.tracePath, obstacles)) {
+    return false
+  }
+
+  const otherNetTraces = traces.filter(
+    (trace) => trace.globalConnNetId !== candidateTrace.globalConnNetId,
+  )
+  if (doesPathCoincideWithTraces(candidateTrace.tracePath, otherNetTraces)) {
+    return false
+  }
+
+  return !pathIntersectsAnyNetLabel({
+    path: candidateTrace.tracePath,
+    netLabelPlacements,
+  })
+}
+
+export const alignSameNetJunctions = ({
+  inputProblem,
+  traces,
+  netLabelPlacements,
+}: AlignSameNetJunctionsInput) => {
+  let outputTraces = [...traces]
+  const alignedBranchTraceIds = new Set<string>()
+  let alignedJunctionCount = 0
+
+  // Reuse each aligned branch as the rail for the next load in the chain.
+  for (const donorTraceId of traces.map((trace) => trace.mspPairId)) {
+    const donorTrace = outputTraces.find(
+      (trace) => trace.mspPairId === donorTraceId,
+    )!
+    for (const branchTrace of outputTraces) {
+      if (alignedBranchTraceIds.has(branchTrace.mspPairId)) continue
+      if (donorTrace.mspPairId === branchTrace.mspPairId) continue
+      if (donorTrace.globalConnNetId !== branchTrace.globalConnNetId) continue
+
+      const candidatePath = getAlignedBranchPath({ donorTrace, branchTrace })
+      if (!candidatePath) continue
+      const candidateTrace = { ...branchTrace, tracePath: candidatePath }
+      const originalPair = [donorTrace, branchTrace]
+      const candidatePair = [donorTrace, candidateTrace]
+      const removesVisibleSegment =
+        getVisibleTraceSegmentCount(candidatePair) <
+        getVisibleTraceSegmentCount(originalPair)
+      const shortensVisibleTrace =
+        getVisibleTraceLength(candidatePair) <
+          getVisibleTraceLength(originalPair) &&
+        !nearlyEqual(
+          getVisibleTraceLength(candidatePair),
+          getVisibleTraceLength(originalPair),
+        )
+      if (!removesVisibleSegment && !shortensVisibleTrace) {
+        continue
+      }
+      if (
+        !candidateIsClear({
+          candidateTrace,
+          traces: outputTraces,
+          inputProblem,
+          netLabelPlacements,
+        })
+      ) {
+        continue
+      }
+
+      outputTraces = outputTraces.map((trace) => {
+        if (trace.mspPairId === branchTrace.mspPairId) return candidateTrace
+        return trace
+      })
+      alignedBranchTraceIds.add(branchTrace.mspPairId)
+      alignedJunctionCount++
+    }
+  }
+
+  return { traces: outputTraces, alignedJunctionCount }
+}

package/lib/solvers/SameNetJunctionAlignmentSolver/pathIntersectsAnyNetLabel.ts

@@ -0,0 +1,22 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { segmentIntersectsRect } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions"
+import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+
+export const pathIntersectsAnyNetLabel = ({
+  path,
+  netLabelPlacements,
+}: {
+  path: Point[]
+  netLabelPlacements: NetLabelPlacement[]
+}) => {
+  for (const label of netLabelPlacements) {
+    const labelBounds = getRectBounds(label.center, label.width, label.height)
+    for (let index = 0; index < path.length - 1; index++) {
+      if (segmentIntersectsRect(path[index], path[index + 1], labelBounds)) {
+        return true
+      }
+    }
+  }
+  return false
+}

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -28,6 +28,7 @@ import { TraceAnchoredNetLabelOverlapSolver } from "../TraceAnchoredNetLabelOver
 import { NetLabelTraceCollisionSolver } from "../NetLabelTraceCollisionSolver/NetLabelTraceCollisionSolver"
 import { NetLabelNetLabelCollisionSolver } from "../NetLabelNetLabelCollisionSolver/NetLabelNetLabelCollisionSolver"
 import { UnroutedTraceRecoverySolver } from "../UnroutedTraceRecoverySolver/UnroutedTraceRecoverySolver"
+import { SameNetJunctionAlignmentSolver } from "../SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -86,6 +87,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   netLabelTraceCollisionSolver?: NetLabelTraceCollisionSolver
   traceCleanupSolver2?: TraceCleanupSolver
   netLabelNetLabelCollisionSolver?: NetLabelNetLabelCollisionSolver
+  sameNetJunctionAlignmentSolver?: SameNetJunctionAlignmentSolver
 
   startTimeOfPhase: Record<string, number>
   endTimeOfPhase: Record<string, number>
@@ -402,6 +404,21 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         },
       ],
     ),
+    definePipelineStep(
+      "sameNetJunctionAlignmentSolver",
+      SameNetJunctionAlignmentSolver,
+      (instance) => {
+        const collisionOutput =
+          instance.netLabelNetLabelCollisionSolver!.getOutput()
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: instance.netLabelNetLabelCollisionSolver!.traces,
+            netLabelPlacements: collisionOutput.netLabelPlacements,
+          },
+        ]
+      },
+    ),
   ]
 
   constructor(inputProblem: InputProblem, opts?: Options) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.115",
+  "version": "0.0.117",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/site/bug-reports/bug-report-20260730T061837Z.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/bug-reports/bug-report-20260730T061837Z/bug-report-20260730T061837Z.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />

package/site/bug-reports/bug-report-20260731T052229Z.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/bug-reports/bug-report-20260731T052229Z/bug-report-20260731T052229Z.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />