@tscircuit/schematic-trace-solver 0.0.174 → 0.0.176

package/lib/solvers/SameNetJunctionAlignmentSolver/findNearestSharedPinExitRail.ts

@@ -0,0 +1,140 @@
+import type { Point } from "@tscircuit/math-utils"
+import { tracePathContainsPoint } from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
+import {
+  isHorizontal,
+  isVertical,
+} from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
+import type { InputPin } from "lib/types/InputProblem"
+import { dir } from "lib/utils/dir"
+
+export type Axis = "x" | "y"
+
+export interface AxisAlignedSegment {
+  start: Point
+  end: Point
+  axis: Axis
+  coordinate: number
+}
+
+export interface SharedPinExitRail {
+  segment: AxisAlignedSegment
+  sharedPinExit: Point
+}
+
+export const getPinFacingAxis = (pin: InputPin): Axis | null => {
+  if (!pin._facingDirection) return null
+  return dir(pin._facingDirection).x === 0 ? "y" : "x"
+}
+
+export const isCoordinateOnPinFacingSide = ({
+  coordinate,
+  axis,
+  pin,
+}: {
+  coordinate: number
+  axis: Axis
+  pin: InputPin
+}) => {
+  if (!pin._facingDirection) return false
+  const facingVector = dir(pin._facingDirection)
+  return (coordinate - pin[axis]) * facingVector[axis] > 0
+}
+
+const getSegmentAxis = (start: Point, end: Point): Axis | null => {
+  if (isHorizontal(start, end)) return "x"
+  if (isVertical(start, end)) return "y"
+  return null
+}
+
+const getAxisAlignedSegments = (path: Point[]): AxisAlignedSegment[] => {
+  const segments: AxisAlignedSegment[] = []
+  for (let index = 0; index < path.length - 1; index++) {
+    const start = path[index]!
+    const end = path[index + 1]!
+    const axis = getSegmentAxis(start, end)
+    if (!axis) continue
+    const coordinateAxis = axis === "x" ? "y" : "x"
+    segments.push({ start, end, axis, coordinate: start[coordinateAxis] })
+  }
+  return segments
+}
+
+const getPinExitPoint = ({
+  pin,
+  departureAxis,
+  railCoordinate,
+}: {
+  pin: InputPin
+  departureAxis: Axis
+  railCoordinate: number
+}): Point =>
+  departureAxis === "x"
+    ? { x: railCoordinate, y: pin.y }
+    : { x: pin.x, y: railCoordinate }
+
+/**
+ * Finds the nearest existing donor rail that joins two same-side pin exits
+ * and is already reached by the branch leaving the shared pin.
+ */
+export const findNearestSharedPinExitRail = ({
+  donorPath,
+  branchDepartureSegment,
+  sharedPin,
+  adjacentPin,
+}: {
+  donorPath: Point[]
+  branchDepartureSegment: [Point, Point]
+  sharedPin: InputPin
+  adjacentPin: InputPin
+}): SharedPinExitRail | null => {
+  const departureAxis = getPinFacingAxis(sharedPin)
+  if (!departureAxis) return null
+  const railAxis = departureAxis === "x" ? "y" : "x"
+
+  const branchDeparture = getAxisAlignedSegments(branchDepartureSegment)[0]
+  if (!branchDeparture || branchDeparture.axis !== departureAxis) return null
+
+  let nearestRail: SharedPinExitRail | null = null
+  let nearestDistance = Number.POSITIVE_INFINITY
+
+  for (const segment of getAxisAlignedSegments(donorPath)) {
+    if (segment.axis !== railAxis) continue
+    if (
+      !isCoordinateOnPinFacingSide({
+        coordinate: segment.coordinate,
+        axis: departureAxis,
+        pin: sharedPin,
+      })
+    ) {
+      continue
+    }
+
+    const sharedPinExit = getPinExitPoint({
+      pin: sharedPin,
+      departureAxis,
+      railCoordinate: segment.coordinate,
+    })
+    const adjacentPinExit = getPinExitPoint({
+      pin: adjacentPin,
+      departureAxis,
+      railCoordinate: segment.coordinate,
+    })
+    if (
+      !tracePathContainsPoint([segment.start, segment.end], sharedPinExit) ||
+      !tracePathContainsPoint([segment.start, segment.end], adjacentPinExit) ||
+      !tracePathContainsPoint(
+        [branchDeparture.start, branchDeparture.end],
+        sharedPinExit,
+      )
+    ) {
+      continue
+    }
+
+    const distance = Math.abs(segment.coordinate - sharedPin[departureAxis])
+    if (distance >= nearestDistance) continue
+    nearestRail = { segment, sharedPinExit }
+    nearestDistance = distance
+  }
+
+  return nearestRail
+}

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -385,11 +385,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
           inputTracePaths: instance.availableNetOrientationSolver!.traces,
           globalConnMap: instance.mspConnectionPairSolver!.globalConnMap,
           traceIdsToShift: new Set(
-            instance
-              .availableNetOrientationSolver!.traces.filter((trace) =>
-                trace.mspPairId.startsWith("available-net-orientation-"),
-              )
-              .map((trace) => trace.mspPairId),
+            instance.availableNetOrientationSolver!.netLabelConnectorTraceIds,
           ),
         },
       ],
