Fail pipeline 4 when a node solver returns incomplete routing

Author: ShiboSoftwareDev

lib/solvers/HyperHighDensitySolver/HyperSingleIntraNodeSolver.ts

@@ -2,6 +2,7 @@ import {
   HighDensityIntraNodeRoute,
   NodeWithPortPoints,
 } from "lib/types/high-density-types"
+import { pointToSegmentDistance } from "@tscircuit/math-utils"
 import { CachedIntraNodeRouteSolver } from "../HighDensitySolver/CachedIntraNodeRouteSolver"
 import { IntraNodeRouteSolver } from "../HighDensitySolver/IntraNodeSolver"
 import {
@@ -324,6 +325,20 @@ export class HyperSingleIntraNodeSolver extends HyperParameterSupervisorSolver<
     } else {
       routes = solver.solver.solvedRoutes
     }
+
+    const invalidConnectionName = getFirstConnectionWithUncoveredPortPoint(
+      routes,
+      this.nodeWithPortPoints,
+    )
+    if (invalidConnectionName) {
+      solver.solver.solved = false
+      solver.solver.failed = true
+      solver.solver.error = `Solver returned partial intra-node routing for connection "${invalidConnectionName}" in node "${this.nodeWithPortPoints.capacityMeshNodeId}"`
+      this.solved = false
+      this.winningSolver = undefined
+      return
+    }
+
     this.solvedRoutes = routes.map((route) => {
       const matchingPortPoint = this.nodeWithPortPoints.portPoints.find(
         (p) => p.connectionName === route.connectionName,
@@ -338,3 +353,66 @@ export class HyperSingleIntraNodeSolver extends HyperParameterSupervisorSolver<
     })
   }
 }
+
+const isSamePoint3 = (
+  a: { x: number; y: number; z: number },
+  b: { x: number; y: number; z: number },
+  epsilon = 1e-6,
+) =>
+  Math.abs(a.x - b.x) <= epsilon &&
+  Math.abs(a.y - b.y) <= epsilon &&
+  a.z === b.z
+
+const doesRouteCoverPoint = (
+  route: Array<{ x: number; y: number; z: number }>,
+  point: { x: number; y: number; z: number },
+) => {
+  for (const routePoint of route) {
+    if (isSamePoint3(routePoint, point)) return true
+  }
+
+  for (let i = 0; i < route.length - 1; i++) {
+    const A = route[i]
+    const B = route[i + 1]
+    if (A.z !== point.z || B.z !== point.z) continue
+    if (pointToSegmentDistance(point, A, B) <= 1e-6) return true
+  }
+
+  return false
+}
+
+const getFirstConnectionWithUncoveredPortPoint = (
+  routes: HighDensityIntraNodeRoute[],
+  nodeWithPortPoints: NodeWithPortPoints,
+) => {
+  const routesByConnection = new Map<string, HighDensityIntraNodeRoute[]>()
+  for (const route of routes) {
+    if (!routesByConnection.has(route.connectionName)) {
+      routesByConnection.set(route.connectionName, [])
+    }
+    routesByConnection.get(route.connectionName)!.push(route)
+  }
+
+  const portPointsByConnection = new Map<
+    string,
+    Array<{ x: number; y: number; z: number }>
+  >()
+  for (const portPoint of nodeWithPortPoints.portPoints) {
+    if (!portPointsByConnection.has(portPoint.connectionName)) {
+      portPointsByConnection.set(portPoint.connectionName, [])
+    }
+    portPointsByConnection.get(portPoint.connectionName)!.push(portPoint)
+  }
+
+  for (const [connectionName, points] of portPointsByConnection) {
+    const connectionRoutes = routesByConnection.get(connectionName) ?? []
+    const coversAllPoints = points.every((point) =>
+      connectionRoutes.some((route) => doesRouteCoverPoint(route.route, point)),
+    )
+    if (!coversAllPoints) {
+      return connectionName
+    }
+  }
+
+  return null
+}

tests/features/pipeline4-circuit003-cmn3-no-center-via.test.ts

@@ -14,12 +14,10 @@ test(
     const solver = new AutoroutingPipelineSolver4(circuit003)
     solver.solve()
 
-    expect(solver.solved).toBe(true)
-    expect(solver.failed).toBe(false)
-
     const cmn3Meta =
       solver.highDensityRouteSolver?.nodeSolveMetadataById.get("cmn_3")
     expect(cmn3Meta).toBeDefined()
+    expect(cmn3Meta?.status).toBe("solved")
 
     const center = cmn3Meta!.node.center
     const sourceNet5Routes = (

tests/features/pipeline4-circuit004-cmn35-multipoint-must-fail.test.ts

@@ -0,0 +1,25 @@
+import { expect, test } from "bun:test"
+import * as dataset01 from "@tscircuit/autorouting-dataset-01"
+import { AutoroutingPipelineSolver4 } from "lib/autorouter-pipelines/AutoroutingPipeline4_TinyHypergraph/AutoroutingPipelineSolver4_TinyHypergraph"
+import type { SimpleRouteJson } from "lib/types"
+
+test(
+  "pipeline4 circuit004 fails when cmn_35 only has a partial multi-point route",
+  () => {
+    const circuit004 = (dataset01 as Record<string, unknown>)
+      .circuit004 as SimpleRouteJson
+    const solver = new AutoroutingPipelineSolver4(circuit004)
+    solver.solve()
+
+    expect(solver.solved).toBe(false)
+    expect(solver.failed).toBe(true)
+    expect(solver.error).toContain("cmn_35")
+
+    const cmn35Meta =
+      solver.highDensityRouteSolver?.nodeSolveMetadataById.get("cmn_35")
+    expect(cmn35Meta).toBeDefined()
+    expect(cmn35Meta?.status).toBe("failed")
+    expect(cmn35Meta?.error).toContain("partial intra-node routing")
+  },
+  { timeout: 60000 },
+)