@tscircuit/schematic-trace-solver 0.0.174 → 0.0.176

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -9,6 +9,7 @@ import {
   getRectBounds,
 } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
 import { tracePathContainsPoint } from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
+import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type {
   ChipId,
@@ -60,6 +61,8 @@ export class AvailableNetOrientationSolver extends BaseSolver {
   inputProblem: InputProblem
   traces: SolvedTracePath[]
   netLabelPlacements: NetLabelPlacement[]
+  /** Exact provenance for connector traces created by this solver. */
+  readonly netLabelConnectorTraceIds = new Set<MspConnectionPairId>()
 
   outputNetLabelPlacements: NetLabelPlacement[]
   queuedLabelIndices: number[] = []
@@ -374,6 +377,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
 
     this.traces.push(connectorTrace)
     this.traceMap[mspPairId] = connectorTrace
+    this.netLabelConnectorTraceIds.add(mspPairId)
   }
 
   private finish() {
@@ -829,7 +833,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
         foundConnectedTrace = false
         for (const trace of Object.values(this.traceMap)) {
           if (connectedTraceIds.has(trace.mspPairId)) continue
-          if (trace.mspPairId.startsWith("available-net-orientation-")) continue
+          if (this.netLabelConnectorTraceIds.has(trace.mspPairId)) continue
           if (trace.globalConnNetId !== label.globalConnNetId) continue
           if (!trace.pinIds.some((pinId) => connectedPinIds.has(pinId)))
             continue

package/lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts

@@ -8,6 +8,7 @@ import { getTraceConnectedPinComponents } from "lib/solvers/SchematicTraceLinesS
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import { getPinDirection } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection"
 import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type { CompletedTraceReroute } from "lib/solvers/TraceElbowTransitionSimplificationSolver/types"
 import type {
   InputDirectConnection,
   InputNetConnection,
@@ -24,6 +25,7 @@ import {
 import { getAnchoredNetLabelRenderedBounds } from "./getAnchoredNetLabelRenderedBounds"
 import { pushAnchoredNetLabelsAwayFromInlineLabels } from "./pushAnchoredNetLabelsAwayFromInlineLabels"
 import { pushInlineTerminalLabelsAwayFromAnchoredLabels } from "./pushInlineTerminalLabelsAwayFromAnchoredLabels"
+import { restoreReroutesAroundSupersededLabels } from "./restoreReroutesAroundSupersededLabels"
 
 export const DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18
 
@@ -95,6 +97,7 @@ interface InlineNetLabelSolverInput {
   inputProblem: InputProblem
   traces: SolvedTracePath[]
   netLabelPlacements: NetLabelPlacement[]
+  completedReroutes?: CompletedTraceReroute[]
 }
 
 export interface InlineNetLabelOutput {
@@ -169,6 +172,7 @@ export class InlineNetLabelSolver extends BaseSolver {
   inputProblem: InputProblem
   traces: SolvedTracePath[]
   inputNetLabelPlacements: NetLabelPlacement[]
+  completedReroutes: CompletedTraceReroute[]
 
   inlineNetLabelPlacements: InlineNetLabelPlacement[] = []
 
@@ -190,6 +194,7 @@ export class InlineNetLabelSolver extends BaseSolver {
     this.inputProblem = input.inputProblem
     this.traces = input.traces
     this.inputNetLabelPlacements = input.netLabelPlacements
+    this.completedReroutes = input.completedReroutes ?? []
     this.globalConnMap = getConnectivityMapsFromInputProblem(
       this.inputProblem,
     ).netConnMap
@@ -235,6 +240,7 @@ export class InlineNetLabelSolver extends BaseSolver {
         inputProblem: this.inputProblem,
         traces: this.traces,
         netLabelPlacements: this.inputNetLabelPlacements,
+        completedReroutes: this.completedReroutes,
       },
     ]
   }
@@ -1066,10 +1072,19 @@ export class InlineNetLabelSolver extends BaseSolver {
       if (blockedGlobalConnNetIds.size === 0) {
         this.inlineNetLabelPlacements = activeInlinePlacements
         this.stats.pushedAnchoredNetLabelCount = pushed.movedLabelCount
-        return {
+        const restored = restoreReroutesAroundSupersededLabels({
+          inputProblem: this.inputProblem,
           traces: pushed.traces,
           netLabelPlacements: pushed.netLabelPlacements,
           inlineNetLabelPlacements: activeInlinePlacements,
+          completedReroutes: this.completedReroutes,
+        })
+        this.stats.restoredSupersededLabelRerouteCount =
+          restored.restoredTraceCount
+        return {
+          traces: restored.traces,
+          netLabelPlacements: pushed.netLabelPlacements,
+          inlineNetLabelPlacements: activeInlinePlacements,
         }
       }
       activeInlinePlacements = activeInlinePlacements.filter(

package/lib/solvers/InlineNetLabelSolver/restoreReroutesAroundSupersededLabels.ts

@@ -0,0 +1,174 @@
+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 { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { isPathCollidingWithObstacles } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import { preservesLabelAnchors } from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/preservesLabelAnchors"
+import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+import { detectTraceLabelOverlap } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap"
+import type { CompletedTraceReroute } from "lib/solvers/TraceElbowTransitionSimplificationSolver/types"
+import type { InputProblem } from "lib/types/InputProblem"
+import {
+  doesPathCoincideWithPaths,
+  doesPathCoincideWithTraces,
+} from "lib/utils/doesPathCoincideWithTraces"
+import { pathIntersectsRenderedLabel } from "lib/utils/pathIntersectsRenderedLabel"
+import type { InlineNetLabelPlacement } from "./InlineNetLabelSolver"
+
+const EPS = 1e-6
+
+const getPathLength = (path: Point[]) =>
+  path.slice(1).reduce((length, point, pointIndex) => {
+    const previousPoint = path[pointIndex]!
+    return (
+      length +
+      Math.abs(point.x - previousPoint.x) +
+      Math.abs(point.y - previousPoint.y)
+    )
+  }, 0)
+
+const pathsEqual = (first: Point[], second: Point[]) =>
+  first.length === second.length &&
+  first.every(
+    (point, index) =>
+      Math.abs(point.x - second[index]!.x) <= EPS &&
+      Math.abs(point.y - second[index]!.y) <= EPS,
+  )
+
+const isStrictlySimpler = (candidate: Point[], current: Point[]) =>
+  candidate.length < current.length &&
+  getPathLength(candidate) <= getPathLength(current) + EPS
+
+const getIntersectionKeys = (path: Point[], otherPath: Point[]) => {
+  const intersections = new Set<string>()
+  for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
+    for (
+      let otherPathIndex = 0;
+      otherPathIndex < otherPath.length - 1;
+      otherPathIndex++
+    ) {
+      const point = getSegmentIntersection(
+        path[pathIndex]!,
+        path[pathIndex + 1]!,
+        otherPath[otherPathIndex]!,
+        otherPath[otherPathIndex + 1]!,
+      )
+      if (point) {
+        intersections.add(`${point.x.toFixed(6)},${point.y.toFixed(6)}`)
+      }
+    }
+  }
+  return intersections
+}
+
+const introducesNewCrossings = (
+  candidatePath: Point[],
+  currentPath: Point[],
+  otherPaths: Point[][],
+) =>
+  otherPaths.some((otherPath) => {
+    const currentIntersections = getIntersectionKeys(currentPath, otherPath)
+    const candidateIntersections = getIntersectionKeys(candidatePath, otherPath)
+    return [...candidateIntersections].some(
+      (intersection) => !currentIntersections.has(intersection),
+    )
+  })
+
+/**
+ * Restores a trace's recorded pre-collision path when the anchored net label
+ * that caused its reroute was later replaced by an inline label.
+ *
+ * A reroute is unwound only when its current geometry still matches the
+ * recorded result and the original path is strictly simpler without creating
+ * collisions, crossings, overlaps, or detached label anchors.
+ */
+export const restoreReroutesAroundSupersededLabels = ({
+  inputProblem,
+  traces,
+  netLabelPlacements,
+  inlineNetLabelPlacements,
+  completedReroutes,
+}: {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+  inlineNetLabelPlacements: InlineNetLabelPlacement[]
+  completedReroutes: CompletedTraceReroute[]
+}) => {
+  const outputTraces = [...traces]
+  const supersededLabelGlobalConnNetIds = new Set(
+    inlineNetLabelPlacements.map((placement) => placement.globalConnNetId),
+  )
+  const obstacles = getObstacleRects(inputProblem)
+  let restoredTraceCount = 0
+
+  // A trace can be rerouted more than once. Unwind only unchanged reroutes,
+  // newest first, so every restoration has exact provenance.
+  for (const reroute of [...completedReroutes].reverse()) {
+    if (!supersededLabelGlobalConnNetIds.has(reroute.label.globalConnNetId)) {
+      continue
+    }
+
+    const traceIndex = outputTraces.findIndex(
+      (trace) => trace.mspPairId === reroute.initialTrace.mspPairId,
+    )
+    if (traceIndex < 0) continue
+
+    const currentTrace = outputTraces[traceIndex]!
+    const currentPath = simplifyPath(currentTrace.tracePath)
+    const recordedReroutePath = simplifyPath(reroute.reroutedTracePath)
+    if (!pathsEqual(currentPath, recordedReroutePath)) continue
+
+    const candidatePath = simplifyPath(reroute.initialTrace.tracePath)
+    if (!isStrictlySimpler(candidatePath, currentPath)) continue
+
+    const candidateTrace = { ...currentTrace, tracePath: candidatePath }
+    const otherNetTraces = outputTraces.filter(
+      (trace) =>
+        trace.mspPairId !== currentTrace.mspPairId &&
+        trace.globalConnNetId !== currentTrace.globalConnNetId,
+    )
+    const otherNetInlineLabels = inlineNetLabelPlacements.filter(
+      (label) => label.globalConnNetId !== currentTrace.globalConnNetId,
+    )
+    const otherNetInlineStubPaths = otherNetInlineLabels.flatMap((label) =>
+      label.stubTracePath ? [[...label.stubTracePath]] : [],
+    )
+
+    if (
+      isPathCollidingWithObstacles(candidatePath, obstacles) ||
+      detectTraceLabelOverlap({
+        traces: [candidateTrace],
+        netLabels: netLabelPlacements,
+      }).length > 0 ||
+      otherNetInlineLabels.some((label) =>
+        pathIntersectsRenderedLabel(candidatePath, label),
+      ) ||
+      doesPathCoincideWithTraces(candidatePath, otherNetTraces) ||
+      doesPathCoincideWithPaths(candidatePath, otherNetInlineStubPaths) ||
+      introducesNewCrossings(
+        candidatePath,
+        currentPath,
+        otherNetTraces.map((trace) => trace.tracePath),
+      ) ||
+      introducesNewCrossings(
+        candidatePath,
+        currentPath,
+        otherNetInlineStubPaths,
+      ) ||
+      !preservesLabelAnchors(
+        netLabelPlacements,
+        [currentTrace],
+        [candidateTrace],
+      )
+    ) {
+      continue
+    }
+
+    outputTraces[traceIndex] = candidateTrace
+    restoredTraceCount++
+  }
+
+  return { traces: outputTraces, restoredTraceCount }
+}

package/lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts

@@ -1,8 +1,4 @@
-import {
-  doesSegmentIntersectRect,
-  getBoundFromCenteredRect,
-  type Point,
-} from "@tscircuit/math-utils"
+import type { Point } from "@tscircuit/math-utils"
 import type { GraphicsObject } from "graphics-debug"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import { doesPairCrossRestrictedCenterLines } from "lib/solvers/MspConnectionPairSolver/doesPairCrossRestrictedCenterLines"
@@ -24,6 +20,7 @@ import type {
   PinId,
 } from "lib/types/InputProblem"
 import { arePinsInDifferentSchematicSections } from "lib/utils/arePinsInDifferentSchematicSections"
+import { pathIntersectsRenderedLabel } from "lib/utils/pathIntersectsRenderedLabel"
 import {
   type InlineNetLabelOutput,
   type InlineNetLabelPlacement,
@@ -55,31 +52,6 @@ const MAX_ROUTED_COMPONENT_RECOVERY_PERPENDICULAR_OFFSET = 0.25
 const getCanonicalPairKey = (firstPinId: PinId, secondPinId: PinId) =>
   [firstPinId, secondPinId].sort().join("--")
 
-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
-}
-
 const getPerpendicularOffset = (firstPoint: Point, secondPoint: Point) => {
   const xDistance = Math.abs(firstPoint.x - secondPoint.x)
   const yDistance = Math.abs(firstPoint.y - secondPoint.y)

package/lib/solvers/SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver.ts

@@ -1,6 +1,7 @@
 import type { GraphicsObject, Rect } from "graphics-debug"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 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 { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
 import type { InputProblem } from "lib/types/InputProblem"
@@ -13,6 +14,7 @@ interface SameNetJunctionAlignmentSolverInput {
   inputProblem: InputProblem
   traces: SolvedTracePath[]
   netLabelPlacements: NetLabelPlacement[]
+  netLabelConnectorTraceIds: ReadonlySet<MspConnectionPairId>
 }
 
 /** Turns separate same-net load traces into one shared rail with short junction branches. */