@@ -571,6 +567,8 @@ export class SchematicTracePipelineSolver extends BaseSolver {
             inputProblem: instance.inputProblem,
             traces: instance.netLabelNetLabelCollisionSolver!.traces,
             netLabelPlacements: collisionOutput.netLabelPlacements,
+            netLabelConnectorTraceIds:
+              instance.availableNetOrientationSolver!.netLabelConnectorTraceIds,
           },
         ]
       },
@@ -581,11 +579,20 @@ export class SchematicTracePipelineSolver extends BaseSolver {
       (instance) => {
         const junctionOutput =
           instance.sameNetJunctionAlignmentSolver!.getOutput()
+        const completedReroutes = [
+          ...instance.traceLabelOverlapAvoidanceSolver!.getOutput()
+            .completedReroutes,
+          ...instance.preAlignmentNetLabelTraceCollisionSolver!.getOutput()
+            .completedReroutes,
+          ...instance.netLabelTraceCollisionSolver!.getOutput()
+            .completedReroutes,
+        ]
         return [
           {
             inputProblem: instance.inputProblem,
             traces: junctionOutput.traces,
             netLabelPlacements: junctionOutput.netLabelPlacements,
+            completedReroutes,
           },
         ]
       },

package/lib/utils/doesPathCoincideWithTraces.ts

@@ -22,6 +22,19 @@ export const SCHEMATIC_TRACE_MIN_VISUAL_CENTERLINE_CLEARANCE =
 export const doesPathCoincideWithTraces = (
   path: Point[],
   traces: SolvedTracePath[],
+): boolean =>
+  doesPathCoincideWithPaths(
+    path,
+    traces.map((trace) => trace.tracePath),
+  )
+
+/**
+ * Path-only form for rendered wire geometry that is not represented by a
+ * SolvedTracePath, such as inline-label terminal stubs.
+ */
+export const doesPathCoincideWithPaths = (
+  path: Point[],
+  otherPaths: Point[][],
 ): boolean => {
   const rangesOverlap1D = (a1: number, a2: number, b1: number, b2: number) =>
     Math.min(Math.max(a1, a2), Math.max(b1, b2)) -
@@ -39,10 +52,10 @@ export const doesPathCoincideWithTraces = (
     const crossAxis = isVertical ? "x" : "y"
     const alongAxis = isVertical ? "y" : "x"
 
-    for (const trace of traces) {
-      for (let j = 0; j < trace.tracePath.length - 1; j++) {
-        const traceSegStart = trace.tracePath[j]!
-        const traceSegEnd = trace.tracePath[j + 1]!
+    for (const otherPath of otherPaths) {
+      for (let j = 0; j < otherPath.length - 1; j++) {
+        const traceSegStart = otherPath[j]!
+        const traceSegEnd = otherPath[j + 1]!
 
         const isParallel =
           Math.abs(traceSegStart[crossAxis] - traceSegEnd[crossAxis]) <

package/lib/utils/pathIntersectsRenderedLabel.ts

@@ -0,0 +1,33 @@
+import {
+  doesSegmentIntersectRect,
+  getBoundFromCenteredRect,
+  type Point,
+} from "@tscircuit/math-utils"
+import type { InlineNetLabelPlacement } from "lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+
+/** Returns whether a path crosses the rendered text bounds of a net label. */
+export const pathIntersectsRenderedLabel = (
+  path: Point[],
+  label: NetLabelPlacement | InlineNetLabelPlacement,
+) => {
+  let width = label.width
+  let height = label.height
+  if ("axis" in label && label.axis === "y") {
+    width = label.height
+    height = label.width
+  }
+  const bounds = getBoundFromCenteredRect({
+    center: label.center,
+    width,
+    height,
+  })
+  for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
+    if (
+      doesSegmentIntersectRect(path[pathIndex]!, path[pathIndex + 1]!, bounds)
+    ) {
+      return true
+    }
+  }
+  return false
+}

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/tscircuit/schematic-trace-solver.git"
   },
   "main": "dist/index.js",
-  "version": "0.0.174",
+  "version": "0.0.176",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/site/bug-reports/bug-report-20260901T055358Z.page.tsx

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

package/site/bug-reports/bug-report-20260901T064117Z.page.tsx

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

package/site/bug-reports/bug-report-20260901T134241Z.page.tsx

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