@tscircuit/schematic-trace-solver 0.0.174 → 0.0.175

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/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -581,11 +581,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.175",
   "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} />