@tscircuit/hypergraph 0.0.53 → 0.0.55

package/dist/index.js

@@ -14700,6 +14700,10 @@ var buildRegionsFromCells = (merged) => {
   );
   return { regions, hulls };
 };
+var clampPointToBounds = (point4, bounds) => ({
+  x: Math.min(bounds.maxX, Math.max(bounds.minX, point4.x)),
+  y: Math.min(bounds.maxY, Math.max(bounds.minY, point4.y))
+});
 var BuildRegionsSolver = class extends BaseSolver2 {
   input;
   output = null;
@@ -14708,9 +14712,15 @@ var BuildRegionsSolver = class extends BaseSolver2 {
     this.input = input;
   }
   _step() {
-    const { regions, hulls } = buildRegionsFromCells(this.input);
+    const boundedPts = this.input.pts.map(
+      (pt) => clampPointToBounds(pt, this.input.bounds)
+    );
+    const { regions, hulls } = buildRegionsFromCells({
+      ...this.input,
+      pts: boundedPts
+    });
     this.output = {
-      pts: this.input.pts,
+      pts: boundedPts,
       validTris: this.input.validTris,
       regions,
       hulls,
@@ -14733,10 +14743,10 @@ var BuildRegionsSolver = class extends BaseSolver2 {
     return {
       points: output.pts.map((pt) => ({ x: pt.x, y: pt.y, color: "#3b82f6" })),
       lines: output.regions.flatMap(
-        (region) => region.flatMap((point3, i) => {
+        (region) => region.flatMap((point4, i) => {
           const next = region[(i + 1) % region.length];
           if (!next) return [];
-          return [{ points: [point3, next], strokeColor: "#0f766e" }];
+          return [{ points: [point4, next], strokeColor: "#0f766e" }];
         })
       ),
       rects: [],
@@ -14964,6 +14974,63 @@ var resolveConstraintCrossings = (pts, constraintEdges, ringBoundaries) => {
   }
   return { pts: outPts, constraintEdges: outEdges, hadCrossings: true };
 };
+var ringToFlattenPoly = (ring) => {
+  return new Polygon$1(ring.map((p) => point(p.x, p.y)));
+};
+var extractFaces = (poly) => {
+  const result = [];
+  for (const face of poly.faces) {
+    const ring = [];
+    for (const v of face.vertices) {
+      ring.push({ x: v.x, y: v.y });
+    }
+    if (ring.length >= 3) {
+      result.push(ring);
+    }
+  }
+  return result;
+};
+var unionObstacleBoundaries = (rings) => {
+  if (rings.length <= 1) return rings;
+  try {
+    let polys = rings.map(ringToFlattenPoly);
+    for (let pass = 0; pass < 2; pass++) {
+      const merged = [];
+      const used = /* @__PURE__ */ new Set();
+      for (let i = 0; i < polys.length; i++) {
+        if (used.has(i)) continue;
+        let current = polys[i];
+        for (let j = i + 1; j < polys.length; j++) {
+          if (used.has(j)) continue;
+          const boxA = current.box;
+          const boxB = polys[j].box;
+          if (boxA.xmin > boxB.xmax + 1e-6 || boxA.xmax < boxB.xmin - 1e-6 || boxA.ymin > boxB.ymax + 1e-6 || boxA.ymax < boxB.ymin - 1e-6) {
+            continue;
+          }
+          try {
+            const unified = BooleanOperations.unify(current, polys[j]);
+            if (unified.faces.size > 0) {
+              current = unified;
+              used.add(j);
+            }
+          } catch {
+          }
+        }
+        merged.push(current);
+        used.add(i);
+      }
+      polys = merged;
+    }
+    const result = [];
+    for (const poly of polys) {
+      const faces = extractFaces(poly);
+      result.push(...faces);
+    }
+    return result.length > 0 ? result : rings;
+  } catch {
+    return rings;
+  }
+};
 var addRing = (ringPts, allPts, constraintEdges) => {
   const startIdx = allPts.length;
   allPts.push(...ringPts);
@@ -15005,6 +15072,7 @@ var generateBoundaryPointsWithEdges = (params) => {
   }
   ringBoundaries.push(constraintEdges.length);
   addRing(boundsPts, allPts, constraintEdges);
+  const obstacleRings = [];
   for (const via of vias) {
     const radius = via.diameter / 2 + clearance;
     const viaPts = [];
@@ -15015,8 +15083,7 @@ var generateBoundaryPointsWithEdges = (params) => {
         y: via.center.y + radius * Math.sin(angle)
       });
     }
-    ringBoundaries.push(constraintEdges.length);
-    addRing(viaPts, allPts, constraintEdges);
+    obstacleRings.push(viaPts);
   }
   for (const rect of rects) {
     const halfWidth = rect.width / 2 + clearance;
@@ -15027,8 +15094,7 @@ var generateBoundaryPointsWithEdges = (params) => {
       rotatePoint({ localX: halfWidth, localY: halfHeight, rect }),
       rotatePoint({ localX: -halfWidth, localY: halfHeight, rect })
     ];
-    ringBoundaries.push(constraintEdges.length);
-    addRing(rectPts, allPts, constraintEdges);
+    obstacleRings.push(rectPts);
   }
   for (const polygon2 of polygons) {
     if (polygon2.points.length < 3) continue;
@@ -15037,8 +15103,12 @@ var generateBoundaryPointsWithEdges = (params) => {
       clearance,
       verticesOnly: true
     });
+    obstacleRings.push(offsetPoints);
+  }
+  const mergedRings = unionObstacleBoundaries(obstacleRings);
+  for (const ring of mergedRings) {
     ringBoundaries.push(constraintEdges.length);
-    addRing(offsetPoints, allPts, constraintEdges);
+    addRing(ring, allPts, constraintEdges);
   }
   const resolved = resolveConstraintCrossings(
     allPts,
@@ -15260,6 +15330,256 @@ var mergeCells = (params) => {
   const depths = cells.map((cell) => concavityDepth(cell, pts));
   return { cells, depths };
 };
+var edgeKey3 = (a, b) => a < b ? a * 1e5 + b : b * 1e5 + a;
+var mergeCellsPolyanya = (params) => {
+  const { triangles, pts } = params;
+  if (!triangles.length) return { cells: [], depths: [] };
+  const n = triangles.length;
+  const cells = triangles.map(([a, b, c]) => {
+    const pa = pts[a];
+    const pb = pts[b];
+    const pc = pts[c];
+    if (!pa || !pb || !pc) return [a, b, c];
+    return cross({ o: pa, a: pb, b: pc }) < 0 ? [a, c, b] : [a, b, c];
+  });
+  const adj = new Array(n).fill(null);
+  for (let i = 0; i < n; i++) adj[i] = /* @__PURE__ */ new Map();
+  function rebuildAdj() {
+    for (let i = 0; i < adj.length; i++) {
+      if (adj[i]) adj[i].clear();
+    }
+    const edgeMap = /* @__PURE__ */ new Map();
+    for (let ci = 0; ci < cells.length; ci++) {
+      const ring = cells[ci];
+      if (!ring) continue;
+      for (let k = 0; k < ring.length; k++) {
+        const a = ring[k];
+        const b = ring[(k + 1) % ring.length];
+        const key = edgeKey3(a, b);
+        const existing = edgeMap.get(key);
+        if (existing) {
+          adj[ci].set(k, {
+            neighbor: existing.cellIdx,
+            neighborEdge: existing.edgePos
+          });
+          adj[existing.cellIdx].set(existing.edgePos, {
+            neighbor: ci,
+            neighborEdge: k
+          });
+        } else {
+          edgeMap.set(key, { cellIdx: ci, edgePos: k });
+        }
+      }
+    }
+  }
+  rebuildAdj();
+  function cellArea(ring) {
+    let a = 0;
+    for (let i = 0; i < ring.length; i++) {
+      const p = pts[ring[i]];
+      const q = pts[ring[(i + 1) % ring.length]];
+      a += p.x * q.y - q.x * p.y;
+    }
+    return Math.abs(a) / 2;
+  }
+  function findBoundary(xIdx, yIdx) {
+    const xRing = cells[xIdx];
+    const xAdj = adj[xIdx];
+    const L = xRing.length;
+    let seedK = -1;
+    for (const [k, entry] of xAdj) {
+      if (entry.neighbor === yIdx) {
+        seedK = k;
+        break;
+      }
+    }
+    if (seedK === -1) return null;
+    let firstK = seedK;
+    while (true) {
+      const prev = (firstK - 1 + L) % L;
+      if (prev === seedK) break;
+      const prevEntry = xAdj.get(prev);
+      if (!prevEntry || prevEntry.neighbor !== yIdx) break;
+      firstK = prev;
+    }
+    let lastK = seedK;
+    while (true) {
+      const next = (lastK + 1) % L;
+      if (next === firstK) break;
+      const nextEntry = xAdj.get(next);
+      if (!nextEntry || nextEntry.neighbor !== yIdx) break;
+      lastK = next;
+    }
+    const sharedCount = (lastK - firstK + L) % L + 1;
+    return { firstK, lastK, sharedCount };
+  }
+  function canMerge(xIdx, yIdx) {
+    const xRing = cells[xIdx];
+    const yRing = cells[yIdx];
+    const boundary = findBoundary(xIdx, yIdx);
+    if (!boundary) return false;
+    const { firstK, lastK, sharedCount } = boundary;
+    const N = xRing.length;
+    const M = yRing.length;
+    const A = xRing[firstK];
+    const B = xRing[(lastK + 1) % N];
+    let mA = -1;
+    for (let i = 0; i < M; i++) {
+      if (yRing[i] === A) {
+        mA = i;
+        break;
+      }
+    }
+    if (mA === -1) return false;
+    const mB = (mA - sharedCount + M) % M;
+    if (yRing[mB] !== B) return false;
+    const prevX = pts[xRing[(firstK - 1 + N) % N]];
+    const pA = pts[A];
+    const nextY = pts[yRing[(mA + 1) % M]];
+    if (cross({ o: prevX, a: pA, b: nextY }) < -1e-8) return false;
+    const prevY = pts[yRing[(mB - 1 + M) % M]];
+    const pB = pts[B];
+    const nextX = pts[xRing[(lastK + 2) % N]];
+    if (cross({ o: prevY, a: pB, b: nextX }) < -1e-8) return false;
+    return true;
+  }
+  function doMerge(xIdx, yIdx) {
+    const xRing = cells[xIdx];
+    const yRing = cells[yIdx];
+    const boundary = findBoundary(xIdx, yIdx);
+    const { firstK, lastK, sharedCount } = boundary;
+    const N = xRing.length;
+    const M = yRing.length;
+    const A = xRing[firstK];
+    const B = xRing[(lastK + 1) % N];
+    let mA = -1;
+    for (let i = 0; i < M; i++) {
+      if (yRing[i] === A) {
+        mA = i;
+        break;
+      }
+    }
+    const newRing = [];
+    newRing.push(A);
+    const yNonShared = M - sharedCount - 1;
+    for (let j = 1; j <= yNonShared; j++) {
+      newRing.push(yRing[(mA + j) % M]);
+    }
+    newRing.push(B);
+    const xNonShared = N - sharedCount - 1;
+    for (let j = 2; j <= xNonShared + 1; j++) {
+      newRing.push(xRing[(lastK + j) % N]);
+    }
+    cells[xIdx] = newRing;
+    cells[yIdx] = null;
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    rebuildAdj();
+    for (let i = 0; i < cells.length; i++) {
+      if (!cells[i]) continue;
+      const iAdj = adj[i];
+      const neighbors = /* @__PURE__ */ new Set();
+      for (const [, entry] of iAdj) {
+        if (cells[entry.neighbor]) neighbors.add(entry.neighbor);
+      }
+      if (neighbors.size === 1) {
+        const nIdx = neighbors.values().next().value;
+        if (canMerge(i, nIdx)) {
+          doMerge(i, nIdx);
+          changed = true;
+        }
+      }
+    }
+  }
+  rebuildAdj();
+  const areas = new Array(cells.length).fill(0);
+  for (let i = 0; i < cells.length; i++) {
+    if (cells[i]) areas[i] = cellArea(cells[i]);
+  }
+  const heap = [];
+  function heapPush(e) {
+    heap.push(e);
+    let i = heap.length - 1;
+    while (i > 0) {
+      const p = i - 1 >> 1;
+      if (heap[p].area >= heap[i].area) break;
+      const t = heap[p];
+      heap[p] = heap[i];
+      heap[i] = t;
+      i = p;
+    }
+  }
+  function heapPop() {
+    if (heap.length === 0) return void 0;
+    const top = heap[0];
+    const last = heap.pop();
+    if (heap.length > 0) {
+      heap[0] = last;
+      let i = 0;
+      while (true) {
+        let big = i;
+        const l = 2 * i + 1;
+        const r = 2 * i + 2;
+        if (l < heap.length && heap[l].area > heap[big].area) big = l;
+        if (r < heap.length && heap[r].area > heap[big].area) big = r;
+        if (big === i) break;
+        const t = heap[i];
+        heap[i] = heap[big];
+        heap[big] = t;
+        i = big;
+      }
+    }
+    return top;
+  }
+  const seenPairs = /* @__PURE__ */ new Set();
+  for (let i = 0; i < cells.length; i++) {
+    if (!cells[i]) continue;
+    const iAdj = adj[i];
+    const neighbors = /* @__PURE__ */ new Set();
+    for (const [, entry] of iAdj) {
+      if (cells[entry.neighbor]) neighbors.add(entry.neighbor);
+    }
+    for (const nIdx of neighbors) {
+      const pairKey = i < nIdx ? i * 1e5 + nIdx : nIdx * 1e5 + i;
+      if (seenPairs.has(pairKey)) continue;
+      seenPairs.add(pairKey);
+      if (canMerge(i, nIdx)) {
+        heapPush({ area: areas[i] + areas[nIdx], xIdx: i, yIdx: nIdx });
+      }
+    }
+  }
+  while (heap.length > 0) {
+    const entry = heapPop();
+    const { xIdx, yIdx } = entry;
+    if (!cells[xIdx] || !cells[yIdx]) continue;
+    const currentArea = areas[xIdx] + areas[yIdx];
+    if (Math.abs(currentArea - entry.area) > 1e-10) {
+      if (canMerge(xIdx, yIdx)) {
+        heapPush({ area: currentArea, xIdx, yIdx });
+      }
+      continue;
+    }
+    if (!canMerge(xIdx, yIdx)) continue;
+    doMerge(xIdx, yIdx);
+    areas[xIdx] = cellArea(cells[xIdx]);
+    rebuildAdj();
+    const xAdj = adj[xIdx];
+    const neighbors = /* @__PURE__ */ new Set();
+    for (const [, e] of xAdj) {
+      if (cells[e.neighbor]) neighbors.add(e.neighbor);
+    }
+    for (const nIdx of neighbors) {
+      if (canMerge(xIdx, nIdx)) {
+        heapPush({ area: areas[xIdx] + areas[nIdx], xIdx, yIdx: nIdx });
+      }
+    }
+  }
+  const liveCells = cells.filter((c) => c !== null);
+  const depths = liveCells.map(() => 0);
+  return { cells: liveCells, depths };
+};
 var MergeCellsSolver = class extends BaseSolver2 {
   input;
   output = null;
@@ -15268,13 +15588,17 @@ var MergeCellsSolver = class extends BaseSolver2 {
     this.input = input;
   }
   _step() {
-    const merged = mergeCells({
+    const merged = this.input.usePolyanyaMerge !== false ? mergeCellsPolyanya({
+      triangles: this.input.validTris,
+      pts: this.input.pts
+    }) : mergeCells({
       triangles: this.input.validTris,
       pts: this.input.pts,
       concavityTolerance: this.input.concavityTolerance
     });
     this.output = {
       pts: this.input.pts,
+      bounds: this.input.bounds,
       validTris: this.input.validTris,
       cells: merged.cells,
       depths: merged.depths
@@ -15430,25 +15754,30 @@ var isPointInOrNearPolygon = (params) => {
 var inFreeSpace = (params) => {
   const { px, py, bounds, vias, clearance, rects, polygons } = params;
   const { minX, maxX, minY, maxY } = bounds;
-  if (px < minX - 0.1 || px > maxX + 0.1 || py < minY - 0.1 || py > maxY + 0.1) {
+  const maxDim = Math.max(maxX - minX, maxY - minY, 1);
+  const eps = maxDim * 1e-6;
+  if (px < minX - eps || px > maxX + eps || py < minY - eps || py > maxY + eps) {
     return false;
   }
   for (const via of vias) {
     const radius = via.diameter / 2 + clearance;
-    if ((px - via.center.x) ** 2 + (py - via.center.y) ** 2 < radius * radius - 0.1) {
+    const effectiveRadius = Math.max(0, radius - eps);
+    if ((px - via.center.x) ** 2 + (py - via.center.y) ** 2 < effectiveRadius * effectiveRadius) {
       return false;
     }
   }
   for (const rect of rects) {
     const halfWidth = rect.width / 2 + clearance;
     const halfHeight = rect.height / 2 + clearance;
+    const effectiveHalfWidth = Math.max(0, halfWidth - eps);
+    const effectiveHalfHeight = Math.max(0, halfHeight - eps);
     const dx = px - rect.center.x;
     const dy = py - rect.center.y;
     const cosTheta = Math.cos(rect.ccwRotation);
     const sinTheta = Math.sin(rect.ccwRotation);
     const localX = dx * cosTheta + dy * sinTheta;
     const localY = -dx * sinTheta + dy * cosTheta;
-    if (Math.abs(localX) < halfWidth - 0.1 && Math.abs(localY) < halfHeight - 0.1) {
+    if (Math.abs(localX) < effectiveHalfWidth && Math.abs(localY) < effectiveHalfHeight) {
       return false;
     }
   }
@@ -15526,7 +15855,8 @@ var TriangulateSolver = class extends BaseSolver2 {
         this.input.pts,
         this.input.constraintEdges
       );
-      validTris = this.input.hadCrossings ? filterTris({
+      const hasObstacles = vias.length > 0 || rects.length > 0 || polygons.length > 0;
+      validTris = hasObstacles ? filterTris({
         triangles: cdtTris,
         pts: this.input.pts,
         bounds: this.input.bounds,
@@ -15549,6 +15879,7 @@ var TriangulateSolver = class extends BaseSolver2 {
     }
     this.output = {
       pts: this.input.pts,
+      bounds: this.input.bounds,
       validTris
     };
     this.stats = {
@@ -15622,8 +15953,10 @@ var ConvexRegionsSolver = class extends BasePipelineSolver {
       return [
         {
           pts: triangulated.pts,
+          bounds: triangulated.bounds,
           validTris: triangulated.validTris,
-          concavityTolerance: instance.inputProblem.concavityTolerance
+          concavityTolerance: instance.inputProblem.concavityTolerance,
+          usePolyanyaMerge: instance.inputProblem.usePolyanyaMerge
         }
       ];
     }),
@@ -15644,16 +15977,24 @@ var ConvexRegionsSolver = class extends BasePipelineSolver {
     if (!result) {
       return { points: [], lines: [], rects: [], circles: [], texts: [] };
     }
+    const boundsWidth = this.inputProblem.bounds.maxX - this.inputProblem.bounds.minX;
+    const boundsHeight = this.inputProblem.bounds.maxY - this.inputProblem.bounds.minY;
+    const maxDim = Math.max(boundsWidth, boundsHeight, Number.EPSILON);
+    const targetVisualSize = 400;
+    const displayScale = Math.max(1, targetVisualSize / maxDim);
+    const displayOffsetX = -this.inputProblem.bounds.minX * displayScale;
+    const displayOffsetY = -this.inputProblem.bounds.minY * displayScale;
+    const toDisplayPoint = (point4) => ({
+      x: point4.x * displayScale + displayOffsetX,
+      y: point4.y * displayScale + displayOffsetY
+    });
     const polygonLines = (this.inputProblem.polygons ?? []).flatMap(
       (polygon2) => {
         const pts = polygon2.points;
         return pts.map((p, i) => {
           const next = pts[(i + 1) % pts.length];
           return {
-            points: [
-              { x: p.x, y: p.y },
-              { x: next.x, y: next.y }
-            ],
+            points: [toDisplayPoint(p), toDisplayPoint(next)],
             strokeColor: "#ff9f43",
             strokeWidth: 2
           };
@@ -15677,10 +16018,7 @@ var ConvexRegionsSolver = class extends BasePipelineSolver {
       return corners.map((p, i) => {
         const next = corners[(i + 1) % corners.length];
         return {
-          points: [
-            { x: p.x, y: p.y },
-            { x: next.x, y: next.y }
-          ],
+          points: [toDisplayPoint(p), toDisplayPoint(next)],
           strokeColor: "#ff6b6b",
           strokeWidth: 2
         };
@@ -15688,8 +16026,7 @@ var ConvexRegionsSolver = class extends BasePipelineSolver {
     });
     return {
       points: result.pts.map((pt) => ({
-        x: pt.x,
-        y: pt.y,
+        ...toDisplayPoint(pt),
         color: "#38b6ff"
       })),
       lines: [
@@ -15697,10 +16034,7 @@ var ConvexRegionsSolver = class extends BasePipelineSolver {
           (region) => region.map((p, i) => {
             const next = region[(i + 1) % region.length] ?? p;
             return {
-              points: [
-                { x: p.x, y: p.y },
-                { x: next.x, y: next.y }
-              ],
+              points: [toDisplayPoint(p), toDisplayPoint(next)],
               strokeColor: "#4ecb82"
             };
           })
@@ -15710,14 +16044,14 @@ var ConvexRegionsSolver = class extends BasePipelineSolver {
       ],
       rects: [],
       circles: (this.inputProblem.vias ?? []).map((via) => ({
-        center: { x: via.center.x, y: via.center.y },
-        radius: via.diameter / 2,
+        center: toDisplayPoint(via.center),
+        radius: via.diameter / 2 * displayScale,
         stroke: "#ff6b6b"
       })),
       texts: [
         {
-          x: this.inputProblem.bounds.minX + 8,
-          y: this.inputProblem.bounds.minY + 16,
+          x: 8,
+          y: 16,
           text: `regions=${result.regions.length}`,
           color: "#ffffff"
         }
@@ -17549,25 +17883,18 @@ var extractXYConnectionsFromSample = (sample) => {
   }
   return xyConnections;
 };
-var predictViaRegionFromGraphPattern = (input) => {
-  const area = Math.max(input.graphWidthMm * input.graphHeightMm, 0.01);
-  const density = input.connectionCount / area;
-  if (density <= 0.032343248633284985) {
-    if (input.connectionCount <= 11.5) {
-      if (input.connectionCount === 8 && input.intersectionCount >= 17 && input.graphWidthMm <= 15 && input.graphHeightMm >= 20) {
-        return "via-tile-5-regions";
-      }
-      return "via-tile-6-regions";
-    }
-    return "via-tile-3-regions";
-  }
-  if (input.graphHeightMm <= 12.600000000000001) {
-    return "via-tile-3-regions";
-  }
-  if (input.graphWidthMm <= 13.41) {
+var predictViaRegionFromSolveMatrix = (input) => {
+  const area = input.graphWidthMm * input.graphHeightMm;
+  if (input.graphWidthMm > 22) {
     return "via-tile-4-regions";
   }
-  return "via-tile-5-regions";
+  if (input.intersectionCount <= 20) {
+    if (input.intersectionCount <= 17) {
+      return "via-tile-5-regions";
+    }
+    return input.graphWidthMm <= 12.6 ? "via-tile-3-regions" : "via-tile-4-regions";
+  }
+  return area <= 246.01 ? "via-tile-3-regions" : "via-tile-5-regions";
 };
 var getViaTileBounds = (viaTile) => {
   const points = [];
@@ -17605,7 +17932,7 @@ var scoreViaTileForProblem = (problem, candidate) => {
   const crossingPerConnection = problem.intersectionCount / Math.max(problem.connectionCount, 1);
   const density = problem.connectionCount / graphArea;
   const requiredCapacityScore = problem.connectionCount * 1.2 + problem.intersectionCount * 1.5 + crossingPerConnection * 5 + density * 40;
-  const capacityScore = viaCount * 3.1 + routeSegmentCount * 2.4 + netCount * 4 + 1 / tileArea * 4.5;
+  const capacityScore = viaCount * 3.1 + routeSegmentCount * 2.4 + netCount * 0.5 + 1 / tileArea * 4.5;
   const predictedReliability = clamp4(
     sigmoid((capacityScore - requiredCapacityScore) / 3.2),
     0,
@@ -17711,24 +18038,21 @@ var recommendViaTileFromGraphInput = (problemInput, fallbackXYConnections = [],
     }
     return a.estimatedIterationCost - b.estimatedIterationCost;
   });
-  const predictedViaRegionName = predictViaRegionFromGraphPattern(normalizedInput);
-  if (predictedViaRegionName) {
-    const predictedCandidate = scored.find(
-      (candidate) => candidate.viaRegionName === predictedViaRegionName
-    );
-    if (predictedCandidate) {
-      const reordered = [
+  const predictedViaRegionName = predictViaRegionFromSolveMatrix(normalizedInput);
+  const predictedCandidate = scored.find(
+    (candidate) => candidate.viaRegionName === predictedViaRegionName
+  );
+  if (predictedCandidate) {
+    return {
+      recommendedViaRegionName: predictedCandidate.viaRegionName,
+      inputFeatures: normalizedInput,
+      candidates: [
         predictedCandidate,
         ...scored.filter(
           (candidate) => candidate.viaRegionName !== predictedViaRegionName
         )
-      ];
-      return {
-        recommendedViaRegionName: reordered[0].viaRegionName,
-        inputFeatures: normalizedInput,
-        candidates: reordered
-      };
-    }
+      ]
+    };
   }
   return {
     recommendedViaRegionName: scored[0].viaRegionName,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/hypergraph",
   "main": "dist/index.js",
-  "version": "0.0.53",
+  "version": "0.0.55",
   "type": "module",
   "scripts": {
     "start": "cosmos",
@@ -16,7 +16,7 @@
   "repository": "https://github.com/tscircuit/hypergraph",
   "devDependencies": {
     "@biomejs/biome": "^2.3.11",
-    "@tscircuit/find-convex-regions": "^0.0.9",
+    "@tscircuit/find-convex-regions": "^0.1.3",
     "@tscircuit/jumper-topology-generator": "^0.0.4",
     "@tscircuit/math-utils": "^0.0.29",
     "@types/bun": "latest",