@tscircuit/schematic-trace-solver 0.0.154 → 0.0.155

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -653,10 +653,8 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     labelIndex: number,
   ) {
     const direction = dir(orientation)
-    const candidatePoints = this.getTraceAnchorCandidatePoints(
-      label,
-      orientation,
-    ).sort((a, b) => {
+    const { points } = this.getTraceAnchorCandidates(label, orientation)
+    const candidatePoints = points.sort((a, b) => {
       const aAlongDirection = a.x * direction.x + a.y * direction.y
       const bAlongDirection = b.x * direction.x + b.y * direction.y
       return bAlongDirection - aAlongDirection
@@ -687,20 +685,29 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     labelIndex: number,
   ) {
     const direction = dir(orientation)
-    const candidatePoints = this.getTraceAnchorCandidatePoints(
-      label,
-      orientation,
-    ).sort((a, b) => {
+    const preservedColumnAnchor = this.getSearchStartAnchor(label, orientation)
+    const { points, preferNearestBendOnOutwardRow } =
+      this.getTraceAnchorCandidates(label, orientation)
+    const candidatePoints = points.sort((a, b) => {
       const aAlongDirection = a.x * direction.x + a.y * direction.y
       const bAlongDirection = b.x * direction.x + b.y * direction.y
-      return bAlongDirection - aAlongDirection
+      if (!preferNearestBendOnOutwardRow) {
+        return bAlongDirection - aAlongDirection
+      }
+
+      const aPerpendicularDistance = isYOrientation(orientation)
+        ? Math.abs(a.x - preservedColumnAnchor.x)
+        : Math.abs(a.y - preservedColumnAnchor.y)
+      const bPerpendicularDistance = isYOrientation(orientation)
+        ? Math.abs(b.x - preservedColumnAnchor.x)
+        : Math.abs(b.y - preservedColumnAnchor.y)
+      return (
+        bAlongDirection - aAlongDirection ||
+        aPerpendicularDistance - bPerpendicularDistance
+      )
     })
 
     for (const connectorSource of candidatePoints) {
-      const preservedColumnAnchor = this.getSearchStartAnchor(
-        label,
-        orientation,
-      )
       const preservedColumnCandidate = this.createCandidate(
         label,
         {
@@ -762,13 +769,14 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return null
   }
 
-  private getTraceAnchorCandidatePoints(
+  private getTraceAnchorCandidates(
     label: NetLabelPlacement,
     orientation: FacingDirection,
   ) {
     const seen = new Set<string>()
     const points: Point[] = []
-    const connectedTraceIds = new Set(label.mspConnectionPairIds ?? [])
+    const directHostTraceIds = new Set(label.mspConnectionPairIds ?? [])
+    const connectedTraceIds = new Set(directHostTraceIds)
 
     if (isYOrientation(orientation)) {
       const connectedPinIds = new Set<string>()
@@ -818,7 +826,43 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       }
     }
 
-    return points
+    const direction = dir(orientation)
+    const furthestAlong = Math.max(
+      ...points.map((point) => point.x * direction.x + point.y * direction.y),
+    )
+    const furthestRowPoints = points.filter(
+      (point) =>
+        Math.abs(
+          point.x * direction.x + point.y * direction.y - furthestAlong,
+        ) <= EPS,
+    )
+    const directHostPinIds = new Set(
+      [...directHostTraceIds].flatMap(
+        (traceId) => this.traceMap[traceId]?.pinIds ?? [],
+      ),
+    )
+    const adjacentTraces = [...connectedTraceIds].flatMap((traceId) => {
+      if (directHostTraceIds.has(traceId)) return []
+      const trace = this.traceMap[traceId]
+      if (!trace?.pinIds.some((pinId) => directHostPinIds.has(pinId))) return []
+      return [trace]
+    })
+
+    return {
+      points,
+      // Prefer the nearest bend when the outward row is on a trace directly
+      // adjacent to the label's host. Deeper transitive chains keep their
+      // stable trace ordering.
+      preferNearestBendOnOutwardRow: adjacentTraces.some((trace) =>
+        furthestRowPoints.some((point) =>
+          trace.tracePath.some(
+            (tracePoint) =>
+              Math.abs(tracePoint.x - point.x) <= EPS &&
+              Math.abs(tracePoint.y - point.y) <= EPS,
+          ),
+        ),
+      ),
+    }
   }
 
   private sharesVerticalRailWithAny(

package/lib/solvers/TraceCleanupSolver/alignSameNetRails.ts

@@ -13,6 +13,14 @@ interface AlignSameNetRailsInput {
   eligibleTraceIds: ReadonlySet<string>
 }
 
+const getTraceStateKey = (traces: SolvedTracePath[]) =>
+  JSON.stringify(
+    traces.map((trace) => ({
+      mspPairId: trace.mspPairId,
+      tracePath: trace.tracePath,
+    })),
+  )
+
 export const alignSameNetRails = ({
   inputProblem,
   traces,
@@ -24,6 +32,7 @@ export const alignSameNetRails = ({
   alignedTraceCount: number
 } => {
   let outputTraces = [...traces]
+  const seenTraceStates = new Set([getTraceStateKey(outputTraces)])
   const obstacles = getObstacleRects(inputProblem)
   const alignedTraceIds = new Set<string>()
   let alignedRailGroupCount = 0
@@ -38,6 +47,7 @@ export const alignSameNetRails = ({
       eligibleTraceIds,
       inputProblem,
       obstacles,
+      netLabelPlacements,
     )
     let applied: AlignmentCandidate | null = null
 
@@ -53,9 +63,16 @@ export const alignSameNetRails = ({
     }
     if (!applied) break
 
+    const candidateStateKey = getTraceStateKey(applied.traces)
+    // A rail can be eligible from both endpoint components. When that creates
+    // a cycle, restore the first-seen state instead of making the final layout
+    // depend on the maximum-pass parity.
+    const repeatsSeenState = seenTraceStates.has(candidateStateKey)
+    if (!repeatsSeenState) seenTraceStates.add(candidateStateKey)
     outputTraces = applied.traces
     alignedRailGroupCount++
     for (const traceId of applied.changedTraceIds) alignedTraceIds.add(traceId)
+    if (repeatsSeenState) break
   }
 
   return {

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/evaluateRailGroup.ts

@@ -9,6 +9,7 @@ import {
 } from "lib/utils/doesPathCoincideWithTraces"
 import { getDistinctCoordinates, pointsEqual } from "./geometry"
 import { getRailAlignmentFallbackCoordinates } from "./getRailAlignmentFallbackCoordinates"
+import { getFixedLabelCoordinate } from "./getFixedLabelCoordinate"
 import { moveRailSegments } from "./moveRailSegments"
 import { preservesLabelAnchors } from "./preservesLabelAnchors"
 import {
@@ -50,6 +51,11 @@ export const evaluateRailGroup = ({
   const originalCoordinates = getDistinctCoordinates(
     group.map((segment) => segment.coordinate),
   )
+  const fixedLabelCoordinate = getFixedLabelCoordinate(
+    group,
+    netLabelPlacements,
+    traces,
+  )
   const otherNetTraces = traces.filter(
     (trace) => trace.globalConnNetId !== group[0]!.globalConnNetId,
   )
@@ -59,7 +65,10 @@ export const evaluateRailGroup = ({
       !eligibleTraceIds.has(trace.mspPairId),
   )
 
-  const evaluateCoordinates = (coordinates: number[]) => {
+  const evaluateCoordinates = (
+    coordinates: number[],
+    options?: { coordinateIsFixedByLabel?: boolean },
+  ) => {
     let best: AlignmentCandidate | null = null
     for (const coordinate of coordinates) {
       const candidateMap = new Map<string, SolvedTracePath>()
@@ -104,7 +113,15 @@ export const evaluateRailGroup = ({
         allCandidateTraces,
       )
       if (metrics.otherNetCrossings > baseline.otherNetCrossings) continue
-      if (!isReadabilityImprovement(metrics, baseline)) continue
+      // A fixed label anchor determines the rail coordinate. It may lengthen
+      // endpoint legs, but it must still preserve turns and every safety gate.
+      if (
+        options?.coordinateIsFixedByLabel
+          ? metrics.turnCount > baseline.turnCount
+          : !isReadabilityImprovement(metrics, baseline)
+      ) {
+        continue
+      }
 
       const score: AlignmentScore = {
         ...metrics,
@@ -124,16 +141,27 @@ export const evaluateRailGroup = ({
         .map((trace) => trace.mspPairId)
       if (changedTraceIds.length === 0) continue
 
-      const candidate = { traces: allCandidateTraces, changedTraceIds, score }
+      const candidate = {
+        traces: allCandidateTraces,
+        changedTraceIds,
+        score,
+      }
       if (!best || scoreIsBetter(candidate.score, best.score)) best = candidate
     }
 
     return best
   }
 
-  const originalCandidate = evaluateCoordinates(originalCoordinates)
+  const originalCandidate = evaluateCoordinates(
+    fixedLabelCoordinate === null
+      ? originalCoordinates
+      : [fixedLabelCoordinate],
+    { coordinateIsFixedByLabel: fixedLabelCoordinate !== null },
+  )
   if (originalCandidate) return originalCandidate
 
+  if (fixedLabelCoordinate !== null) return null
+
   return evaluateCoordinates(
     getRailAlignmentFallbackCoordinates({
       group,

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/getComponentSideRailSegments.ts

@@ -1,3 +1,5 @@
+import { distance } from "@tscircuit/math-utils"
+import { DEFAULT_MAX_MSP_PAIR_DISTANCE } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import { getPinDirection } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection"
 import type { InputChip } from "lib/types/InputProblem"
@@ -80,12 +82,22 @@ const railIsOutsideComponent = (
   }
 }
 
-/** Associates each movable internal rail with the nearest component endpoint. */
+/**
+ * Associates each movable rail with its nearest endpoint. Label-anchored group
+ * discovery may opt into equally-near endpoints for local connections.
+ */
 export const getComponentSideRailSegments = (
   trace: SolvedTracePath,
   chipMap: Map<string, InputChip>,
+  options?: {
+    includeTiedEndpointAssociations?: boolean
+    maxMspPairDistance?: number
+  },
 ): RailSegment[] => {
   const segments: RailSegment[] = []
+  const isLocalConnection =
+    distance(trace.pins[0]!, trace.pins[1]!) <=
+    (options?.maxMspPairDistance ?? DEFAULT_MAX_MSP_PAIR_DISTANCE)
 
   for (const segment of getMovableRailSegments(trace)) {
     const associations = trace.pins.flatMap((pin, pinIndex) => {
@@ -111,10 +123,21 @@ export const getComponentSideRailSegments = (
     })
 
     associations.sort((a, b) => a.distanceFromEndpoint - b.distanceFromEndpoint)
-    const association = associations[0]
-    if (!association) continue
-
-    segments.push({ ...segment, ...association })
+    const minimumDistance = associations[0]?.distanceFromEndpoint
+    const nearestAssociationKeys = new Set<string>()
+    for (const association of associations) {
+      if (
+        nearestAssociationKeys.size > 0 &&
+        (!options?.includeTiedEndpointAssociations || !isLocalConnection)
+      ) {
+        break
+      }
+      if (association.distanceFromEndpoint !== minimumDistance) continue
+      const associationKey = `${association.componentId}:${association.componentFacingDirection}`
+      if (nearestAssociationKeys.has(associationKey)) continue
+      nearestAssociationKeys.add(associationKey)
+      segments.push({ ...segment, ...association })
+    }
   }
 
   return segments

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/getFixedLabelCoordinate.ts

@@ -0,0 +1,114 @@
+import { distance } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { tracePathContainsPoint } from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { getDistinctCoordinates, RAIL_ALIGNMENT_EPSILON } from "./geometry"
+import type { RailSegment } from "./types"
+
+const getTransitivelyConnectedTraceIds = (
+  group: RailSegment[],
+  traces: SolvedTracePath[],
+) => {
+  const groupNetId = group[0]!.globalConnNetId
+  const sameNetTraces = traces.filter(
+    (trace) => trace.globalConnNetId === groupNetId,
+  )
+  const connectedTraceIds = new Set(group.map((segment) => segment.traceId))
+  const connectedPinIds = new Set(
+    sameNetTraces
+      .filter((trace) => connectedTraceIds.has(trace.mspPairId))
+      .flatMap((trace) => trace.pinIds),
+  )
+
+  for (let changed = true; changed; ) {
+    changed = false
+    for (const trace of sameNetTraces) {
+      if (connectedTraceIds.has(trace.mspPairId)) continue
+      if (!trace.pinIds.some((pinId) => connectedPinIds.has(pinId))) continue
+
+      connectedTraceIds.add(trace.mspPairId)
+      for (const pinId of trace.pinIds) connectedPinIds.add(pinId)
+      changed = true
+    }
+  }
+
+  return connectedTraceIds
+}
+
+const getLabelsLinkedToRailGroup = (
+  group: RailSegment[],
+  netLabelPlacements: NetLabelPlacement[],
+  traces: SolvedTracePath[],
+) => {
+  const traceIds = getTransitivelyConnectedTraceIds(group, traces)
+  return netLabelPlacements.filter((label) =>
+    label.mspConnectionPairIds.some((traceId) => traceIds.has(traceId)),
+  )
+}
+
+export const getFixedLabelCoordinate = (
+  group: RailSegment[],
+  netLabelPlacements: NetLabelPlacement[],
+  traces: SolvedTracePath[],
+) => {
+  const traceMap = new Map(traces.map((trace) => [trace.mspPairId, trace]))
+  const groupTraceIds = new Set(group.map((segment) => segment.traceId))
+  const groupHasOnlySingleRailTraces = [...groupTraceIds].every(
+    (traceId) => traceMap.get(traceId)?.tracePath.length === 4,
+  )
+  // A fixed label may lengthen the endpoint legs around one movable rail. A
+  // trace with more elbows still has to pass the normal readability scoring.
+  if (!groupHasOnlySingleRailTraces) return null
+
+  const orientation = group[0]!.orientation
+  const linkedLabels = getLabelsLinkedToRailGroup(
+    group,
+    netLabelPlacements,
+    traces,
+  )
+  const anchoringLabels = linkedLabels.filter(
+    (label) =>
+      label.orientation === group[0]!.componentFacingDirection &&
+      label.mspConnectionPairIds.some((traceId) => {
+        const trace = traceMap.get(traceId)
+        return (
+          trace && tracePathContainsPoint(trace.tracePath, label.anchorPoint)
+        )
+      }),
+  )
+  const coordinates = getDistinctCoordinates(
+    anchoringLabels.map((label) =>
+      orientation === "vertical" ? label.anchorPoint.x : label.anchorPoint.y,
+    ),
+  )
+  if (coordinates.length !== 1) return null
+
+  const labelCoordinate = coordinates[0]!
+  const coordinate =
+    group.find(
+      (segment) =>
+        Math.abs(segment.coordinate - labelCoordinate) <=
+        RAIL_ALIGNMENT_EPSILON,
+    )?.coordinate ?? labelCoordinate
+  const labelIsAnchoredToRoutedBackbone = anchoringLabels.some((label) =>
+    label.mspConnectionPairIds.some(
+      (traceId) => (traceMap.get(traceId)?.tracePath.length ?? 0) > 4,
+    ),
+  )
+  // A multi-turn label trace is an intentional routed backbone, so its rail
+  // coordinate may propagate through the local component chain. Labels riding
+  // a single movable rail remain subject to the per-connection locality gate.
+  if (labelIsAnchoredToRoutedBackbone) return coordinate
+
+  // Rail cleanup is local: a label cannot pull a connection farther than the
+  // span of the pins that connection already joins.
+  const coordinateIsLocalToEveryTrace = group.every((segment) => {
+    const trace = traceMap.get(segment.traceId)
+    if (!trace) return false
+    return (
+      Math.abs(segment.coordinate - coordinate) <=
+      distance(trace.pins[0]!, trace.pins[1]!) + RAIL_ALIGNMENT_EPSILON
+    )
+  })
+  return coordinateIsLocalToEveryTrace ? coordinate : null
+}

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/getRailGroups.ts

@@ -3,7 +3,9 @@ import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/Sche
 import { segmentIntersectsRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 import type { ObstacleRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 import type { InputProblem } from "lib/types/InputProblem"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
 import { getComponentSideRailSegments } from "./getComponentSideRailSegments"
+import { getFixedLabelCoordinate } from "./getFixedLabelCoordinate"
 import { nearlyEqual, rangesTouchOrOverlap } from "./geometry"
 import type { RailSegment } from "./types"
 
@@ -66,49 +68,113 @@ export const getRailGroups = (
   eligibleTraceIds: ReadonlySet<string>,
   inputProblem: InputProblem,
   obstacles: ObstacleRect[],
+  netLabelPlacements: NetLabelPlacement[],
 ): RailSegment[][] => {
   const chipMap = new Map(inputProblem.chips.map((chip) => [chip.chipId, chip]))
-  const segments = traces
-    .filter((trace) => eligibleTraceIds.has(trace.mspPairId))
-    .flatMap((trace) => getComponentSideRailSegments(trace, chipMap))
   const traceMap = new Map(traces.map((trace) => [trace.mspPairId, trace]))
-  const visited = new Set<number>()
-  const groups: RailSegment[][] = []
-
-  for (let startIndex = 0; startIndex < segments.length; startIndex++) {
-    if (visited.has(startIndex)) continue
-
-    const start = segments[startIndex]!
-    const queue = [startIndex]
-    const group: RailSegment[] = []
-    visited.add(startIndex)
-
-    for (let queueIndex = 0; queueIndex < queue.length; queueIndex++) {
-      const current = segments[queue[queueIndex]!]!
-      group.push(current)
-
-      for (
-        let candidateIndex = 0;
-        candidateIndex < segments.length;
-        candidateIndex++
-      ) {
-        if (visited.has(candidateIndex)) continue
-        const candidate = segments[candidateIndex]!
-        if (!canJoinRailGroup(start, current, candidate, traceMap, obstacles)) {
-          continue
-        }
+  const eligibleTraces = traces.filter((trace) =>
+    eligibleTraceIds.has(trace.mspPairId),
+  )
+
+  const collectConnectedGroups = (segments: RailSegment[]) => {
+    const visited = new Set<number>()
+    const connectedGroups: RailSegment[][] = []
+
+    for (let startIndex = 0; startIndex < segments.length; startIndex++) {
+      if (visited.has(startIndex)) continue
+
+      const start = segments[startIndex]!
+      const queue = [startIndex]
+      const group: RailSegment[] = []
+      visited.add(startIndex)
+
+      for (let queueIndex = 0; queueIndex < queue.length; queueIndex++) {
+        const current = segments[queue[queueIndex]!]!
+        group.push(current)
 
-        visited.add(candidateIndex)
-        queue.push(candidateIndex)
+        for (
+          let candidateIndex = 0;
+          candidateIndex < segments.length;
+          candidateIndex++
+        ) {
+          if (visited.has(candidateIndex)) continue
+          const candidate = segments[candidateIndex]!
+          if (
+            !canJoinRailGroup(start, current, candidate, traceMap, obstacles)
+          ) {
+            continue
+          }
+
+          visited.add(candidateIndex)
+          queue.push(candidateIndex)
+        }
       }
+
+      connectedGroups.push(group)
     }
 
+    return connectedGroups
+  }
+
+  const groupKey = (group: RailSegment[]) =>
+    [
+      group[0]!.componentId,
+      group[0]!.componentFacingDirection,
+      group[0]!.orientation,
+      ...group
+        .map((segment) => `${segment.traceId}:${segment.segmentIndex}`)
+        .sort(),
+    ].join("|")
+
+  const selectedGroups: RailSegment[][] = []
+  const selectedGroupKeys = new Set<string>()
+  const addEligibleGroup = (
+    group: RailSegment[],
+    options?: { requireFixedLabel?: boolean },
+  ) => {
     const traceCount = new Set(group.map((segment) => segment.traceId)).size
+    if (traceCount < 2) return
+
+    const fixedLabelCoordinate = getFixedLabelCoordinate(
+      group,
+      netLabelPlacements,
+      traces,
+    )
+    if (options?.requireFixedLabel && fixedLabelCoordinate === null) return
+
     const hasDifferentCoordinates = group.some(
       (segment) => !nearlyEqual(segment.coordinate, group[0]!.coordinate),
     )
-    if (traceCount >= 2 && hasDifferentCoordinates) groups.push(group)
+    const hasDifferentFixedLabelCoordinate =
+      fixedLabelCoordinate !== null &&
+      !nearlyEqual(fixedLabelCoordinate, group[0]!.coordinate)
+    if (!hasDifferentCoordinates && !hasDifferentFixedLabelCoordinate) return
+
+    const key = groupKey(group)
+    if (selectedGroupKeys.has(key)) return
+    selectedGroupKeys.add(key)
+    selectedGroups.push(group)
+  }
+
+  const primarySegments = eligibleTraces.flatMap((trace) =>
+    getComponentSideRailSegments(trace, chipMap),
+  )
+  // Preserve the original nearest-endpoint grouping and its ordering.
+  for (const group of collectConnectedGroups(primarySegments)) {
+    addEligibleGroup(group)
+  }
+
+  // Equal-distance endpoint associations can bridge a component chain, but
+  // only a fixed label is allowed to opt that broader group into alignment.
+  const tiedEndpointSegments = eligibleTraces.flatMap((trace) =>
+    getComponentSideRailSegments(trace, chipMap, {
+      includeTiedEndpointAssociations: true,
+      maxMspPairDistance: inputProblem.maxMspPairDistance,
+    }),
+  )
+  for (const group of collectConnectedGroups(tiedEndpointSegments)) {
+    addEligibleGroup(group, { requireFixedLabel: true })
   }
 
-  return groups
+  return selectedGroups
 }

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/moveRailSegments.ts

@@ -1,5 +1,6 @@
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import { simplifyPath } from "../simplifyPath"
+import { nearlyEqual } from "./geometry"
 import type { RailSegment } from "./types"
 
 export const moveRailSegments = (
@@ -9,6 +10,7 @@ export const moveRailSegments = (
 ): SolvedTracePath => {
   const pointsToMove = new Set<number>()
   for (const segment of segments) {
+    if (nearlyEqual(segment.coordinate, coordinate)) continue
     pointsToMove.add(segment.segmentIndex)
     pointsToMove.add(segment.segmentIndex + 1)
   }

package/package.json

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