@tscircuit/capacity-autorouter 0.0.54 → 0.0.56

package/dist/index.js

@@ -47,6 +47,7 @@ var BaseSolver = class {
   activeSubSolver;
   failedSubSolvers;
   timeToSolve;
+  stats = {};
   /** DO NOT OVERRIDE! Override _step() instead */
   step() {
     if (this.solved) return;
@@ -65,6 +66,9 @@ var BaseSolver = class {
       console.error(this.error);
       this.failed = true;
     }
+    if ("computeProgress" in this) {
+      this.progress = this.computeProgress();
+    }
   }
   _step() {
   }
@@ -968,8 +972,935 @@ var calculateOptimalCapacityDepth = (initialWidth, targetMinCapacity = 0.5, maxD
   return Math.max(1, depth);
 };
 
+// node_modules/quickselect/index.js
+function quickselect(arr, k, left = 0, right = arr.length - 1, compare = defaultCompare) {
+  while (right > left) {
+    if (right - left > 600) {
+      const n = right - left + 1;
+      const m = k - left + 1;
+      const z = Math.log(n);
+      const s = 0.5 * Math.exp(2 * z / 3);
+      const sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
+      const newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
+      const newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
+      quickselect(arr, k, newLeft, newRight, compare);
+    }
+    const t = arr[k];
+    let i = left;
+    let j = right;
+    swap(arr, left, k);
+    if (compare(arr[right], t) > 0) swap(arr, left, right);
+    while (i < j) {
+      swap(arr, i, j);
+      i++;
+      j--;
+      while (compare(arr[i], t) < 0) i++;
+      while (compare(arr[j], t) > 0) j--;
+    }
+    if (compare(arr[left], t) === 0) swap(arr, left, j);
+    else {
+      j++;
+      swap(arr, j, right);
+    }
+    if (j <= k) left = j + 1;
+    if (k <= j) right = j - 1;
+  }
+}
+function swap(arr, i, j) {
+  const tmp = arr[i];
+  arr[i] = arr[j];
+  arr[j] = tmp;
+}
+function defaultCompare(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+// node_modules/rbush/index.js
+var RBush = class {
+  constructor(maxEntries = 9) {
+    this._maxEntries = Math.max(4, maxEntries);
+    this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4));
+    this.clear();
+  }
+  all() {
+    return this._all(this.data, []);
+  }
+  search(bbox) {
+    let node = this.data;
+    const result = [];
+    if (!intersects(bbox, node)) return result;
+    const toBBox = this.toBBox;
+    const nodesToSearch = [];
+    while (node) {
+      for (let i = 0; i < node.children.length; i++) {
+        const child = node.children[i];
+        const childBBox = node.leaf ? toBBox(child) : child;
+        if (intersects(bbox, childBBox)) {
+          if (node.leaf) result.push(child);
+          else if (contains(bbox, childBBox)) this._all(child, result);
+          else nodesToSearch.push(child);
+        }
+      }
+      node = nodesToSearch.pop();
+    }
+    return result;
+  }
+  collides(bbox) {
+    let node = this.data;
+    if (!intersects(bbox, node)) return false;
+    const nodesToSearch = [];
+    while (node) {
+      for (let i = 0; i < node.children.length; i++) {
+        const child = node.children[i];
+        const childBBox = node.leaf ? this.toBBox(child) : child;
+        if (intersects(bbox, childBBox)) {
+          if (node.leaf || contains(bbox, childBBox)) return true;
+          nodesToSearch.push(child);
+        }
+      }
+      node = nodesToSearch.pop();
+    }
+    return false;
+  }
+  load(data) {
+    if (!(data && data.length)) return this;
+    if (data.length < this._minEntries) {
+      for (let i = 0; i < data.length; i++) {
+        this.insert(data[i]);
+      }
+      return this;
+    }
+    let node = this._build(data.slice(), 0, data.length - 1, 0);
+    if (!this.data.children.length) {
+      this.data = node;
+    } else if (this.data.height === node.height) {
+      this._splitRoot(this.data, node);
+    } else {
+      if (this.data.height < node.height) {
+        const tmpNode = this.data;
+        this.data = node;
+        node = tmpNode;
+      }
+      this._insert(node, this.data.height - node.height - 1, true);
+    }
+    return this;
+  }
+  insert(item) {
+    if (item) this._insert(item, this.data.height - 1);
+    return this;
+  }
+  clear() {
+    this.data = createNode([]);
+    return this;
+  }
+  remove(item, equalsFn) {
+    if (!item) return this;
+    let node = this.data;
+    const bbox = this.toBBox(item);
+    const path = [];
+    const indexes = [];
+    let i, parent, goingUp;
+    while (node || path.length) {
+      if (!node) {
+        node = path.pop();
+        parent = path[path.length - 1];
+        i = indexes.pop();
+        goingUp = true;
+      }
+      if (node.leaf) {
+        const index = findItem(item, node.children, equalsFn);
+        if (index !== -1) {
+          node.children.splice(index, 1);
+          path.push(node);
+          this._condense(path);
+          return this;
+        }
+      }
+      if (!goingUp && !node.leaf && contains(node, bbox)) {
+        path.push(node);
+        indexes.push(i);
+        i = 0;
+        parent = node;
+        node = node.children[0];
+      } else if (parent) {
+        i++;
+        node = parent.children[i];
+        goingUp = false;
+      } else node = null;
+    }
+    return this;
+  }
+  toBBox(item) {
+    return item;
+  }
+  compareMinX(a, b) {
+    return a.minX - b.minX;
+  }
+  compareMinY(a, b) {
+    return a.minY - b.minY;
+  }
+  toJSON() {
+    return this.data;
+  }
+  fromJSON(data) {
+    this.data = data;
+    return this;
+  }
+  _all(node, result) {
+    const nodesToSearch = [];
+    while (node) {
+      if (node.leaf) result.push(...node.children);
+      else nodesToSearch.push(...node.children);
+      node = nodesToSearch.pop();
+    }
+    return result;
+  }
+  _build(items, left, right, height) {
+    const N = right - left + 1;
+    let M = this._maxEntries;
+    let node;
+    if (N <= M) {
+      node = createNode(items.slice(left, right + 1));
+      calcBBox(node, this.toBBox);
+      return node;
+    }
+    if (!height) {
+      height = Math.ceil(Math.log(N) / Math.log(M));
+      M = Math.ceil(N / Math.pow(M, height - 1));
+    }
+    node = createNode([]);
+    node.leaf = false;
+    node.height = height;
+    const N2 = Math.ceil(N / M);
+    const N1 = N2 * Math.ceil(Math.sqrt(M));
+    multiSelect(items, left, right, N1, this.compareMinX);
+    for (let i = left; i <= right; i += N1) {
+      const right2 = Math.min(i + N1 - 1, right);
+      multiSelect(items, i, right2, N2, this.compareMinY);
+      for (let j = i; j <= right2; j += N2) {
+        const right3 = Math.min(j + N2 - 1, right2);
+        node.children.push(this._build(items, j, right3, height - 1));
+      }
+    }
+    calcBBox(node, this.toBBox);
+    return node;
+  }
+  _chooseSubtree(bbox, node, level, path) {
+    while (true) {
+      path.push(node);
+      if (node.leaf || path.length - 1 === level) break;
+      let minArea = Infinity;
+      let minEnlargement = Infinity;
+      let targetNode;
+      for (let i = 0; i < node.children.length; i++) {
+        const child = node.children[i];
+        const area = bboxArea(child);
+        const enlargement = enlargedArea(bbox, child) - area;
+        if (enlargement < minEnlargement) {
+          minEnlargement = enlargement;
+          minArea = area < minArea ? area : minArea;
+          targetNode = child;
+        } else if (enlargement === minEnlargement) {
+          if (area < minArea) {
+            minArea = area;
+            targetNode = child;
+          }
+        }
+      }
+      node = targetNode || node.children[0];
+    }
+    return node;
+  }
+  _insert(item, level, isNode) {
+    const bbox = isNode ? item : this.toBBox(item);
+    const insertPath = [];
+    const node = this._chooseSubtree(bbox, this.data, level, insertPath);
+    node.children.push(item);
+    extend(node, bbox);
+    while (level >= 0) {
+      if (insertPath[level].children.length > this._maxEntries) {
+        this._split(insertPath, level);
+        level--;
+      } else break;
+    }
+    this._adjustParentBBoxes(bbox, insertPath, level);
+  }
+  // split overflowed node into two
+  _split(insertPath, level) {
+    const node = insertPath[level];
+    const M = node.children.length;
+    const m = this._minEntries;
+    this._chooseSplitAxis(node, m, M);
+    const splitIndex = this._chooseSplitIndex(node, m, M);
+    const newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex));
+    newNode.height = node.height;
+    newNode.leaf = node.leaf;
+    calcBBox(node, this.toBBox);
+    calcBBox(newNode, this.toBBox);
+    if (level) insertPath[level - 1].children.push(newNode);
+    else this._splitRoot(node, newNode);
+  }
+  _splitRoot(node, newNode) {
+    this.data = createNode([node, newNode]);
+    this.data.height = node.height + 1;
+    this.data.leaf = false;
+    calcBBox(this.data, this.toBBox);
+  }
+  _chooseSplitIndex(node, m, M) {
+    let index;
+    let minOverlap = Infinity;
+    let minArea = Infinity;
+    for (let i = m; i <= M - m; i++) {
+      const bbox1 = distBBox(node, 0, i, this.toBBox);
+      const bbox2 = distBBox(node, i, M, this.toBBox);
+      const overlap = intersectionArea(bbox1, bbox2);
+      const area = bboxArea(bbox1) + bboxArea(bbox2);
+      if (overlap < minOverlap) {
+        minOverlap = overlap;
+        index = i;
+        minArea = area < minArea ? area : minArea;
+      } else if (overlap === minOverlap) {
+        if (area < minArea) {
+          minArea = area;
+          index = i;
+        }
+      }
+    }
+    return index || M - m;
+  }
+  // sorts node children by the best axis for split
+  _chooseSplitAxis(node, m, M) {
+    const compareMinX = node.leaf ? this.compareMinX : compareNodeMinX;
+    const compareMinY = node.leaf ? this.compareMinY : compareNodeMinY;
+    const xMargin = this._allDistMargin(node, m, M, compareMinX);
+    const yMargin = this._allDistMargin(node, m, M, compareMinY);
+    if (xMargin < yMargin) node.children.sort(compareMinX);
+  }
+  // total margin of all possible split distributions where each node is at least m full
+  _allDistMargin(node, m, M, compare) {
+    node.children.sort(compare);
+    const toBBox = this.toBBox;
+    const leftBBox = distBBox(node, 0, m, toBBox);
+    const rightBBox = distBBox(node, M - m, M, toBBox);
+    let margin = bboxMargin(leftBBox) + bboxMargin(rightBBox);
+    for (let i = m; i < M - m; i++) {
+      const child = node.children[i];
+      extend(leftBBox, node.leaf ? toBBox(child) : child);
+      margin += bboxMargin(leftBBox);
+    }
+    for (let i = M - m - 1; i >= m; i--) {
+      const child = node.children[i];
+      extend(rightBBox, node.leaf ? toBBox(child) : child);
+      margin += bboxMargin(rightBBox);
+    }
+    return margin;
+  }
+  _adjustParentBBoxes(bbox, path, level) {
+    for (let i = level; i >= 0; i--) {
+      extend(path[i], bbox);
+    }
+  }
+  _condense(path) {
+    for (let i = path.length - 1, siblings; i >= 0; i--) {
+      if (path[i].children.length === 0) {
+        if (i > 0) {
+          siblings = path[i - 1].children;
+          siblings.splice(siblings.indexOf(path[i]), 1);
+        } else this.clear();
+      } else calcBBox(path[i], this.toBBox);
+    }
+  }
+};
+function findItem(item, items, equalsFn) {
+  if (!equalsFn) return items.indexOf(item);
+  for (let i = 0; i < items.length; i++) {
+    if (equalsFn(item, items[i])) return i;
+  }
+  return -1;
+}
+function calcBBox(node, toBBox) {
+  distBBox(node, 0, node.children.length, toBBox, node);
+}
+function distBBox(node, k, p, toBBox, destNode) {
+  if (!destNode) destNode = createNode(null);
+  destNode.minX = Infinity;
+  destNode.minY = Infinity;
+  destNode.maxX = -Infinity;
+  destNode.maxY = -Infinity;
+  for (let i = k; i < p; i++) {
+    const child = node.children[i];
+    extend(destNode, node.leaf ? toBBox(child) : child);
+  }
+  return destNode;
+}
+function extend(a, b) {
+  a.minX = Math.min(a.minX, b.minX);
+  a.minY = Math.min(a.minY, b.minY);
+  a.maxX = Math.max(a.maxX, b.maxX);
+  a.maxY = Math.max(a.maxY, b.maxY);
+  return a;
+}
+function compareNodeMinX(a, b) {
+  return a.minX - b.minX;
+}
+function compareNodeMinY(a, b) {
+  return a.minY - b.minY;
+}
+function bboxArea(a) {
+  return (a.maxX - a.minX) * (a.maxY - a.minY);
+}
+function bboxMargin(a) {
+  return a.maxX - a.minX + (a.maxY - a.minY);
+}
+function enlargedArea(a, b) {
+  return (Math.max(b.maxX, a.maxX) - Math.min(b.minX, a.minX)) * (Math.max(b.maxY, a.maxY) - Math.min(b.minY, a.minY));
+}
+function intersectionArea(a, b) {
+  const minX = Math.max(a.minX, b.minX);
+  const minY = Math.max(a.minY, b.minY);
+  const maxX = Math.min(a.maxX, b.maxX);
+  const maxY = Math.min(a.maxY, b.maxY);
+  return Math.max(0, maxX - minX) * Math.max(0, maxY - minY);
+}
+function contains(a, b) {
+  return a.minX <= b.minX && a.minY <= b.minY && b.maxX <= a.maxX && b.maxY <= a.maxY;
+}
+function intersects(a, b) {
+  return b.minX <= a.maxX && b.minY <= a.maxY && b.maxX >= a.minX && b.maxY >= a.minY;
+}
+function createNode(children) {
+  return {
+    children,
+    height: 1,
+    leaf: true,
+    minX: Infinity,
+    minY: Infinity,
+    maxX: -Infinity,
+    maxY: -Infinity
+  };
+}
+function multiSelect(arr, left, right, n, compare) {
+  const stack = [left, right];
+  while (stack.length) {
+    right = stack.pop();
+    left = stack.pop();
+    if (right - left <= n) continue;
+    const mid = left + Math.ceil((right - left) / n / 2) * n;
+    quickselect(arr, mid, left, right, compare);
+    stack.push(left, mid, mid, right);
+  }
+}
+
+// lib/data-structures/RbushIndex.ts
+var RbushIndex = class {
+  tree;
+  constructor(maxEntries = 9) {
+    this.tree = new RBush(maxEntries);
+  }
+  insert(item, minX, minY, maxX, maxY) {
+    this.tree.insert({ minX, minY, maxX, maxY, data: item });
+  }
+  bulkLoad(items) {
+    const nodes = items.map(({ item, minX, minY, maxX, maxY }) => ({
+      minX,
+      minY,
+      maxX,
+      maxY,
+      data: item
+    }));
+    this.tree.load(nodes);
+  }
+  search(minX, minY, maxX, maxY) {
+    return this.tree.search({ minX, minY, maxX, maxY }).map((n) => n.data);
+  }
+  clear() {
+    this.tree.clear();
+  }
+};
+
+// node_modules/flatqueue/index.js
+var FlatQueue = class {
+  constructor() {
+    this.ids = [];
+    this.values = [];
+    this.length = 0;
+  }
+  clear() {
+    this.length = 0;
+  }
+  push(id, value) {
+    let pos = this.length++;
+    while (pos > 0) {
+      const parent = pos - 1 >> 1;
+      const parentValue = this.values[parent];
+      if (value >= parentValue) break;
+      this.ids[pos] = this.ids[parent];
+      this.values[pos] = parentValue;
+      pos = parent;
+    }
+    this.ids[pos] = id;
+    this.values[pos] = value;
+  }
+  pop() {
+    if (this.length === 0) return void 0;
+    const top = this.ids[0];
+    this.length--;
+    if (this.length > 0) {
+      const id = this.ids[0] = this.ids[this.length];
+      const value = this.values[0] = this.values[this.length];
+      const halfLength = this.length >> 1;
+      let pos = 0;
+      while (pos < halfLength) {
+        let left = (pos << 1) + 1;
+        const right = left + 1;
+        let bestIndex = this.ids[left];
+        let bestValue = this.values[left];
+        const rightValue = this.values[right];
+        if (right < this.length && rightValue < bestValue) {
+          left = right;
+          bestIndex = this.ids[right];
+          bestValue = rightValue;
+        }
+        if (bestValue >= value) break;
+        this.ids[pos] = bestIndex;
+        this.values[pos] = bestValue;
+        pos = left;
+      }
+      this.ids[pos] = id;
+      this.values[pos] = value;
+    }
+    return top;
+  }
+  peek() {
+    if (this.length === 0) return void 0;
+    return this.ids[0];
+  }
+  peekValue() {
+    if (this.length === 0) return void 0;
+    return this.values[0];
+  }
+  shrink() {
+    this.ids.length = this.values.length = this.length;
+  }
+};
+
+// node_modules/flatbush/index.js
+var ARRAY_TYPES = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array];
+var VERSION = 3;
+var Flatbush = class _Flatbush {
+  /**
+   * Recreate a Flatbush index from raw `ArrayBuffer` or `SharedArrayBuffer` data.
+   * @param {ArrayBuffer | SharedArrayBuffer} data
+   * @param {number} [byteOffset=0] byte offset to the start of the Flatbush buffer in the referenced ArrayBuffer.
+   * @returns {Flatbush} index
+   */
+  static from(data, byteOffset = 0) {
+    if (byteOffset % 8 !== 0) {
+      throw new Error("byteOffset must be 8-byte aligned.");
+    }
+    if (!data || data.byteLength === void 0 || data.buffer) {
+      throw new Error("Data must be an instance of ArrayBuffer or SharedArrayBuffer.");
+    }
+    const [magic, versionAndType] = new Uint8Array(data, byteOffset + 0, 2);
+    if (magic !== 251) {
+      throw new Error("Data does not appear to be in a Flatbush format.");
+    }
+    const version = versionAndType >> 4;
+    if (version !== VERSION) {
+      throw new Error(`Got v${version} data when expected v${VERSION}.`);
+    }
+    const ArrayType = ARRAY_TYPES[versionAndType & 15];
+    if (!ArrayType) {
+      throw new Error("Unrecognized array type.");
+    }
+    const [nodeSize] = new Uint16Array(data, byteOffset + 2, 1);
+    const [numItems] = new Uint32Array(data, byteOffset + 4, 1);
+    return new _Flatbush(numItems, nodeSize, ArrayType, void 0, data, byteOffset);
+  }
+  /**
+   * Create a Flatbush index that will hold a given number of items.
+   * @param {number} numItems
+   * @param {number} [nodeSize=16] Size of the tree node (16 by default).
+   * @param {TypedArrayConstructor} [ArrayType=Float64Array] The array type used for coordinates storage (`Float64Array` by default).
+   * @param {ArrayBufferConstructor | SharedArrayBufferConstructor} [ArrayBufferType=ArrayBuffer] The array buffer type used to store data (`ArrayBuffer` by default).
+   * @param {ArrayBuffer | SharedArrayBuffer} [data] (Only used internally)
+   * @param {number} [byteOffset=0] (Only used internally)
+   */
+  constructor(numItems, nodeSize = 16, ArrayType = Float64Array, ArrayBufferType = ArrayBuffer, data, byteOffset = 0) {
+    if (numItems === void 0) throw new Error("Missing required argument: numItems.");
+    if (isNaN(numItems) || numItems <= 0) throw new Error(`Unexpected numItems value: ${numItems}.`);
+    this.numItems = +numItems;
+    this.nodeSize = Math.min(Math.max(+nodeSize, 2), 65535);
+    this.byteOffset = byteOffset;
+    let n = numItems;
+    let numNodes = n;
+    this._levelBounds = [n * 4];
+    do {
+      n = Math.ceil(n / this.nodeSize);
+      numNodes += n;
+      this._levelBounds.push(numNodes * 4);
+    } while (n !== 1);
+    this.ArrayType = ArrayType;
+    this.IndexArrayType = numNodes < 16384 ? Uint16Array : Uint32Array;
+    const arrayTypeIndex = ARRAY_TYPES.indexOf(this.ArrayType);
+    const nodesByteSize = numNodes * 4 * this.ArrayType.BYTES_PER_ELEMENT;
+    if (arrayTypeIndex < 0) {
+      throw new Error(`Unexpected typed array class: ${ArrayType}.`);
+    }
+    if (data && data.byteLength !== void 0 && !data.buffer) {
+      this.data = data;
+      this._boxes = new this.ArrayType(this.data, byteOffset + 8, numNodes * 4);
+      this._indices = new this.IndexArrayType(this.data, byteOffset + 8 + nodesByteSize, numNodes);
+      this._pos = numNodes * 4;
+      this.minX = this._boxes[this._pos - 4];
+      this.minY = this._boxes[this._pos - 3];
+      this.maxX = this._boxes[this._pos - 2];
+      this.maxY = this._boxes[this._pos - 1];
+    } else {
+      this.data = new ArrayBufferType(8 + nodesByteSize + numNodes * this.IndexArrayType.BYTES_PER_ELEMENT);
+      this._boxes = new this.ArrayType(this.data, 8, numNodes * 4);
+      this._indices = new this.IndexArrayType(this.data, 8 + nodesByteSize, numNodes);
+      this._pos = 0;
+      this.minX = Infinity;
+      this.minY = Infinity;
+      this.maxX = -Infinity;
+      this.maxY = -Infinity;
+      new Uint8Array(this.data, 0, 2).set([251, (VERSION << 4) + arrayTypeIndex]);
+      new Uint16Array(this.data, 2, 1)[0] = nodeSize;
+      new Uint32Array(this.data, 4, 1)[0] = numItems;
+    }
+    this._queue = new FlatQueue();
+  }
+  /**
+   * Add a given rectangle to the index.
+   * @param {number} minX
+   * @param {number} minY
+   * @param {number} maxX
+   * @param {number} maxY
+   * @returns {number} A zero-based, incremental number that represents the newly added rectangle.
+   */
+  add(minX, minY, maxX = minX, maxY = minY) {
+    const index = this._pos >> 2;
+    const boxes = this._boxes;
+    this._indices[index] = index;
+    boxes[this._pos++] = minX;
+    boxes[this._pos++] = minY;
+    boxes[this._pos++] = maxX;
+    boxes[this._pos++] = maxY;
+    if (minX < this.minX) this.minX = minX;
+    if (minY < this.minY) this.minY = minY;
+    if (maxX > this.maxX) this.maxX = maxX;
+    if (maxY > this.maxY) this.maxY = maxY;
+    return index;
+  }
+  /** Perform indexing of the added rectangles. */
+  finish() {
+    if (this._pos >> 2 !== this.numItems) {
+      throw new Error(`Added ${this._pos >> 2} items when expected ${this.numItems}.`);
+    }
+    const boxes = this._boxes;
+    if (this.numItems <= this.nodeSize) {
+      boxes[this._pos++] = this.minX;
+      boxes[this._pos++] = this.minY;
+      boxes[this._pos++] = this.maxX;
+      boxes[this._pos++] = this.maxY;
+      return;
+    }
+    const width = this.maxX - this.minX || 1;
+    const height = this.maxY - this.minY || 1;
+    const hilbertValues = new Uint32Array(this.numItems);
+    const hilbertMax = (1 << 16) - 1;
+    for (let i = 0, pos = 0; i < this.numItems; i++) {
+      const minX = boxes[pos++];
+      const minY = boxes[pos++];
+      const maxX = boxes[pos++];
+      const maxY = boxes[pos++];
+      const x = Math.floor(hilbertMax * ((minX + maxX) / 2 - this.minX) / width);
+      const y = Math.floor(hilbertMax * ((minY + maxY) / 2 - this.minY) / height);
+      hilbertValues[i] = hilbert(x, y);
+    }
+    sort(hilbertValues, boxes, this._indices, 0, this.numItems - 1, this.nodeSize);
+    for (let i = 0, pos = 0; i < this._levelBounds.length - 1; i++) {
+      const end = this._levelBounds[i];
+      while (pos < end) {
+        const nodeIndex = pos;
+        let nodeMinX = boxes[pos++];
+        let nodeMinY = boxes[pos++];
+        let nodeMaxX = boxes[pos++];
+        let nodeMaxY = boxes[pos++];
+        for (let j = 1; j < this.nodeSize && pos < end; j++) {
+          nodeMinX = Math.min(nodeMinX, boxes[pos++]);
+          nodeMinY = Math.min(nodeMinY, boxes[pos++]);
+          nodeMaxX = Math.max(nodeMaxX, boxes[pos++]);
+          nodeMaxY = Math.max(nodeMaxY, boxes[pos++]);
+        }
+        this._indices[this._pos >> 2] = nodeIndex;
+        boxes[this._pos++] = nodeMinX;
+        boxes[this._pos++] = nodeMinY;
+        boxes[this._pos++] = nodeMaxX;
+        boxes[this._pos++] = nodeMaxY;
+      }
+    }
+  }
+  /**
+   * Search the index by a bounding box.
+   * @param {number} minX
+   * @param {number} minY
+   * @param {number} maxX
+   * @param {number} maxY
+   * @param {(index: number) => boolean} [filterFn] An optional function for filtering the results.
+   * @returns {number[]} An array of indices of items intersecting or touching the given bounding box.
+   */
+  search(minX, minY, maxX, maxY, filterFn) {
+    if (this._pos !== this._boxes.length) {
+      throw new Error("Data not yet indexed - call index.finish().");
+    }
+    let nodeIndex = this._boxes.length - 4;
+    const queue = [];
+    const results = [];
+    while (nodeIndex !== void 0) {
+      const end = Math.min(nodeIndex + this.nodeSize * 4, upperBound(nodeIndex, this._levelBounds));
+      for (let pos = nodeIndex; pos < end; pos += 4) {
+        if (maxX < this._boxes[pos]) continue;
+        if (maxY < this._boxes[pos + 1]) continue;
+        if (minX > this._boxes[pos + 2]) continue;
+        if (minY > this._boxes[pos + 3]) continue;
+        const index = this._indices[pos >> 2] | 0;
+        if (nodeIndex >= this.numItems * 4) {
+          queue.push(index);
+        } else if (filterFn === void 0 || filterFn(index)) {
+          results.push(index);
+        }
+      }
+      nodeIndex = queue.pop();
+    }
+    return results;
+  }
+  /**
+   * Search items in order of distance from the given point.
+   * @param {number} x
+   * @param {number} y
+   * @param {number} [maxResults=Infinity]
+   * @param {number} [maxDistance=Infinity]
+   * @param {(index: number) => boolean} [filterFn] An optional function for filtering the results.
+   * @returns {number[]} An array of indices of items found.
+   */
+  neighbors(x, y, maxResults = Infinity, maxDistance = Infinity, filterFn) {
+    if (this._pos !== this._boxes.length) {
+      throw new Error("Data not yet indexed - call index.finish().");
+    }
+    let nodeIndex = this._boxes.length - 4;
+    const q = this._queue;
+    const results = [];
+    const maxDistSquared = maxDistance * maxDistance;
+    outer: while (nodeIndex !== void 0) {
+      const end = Math.min(nodeIndex + this.nodeSize * 4, upperBound(nodeIndex, this._levelBounds));
+      for (let pos = nodeIndex; pos < end; pos += 4) {
+        const index = this._indices[pos >> 2] | 0;
+        const dx = axisDist(x, this._boxes[pos], this._boxes[pos + 2]);
+        const dy = axisDist(y, this._boxes[pos + 1], this._boxes[pos + 3]);
+        const dist = dx * dx + dy * dy;
+        if (dist > maxDistSquared) continue;
+        if (nodeIndex >= this.numItems * 4) {
+          q.push(index << 1, dist);
+        } else if (filterFn === void 0 || filterFn(index)) {
+          q.push((index << 1) + 1, dist);
+        }
+      }
+      while (q.length && q.peek() & 1) {
+        const dist = q.peekValue();
+        if (dist > maxDistSquared) break outer;
+        results.push(q.pop() >> 1);
+        if (results.length === maxResults) break outer;
+      }
+      nodeIndex = q.length ? q.pop() >> 1 : void 0;
+    }
+    q.clear();
+    return results;
+  }
+};
+function axisDist(k, min, max) {
+  return k < min ? min - k : k <= max ? 0 : k - max;
+}
+function upperBound(value, arr) {
+  let i = 0;
+  let j = arr.length - 1;
+  while (i < j) {
+    const m = i + j >> 1;
+    if (arr[m] > value) {
+      j = m;
+    } else {
+      i = m + 1;
+    }
+  }
+  return arr[i];
+}
+function sort(values, boxes, indices, left, right, nodeSize) {
+  if (Math.floor(left / nodeSize) >= Math.floor(right / nodeSize)) return;
+  const pivot = values[left + right >> 1];
+  let i = left - 1;
+  let j = right + 1;
+  while (true) {
+    do
+      i++;
+    while (values[i] < pivot);
+    do
+      j--;
+    while (values[j] > pivot);
+    if (i >= j) break;
+    swap2(values, boxes, indices, i, j);
+  }
+  sort(values, boxes, indices, left, j, nodeSize);
+  sort(values, boxes, indices, j + 1, right, nodeSize);
+}
+function swap2(values, boxes, indices, i, j) {
+  const temp = values[i];
+  values[i] = values[j];
+  values[j] = temp;
+  const k = 4 * i;
+  const m = 4 * j;
+  const a = boxes[k];
+  const b = boxes[k + 1];
+  const c = boxes[k + 2];
+  const d = boxes[k + 3];
+  boxes[k] = boxes[m];
+  boxes[k + 1] = boxes[m + 1];
+  boxes[k + 2] = boxes[m + 2];
+  boxes[k + 3] = boxes[m + 3];
+  boxes[m] = a;
+  boxes[m + 1] = b;
+  boxes[m + 2] = c;
+  boxes[m + 3] = d;
+  const e = indices[i];
+  indices[i] = indices[j];
+  indices[j] = e;
+}
+function hilbert(x, y) {
+  let a = x ^ y;
+  let b = 65535 ^ a;
+  let c = 65535 ^ (x | y);
+  let d = x & (y ^ 65535);
+  let A = a | b >> 1;
+  let B = a >> 1 ^ a;
+  let C = c >> 1 ^ b & d >> 1 ^ c;
+  let D = a & c >> 1 ^ d >> 1 ^ d;
+  a = A;
+  b = B;
+  c = C;
+  d = D;
+  A = a & a >> 2 ^ b & b >> 2;
+  B = a & b >> 2 ^ b & (a ^ b) >> 2;
+  C ^= a & c >> 2 ^ b & d >> 2;
+  D ^= b & c >> 2 ^ (a ^ b) & d >> 2;
+  a = A;
+  b = B;
+  c = C;
+  d = D;
+  A = a & a >> 4 ^ b & b >> 4;
+  B = a & b >> 4 ^ b & (a ^ b) >> 4;
+  C ^= a & c >> 4 ^ b & d >> 4;
+  D ^= b & c >> 4 ^ (a ^ b) & d >> 4;
+  a = A;
+  b = B;
+  c = C;
+  d = D;
+  C ^= a & c >> 8 ^ b & d >> 8;
+  D ^= b & c >> 8 ^ (a ^ b) & d >> 8;
+  a = C ^ C >> 1;
+  b = D ^ D >> 1;
+  let i0 = x ^ y;
+  let i1 = b | 65535 ^ (i0 | a);
+  i0 = (i0 | i0 << 8) & 16711935;
+  i0 = (i0 | i0 << 4) & 252645135;
+  i0 = (i0 | i0 << 2) & 858993459;
+  i0 = (i0 | i0 << 1) & 1431655765;
+  i1 = (i1 | i1 << 8) & 16711935;
+  i1 = (i1 | i1 << 4) & 252645135;
+  i1 = (i1 | i1 << 2) & 858993459;
+  i1 = (i1 | i1 << 1) & 1431655765;
+  return (i1 << 1 | i0) >>> 0;
+}
+
+// lib/data-structures/FlatbushIndex.ts
+var FlatbushIndex = class {
+  index;
+  items = [];
+  currentIndex = 0;
+  constructor(numItems) {
+    this.index = new Flatbush(numItems);
+  }
+  insert(item, minX, minY, maxX, maxY) {
+    if (this.currentIndex >= this.index.numItems) {
+      throw new Error("Exceeded initial capacity");
+    }
+    this.items[this.currentIndex] = item;
+    this.index.add(minX, minY, maxX, maxY);
+    this.currentIndex++;
+  }
+  finish() {
+    this.index.finish();
+  }
+  search(minX, minY, maxX, maxY) {
+    const ids = this.index.search(minX, minY, maxX, maxY);
+    return ids.map((id) => this.items[id] || null).filter(Boolean);
+  }
+  clear() {
+    this.items = [];
+    this.index = new Flatbush(0);
+  }
+};
+
 // lib/data-structures/ObstacleTree.ts
 var ObstacleSpatialHashIndex = class {
+  idx;
+  storage = [];
+  constructor(implementation = "native", obstacles = []) {
+    if (implementation === "flatbush") {
+      this.idx = new FlatbushIndex(obstacles.length);
+    } else if (implementation === "rbush") {
+      this.idx = new RbushIndex();
+    } else {
+      this.idx = new class {
+        shi = new NativeObstacleTree(obstacles);
+        insert(item) {
+        }
+        search(minX, minY, maxX, maxY) {
+          const centerX = (minX + maxX) / 2;
+          const centerY = (minY + maxY) / 2;
+          const width = maxX - minX;
+          const height = maxY - minY;
+          return this.shi.getNodesInArea(centerX, centerY, width, height);
+        }
+        clear() {
+        }
+      }();
+    }
+    obstacles.forEach((o) => this.insert(o));
+    if (implementation === "flatbush") this.idx.finish?.();
+  }
+  insert(o) {
+    this.storage.push(o);
+    this.idx.insert(
+      o,
+      o.center.x - o.width / 2,
+      o.center.y - o.height / 2,
+      o.center.x + o.width / 2,
+      o.center.y + o.height / 2
+    );
+  }
+  search(bbox) {
+    return this.idx.search(bbox.minX, bbox.minY, bbox.maxX, bbox.maxY);
+  }
+  searchArea(centerX, centerY, width, height) {
+    return this.search({
+      minX: centerX - width / 2,
+      minY: centerY - height / 2,
+      maxX: centerX + width / 2,
+      maxY: centerY + height / 2
+    });
+  }
+};
+var NativeObstacleTree = class {
   constructor(obstacles) {
     this.obstacles = obstacles;
     this.buckets = /* @__PURE__ */ new Map();
@@ -1115,7 +2046,10 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
     ];
     this.finishedNodes = [];
     this.nodeToXYOverlappingObstaclesMap = /* @__PURE__ */ new Map();
-    this.obstacleTree = new ObstacleSpatialHashIndex(this.srj.obstacles);
+    this.obstacleTree = new ObstacleSpatialHashIndex(
+      "flatbush",
+      this.srj.obstacles
+    );
     this.targets = this.computeTargets();
     this.targetTree = new TargetTree(this.targets);
   }
@@ -1132,7 +2066,7 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
     const targets = [];
     for (const conn of this.srj.connections) {
       for (const ptc of conn.pointsToConnect) {
-        const obstacles = this.obstacleTree.getNodesInArea(ptc.x, ptc.y, 0.01, 0.01).filter(
+        const obstacles = this.obstacleTree.searchArea(ptc.x, ptc.y, 0.01, 0.01).filter(
           (o) => o.zLayers.some((z) => ptc.layer === "top" ? z === 0 : z === 1)
         );
         let bounds = {
@@ -1972,7 +2906,7 @@ var CapacitySegmentToPointSolver = class extends BaseSolver {
   }
 };
 
-// node_modules/@tscircuit/math-utils/dist/chunk-CHQOCSFB.js
+// node_modules/@tscircuit/math-utils/dist/chunk-3453HRP7.js
 function doSegmentsIntersect(p1, q1, p2, q2) {
   const o1 = orientation(p1, q1, p2);
   const o2 = orientation(p1, q1, q2);
@@ -2044,7 +2978,7 @@ function clamp(value, min, max) {
   return Math.max(min, Math.min(max, value));
 }
 
-// node_modules/@tscircuit/math-utils/dist/chunk-RNQKFERU.js
+// node_modules/@tscircuit/math-utils/dist/chunk-FWQGMQBW.js
 function segmentToSegmentMinDistance(a, b, u, v) {
   if (a.x === b.x && a.y === b.y) {
     return pointToSegmentDistance(a, u, v);
@@ -3078,12 +4012,15 @@ var HyperParameterSupervisorSolver = class extends BaseSolver {
     }
     return bestSolver;
   }
+  getFailureMessage() {
+    return "All solvers failed in hyper solver.";
+  }
   _step() {
     if (!this.supervisedSolvers) this.initializeSolvers();
     const supervisedSolver = this.getSupervisedSolverWithBestFitness();
     if (!supervisedSolver) {
       this.failed = true;
-      this.error = "All solvers failed";
+      this.error = this.getFailureMessage();
       return;
     }
     for (let i = 0; i < this.MIN_SUBSTEPS; i++) {
@@ -5332,10 +6269,13 @@ var Vertex = class {
   y;
   out;
   // Outgoing half-edge indices
+  connectionNames;
+  // Names of connections passing through this vertex
   constructor(x, y) {
     this.x = x;
     this.y = y;
     this.out = [];
+    this.connectionNames = /* @__PURE__ */ new Set();
   }
 };
 var HalfEdge = class {
@@ -5419,9 +6359,17 @@ function getCentroidsFromInnerBoxIntersections(rectangle, userSegments) {
       return t1 - t2;
     });
     for (let k = 0; k < list.length - 1; ++k) {
-      const v1 = getVertexId(list[k]);
-      const v2 = getVertexId(list[k + 1]);
-      if (v1 !== v2) undirectedEdges.push([v1, v2]);
+      const p1 = list[k];
+      const p2 = list[k + 1];
+      const v1 = getVertexId(p1);
+      const v2 = getVertexId(p2);
+      if (v1 !== v2) {
+        undirectedEdges.push([v1, v2]);
+        if (s.connectionName) {
+          vertices[v1].connectionNames.add(s.connectionName);
+          vertices[v2].connectionNames.add(s.connectionName);
+        }
+      }
     }
   }
   const halfEdges = [];
@@ -5478,8 +6426,11 @@ function getCentroidsFromInnerBoxIntersections(rectangle, userSegments) {
       if (c) {
         centroids.push(c);
         faces.push({
-          vertices: poly.map((p) => ({ x: p.x, y: p.y })),
-          // Convert Vertex back to simple Point
+          vertices: poly.map((v) => ({
+            x: v.x,
+            y: v.y,
+            connectionNames: v.connectionNames.size > 0 ? v.connectionNames : void 0
+          })),
           centroid: c
         });
       }
@@ -6065,6 +7016,7 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
   obstacleMargin = 0.1;
   traceWidth = 0.15;
   availableZ = [];
+  uniqueConnections = 0;
   lastCandidate = null;
   maxViaCount;
   minViaCount;
@@ -6092,6 +7044,7 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
     const uniqueConnections = new Set(
       this.nodeWithPortPoints.portPoints.map((pp) => pp.connectionName)
     ).size;
+    this.uniqueConnections = uniqueConnections;
     const { numSameLayerCrossings, numTransitions } = getIntraNodeCrossings(
       this.nodeWithPortPoints
     );
@@ -6100,11 +7053,6 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
       Math.floor(areaInsideNode / areaPerVia),
       Math.ceil(uniqueConnections * 1.5)
     );
-    if (uniqueConnections > 5) {
-      this.failed = true;
-      this.error = `Limit is currently set to 6 unique connections, ${uniqueConnections} found`;
-      return;
-    }
     if (this.minViaCount > this.SEGMENTS_PER_POLYLINE * (uniqueConnections / 2)) {
       this.failed = true;
       this.error = `Not possible to solve problem with given SEGMENTS_PER_POLYLINE (${this.SEGMENTS_PER_POLYLINE}), atleast ${this.minViaCount} vias are required`;
@@ -6843,7 +7791,7 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
             strokeColor: segmentColor,
             strokeWidth: this.traceWidth,
             // TODO: Use actual trace thickness from HighDensityRoute?
-            strokeDash: !isLayer0 ? "5,5" : void 0,
+            strokeDash: !isLayer0 ? [0.15, 0.15] : void 0,
             // Dashed for layers > 0
             label: `${polyLine.connectionName} segment (z=${segmentLayer})`
           });
@@ -7572,7 +8520,7 @@ var HighDensitySolver = class extends BaseSolver {
       if (this.failedSolvers.length > 0) {
         this.solved = false;
         this.failed = true;
-        this.error = `Failed to solve ${this.failedSolvers.length} nodes`;
+        this.error = `Failed to solve ${this.failedSolvers.length} nodes, ${this.failedSolvers.slice(0, 5).map((fs) => fs.nodeWithPortPoints.capacityMeshNodeId)}`;
         return;
       }
       this.solved = true;
@@ -7644,7 +8592,8 @@ var HighDensitySolver = class extends BaseSolver {
           graphics.lines.push({
             points: [start, end],
             strokeColor: "red",
-            strokeDash: "10, 5"
+            strokeDash: "10, 5",
+            layer: "did_not_connect"
           });
         }
       }
@@ -8128,7 +9077,7 @@ var SingleHighDensityRouteStitchSolver = class extends BaseSolver {
     super();
     this.remainingHdRoutes = [...opts.hdRoutes];
     this.colorMap = opts.colorMap ?? {};
-    const firstRoute = this.remainingHdRoutes[0];
+    const { firstRoute } = this.getDisjointedRoute();
     const firstRouteToStartDist = Math.min(
       distance(firstRoute.route[0], opts.start),
       distance(firstRoute.route[firstRoute.route.length - 1], opts.start)
@@ -8154,10 +9103,42 @@ var SingleHighDensityRouteStitchSolver = class extends BaseSolver {
         }
       ],
       vias: [],
-      viaDiameter: opts.hdRoutes?.[0]?.viaDiameter ?? 0.6,
-      traceThickness: opts.hdRoutes?.[0]?.traceThickness ?? 0.15
+      viaDiameter: firstRoute.viaDiameter,
+      traceThickness: firstRoute.traceThickness
     };
   }
+  /**
+   * Scan `remainingHdRoutes` and find a route that has **one** end that is not
+   * within `5e-6` of the start or end of any other route on the same layer.
+   * That “lonely” end marks one extremity of the whole chain, which we use as
+   * our starting segment. If no such route exists (e.g., the data form a loop),
+   * we simply return the first route so the solver can proceed.
+   */
+  getDisjointedRoute() {
+    const TOL = 5e-6;
+    for (const candidate of this.remainingHdRoutes) {
+      const candidateEnds = [
+        candidate.route[0],
+        candidate.route[candidate.route.length - 1]
+      ];
+      const hasLonelyEnd = candidateEnds.some((end) => {
+        return !this.remainingHdRoutes.some((other) => {
+          if (other === candidate) return false;
+          const otherEnds = [
+            other.route[0],
+            other.route[other.route.length - 1]
+          ];
+          return otherEnds.some(
+            (oe) => oe.z === end.z && distance(end, oe) < TOL
+          );
+        });
+      });
+      if (hasLonelyEnd) {
+        return { firstRoute: candidate };
+      }
+    }
+    return { firstRoute: this.remainingHdRoutes[0] };
+  }
   _step() {
     if (this.remainingHdRoutes.length === 0) {
       this.mergedHdRoute.route.push({
@@ -10514,7 +11495,7 @@ ${percent}% (Pf: ${(probabilityOfFailure * 100).toFixed(1)}%)`;
 }
 
 // lib/solvers/CapacityPathingSectionSolver/CapacityPathingSingleSectionPathingSolver.ts
-var CapacityPathingSingleSectionPathingSolver = class extends BaseSolver {
+var CapacityPathingSingleSectionSolver = class extends BaseSolver {
   GREEDY_MULTIPLIER = 1.5;
   sectionNodes;
   sectionEdges;
@@ -10526,6 +11507,7 @@ var CapacityPathingSingleSectionPathingSolver = class extends BaseSolver {
   colorMap;
   usedNodeCapacityMap;
   // Tracks capacity usage *within this solver's run*
+  centerNodeId;
   MAX_CANDIDATES_IN_MEMORY = 1e4;
   // A* state
   currentConnectionIndex = 0;
@@ -10539,6 +11521,7 @@ var CapacityPathingSingleSectionPathingSolver = class extends BaseSolver {
   // Default, similar to CapacityPathingSolver5
   constructor(params) {
     super();
+    this.centerNodeId = params.centerNodeId;
     this.sectionNodes = params.sectionNodes;
     this.sectionEdges = params.sectionEdges;
     this.sectionConnectionTerminals = params.sectionConnectionTerminals.map(
@@ -10712,6 +11695,28 @@ var CapacityPathingSingleSectionPathingSolver = class extends BaseSolver {
       candidates.push(newCandidate);
     }
   }
+  computeProgress() {
+    const totalConnections = this.sectionConnectionTerminals.length;
+    if (totalConnections === 0) return 1;
+    const completedConnections = this.currentConnectionIndex;
+    let progress = completedConnections / totalConnections;
+    if (this.currentConnectionIndex < totalConnections && this.candidates && this.candidates.length > 0 && this.activeCandidateStraightLineDistance && this.activeCandidateStraightLineDistance > 0) {
+      const bestCandidate = this.candidates.reduce(
+        (best, current) => current.f < best.f ? current : best
+      );
+      const currentConnectionProgress = Math.max(
+        0,
+        Math.min(
+          1,
+          1 - bestCandidate.h / this.activeCandidateStraightLineDistance
+        )
+      );
+      progress += currentConnectionProgress / totalConnections;
+    } else if (this.solved) {
+      progress = 1;
+    }
+    return Math.min(1, progress);
+  }
   _setupAStar(startNode, endNode) {
     this.candidates = [
       { prevCandidate: null, node: startNode, f: 0, g: 0, h: 0 }
@@ -10816,133 +11821,157 @@ var CapacityPathingSingleSectionPathingSolver = class extends BaseSolver {
     return baseGraphics;
   }
 };
+var CapacityPathingSingleSectionPathingSolver = CapacityPathingSingleSectionSolver;
 
-// lib/solvers/CapacityPathingSectionSolver/CapacityPathingSingleSectionSolver.ts
-var CapacityPathingSingleSectionSolver = class extends BaseSolver {
-  centerNodeId;
-  connectionsWithNodes;
-  nodes;
-  nodeMap;
-  edges;
-  nodeEdgeMap;
-  expansionDegrees;
-  colorMap;
-  sectionNodes;
-  sectionEdges;
-  // Added sectionEdges property
-  sectionConnectionTerminals;
-  activeSubSolver = null;
+// lib/solvers/CapacityPathingSectionSolver/HyperCapacityPathingSingleSectionSolver.ts
+var HyperCapacityPathingSingleSectionSolver = class extends HyperParameterSupervisorSolver {
+  constructorParams;
+  winningSolver;
   constructor(params) {
     super();
-    this.MAX_ITERATIONS = 1e5;
-    this.colorMap = params.colorMap;
-    this.centerNodeId = params.centerNodeId;
-    this.connectionsWithNodes = params.connectionsWithNodes;
-    this.nodes = params.nodes;
-    this.nodeMap = new Map(this.nodes.map((n) => [n.capacityMeshNodeId, n]));
-    this.edges = params.edges;
-    this.nodeEdgeMap = getNodeEdgeMap(this.edges);
-    this.expansionDegrees = params.hyperParameters?.EXPANSION_DEGREES ?? 3;
-    this.sectionNodes = [];
-    this.sectionEdges = [];
-    this.sectionConnectionTerminals = [];
-    this.computeSectionNodesTerminalsAndEdges();
-    this.activeSubSolver = new CapacityPathingSingleSectionPathingSolver({
-      sectionConnectionTerminals: this.sectionConnectionTerminals,
-      sectionNodes: this.sectionNodes,
-      sectionEdges: this.sectionEdges,
-      colorMap: this.colorMap,
-      hyperParameters: params.hyperParameters
-    });
+    this.MAX_ITERATIONS = 1e4;
+    this.constructorParams = params;
   }
-  computeSectionNodesTerminalsAndEdges() {
-    const sectionNodeIds = /* @__PURE__ */ new Set();
-    const queue = [
-      { nodeId: this.centerNodeId, depth: 0 }
-    ];
-    sectionNodeIds.add(this.centerNodeId);
-    let head = 0;
-    while (head < queue.length) {
-      const { nodeId, depth } = queue[head++];
-      if (depth >= this.expansionDegrees) continue;
-      const neighbors = this.nodeEdgeMap.get(nodeId)?.flatMap((edge) => edge.nodeIds.filter((id) => id !== nodeId)) ?? [];
-      for (const neighborId of neighbors) {
-        if (!sectionNodeIds.has(neighborId)) {
-          sectionNodeIds.add(neighborId);
-          queue.push({ nodeId: neighborId, depth: depth + 1 });
-        }
-      }
-    }
-    this.sectionNodes = Array.from(sectionNodeIds).map(
-      (id) => this.nodeMap.get(id)
-    );
-    this.sectionEdges = this.edges.filter((edge) => {
-      const [nodeIdA, nodeIdB] = edge.nodeIds;
-      return sectionNodeIds.has(nodeIdA) && sectionNodeIds.has(nodeIdB);
-    });
-    this.sectionConnectionTerminals = [];
-    for (const conn of this.connectionsWithNodes) {
-      if (!conn.path) continue;
-      let startNodeId = null;
-      let endNodeId = null;
-      for (const node of conn.path) {
-        if (sectionNodeIds.has(node.capacityMeshNodeId)) {
-          startNodeId = node.capacityMeshNodeId;
-          break;
-        }
-      }
-      for (let i = conn.path.length - 1; i >= 0; i--) {
-        const node = conn.path[i];
-        if (sectionNodeIds.has(node.capacityMeshNodeId)) {
-          endNodeId = node.capacityMeshNodeId;
-          break;
-        }
-      }
-      if (startNodeId && endNodeId) {
-        this.sectionConnectionTerminals.push({
-          connectionName: conn.connection.name,
-          startNodeId,
-          endNodeId
-        });
-      }
-    }
+  computeG(solver) {
+    return solver.iterations / 100;
   }
-  _step() {
-    this.activeSubSolver?.step();
-    if (this.activeSubSolver?.solved) {
-      this.solved = true;
-      return;
-    }
-    if (this.activeSubSolver?.failed) {
-      this.failed = true;
-      this.error = this.activeSubSolver.error;
-      return;
-    }
+  computeH(solver) {
+    return solver.computeProgress();
   }
-  getConstructorParams() {
+  getCombinationDefs() {
+    return [["orderings10"]];
+  }
+  getFailureMessage() {
+    return `All CapacityPathingSingleSection solvers failed for "${this.centerNodeId}"`;
+  }
+  getHyperParameterDefs() {
     return [
       {
-        centerNodeId: this.centerNodeId,
-        connectionsWithNodes: this.connectionsWithNodes,
-        nodes: this.nodes,
-        edges: this.edges,
-        expansionDegrees: this.expansionDegrees
+        name: "orderings10",
+        possibleValues: [
+          {
+            SHUFFLE_SEED: 0
+          },
+          {
+            SHUFFLE_SEED: 1
+          },
+          {
+            SHUFFLE_SEED: 2
+          },
+          {
+            SHUFFLE_SEED: 3
+          },
+          {
+            SHUFFLE_SEED: 4
+          },
+          {
+            SHUFFLE_SEED: 5
+          },
+          {
+            SHUFFLE_SEED: 6
+          },
+          {
+            SHUFFLE_SEED: 7
+          },
+          {
+            SHUFFLE_SEED: 8
+          },
+          {
+            SHUFFLE_SEED: 9
+          }
+        ]
       }
     ];
   }
-  visualize() {
-    return visualizeSection({
-      sectionNodes: this.sectionNodes,
-      sectionEdges: this.sectionEdges,
-      // Use the computed class property
-      sectionConnectionTerminals: this.sectionConnectionTerminals,
-      nodeMap: this.nodeMap,
-      colorMap: this.colorMap,
-      centerNodeId: this.centerNodeId,
-      nodeOpacity: 1e-3,
-      title: `Section Solver (Center: ${this.centerNodeId}, Hops: ${this.expansionDegrees})`
+  generateSolver(hyperParameters) {
+    return new CapacityPathingSingleSectionPathingSolver({
+      ...this.constructorParams,
+      hyperParameters: {
+        ...this.constructorParams.hyperParameters,
+        ...hyperParameters
+      }
     });
   }
+  onSolve({
+    solver
+  }) {
+    this.winningSolver = solver;
+  }
+  get centerNodeId() {
+    return this.constructorParams.centerNodeId;
+  }
+  get sectionNodes() {
+    return this.constructorParams.sectionNodes;
+  }
+  get sectionConnectionTerminals() {
+    return this.winningSolver?.sectionConnectionTerminals;
+  }
+};
+
+// lib/solvers/CapacityPathingSectionSolver/computeSectionNodesTerminalsAndEdges.ts
+var computeSectionNodesTerminalsAndEdges = (opts) => {
+  const {
+    centerNodeId,
+    connectionsWithNodes,
+    nodeMap,
+    edges,
+    nodeEdgeMap,
+    expansionDegrees
+  } = opts;
+  const sectionNodeIds = /* @__PURE__ */ new Set();
+  const queue = [
+    { nodeId: centerNodeId, depth: 0 }
+  ];
+  sectionNodeIds.add(centerNodeId);
+  let head = 0;
+  while (head < queue.length) {
+    const { nodeId, depth } = queue[head++];
+    if (depth >= expansionDegrees) continue;
+    const neighbors = nodeEdgeMap.get(nodeId)?.flatMap((edge) => edge.nodeIds.filter((id) => id !== nodeId)) ?? [];
+    for (const neighborId of neighbors) {
+      if (!sectionNodeIds.has(neighborId)) {
+        sectionNodeIds.add(neighborId);
+        queue.push({ nodeId: neighborId, depth: depth + 1 });
+      }
+    }
+  }
+  const sectionNodes = Array.from(sectionNodeIds).map((id) => nodeMap.get(id));
+  const sectionEdges = edges.filter((edge) => {
+    const [nodeIdA, nodeIdB] = edge.nodeIds;
+    return sectionNodeIds.has(nodeIdA) && sectionNodeIds.has(nodeIdB);
+  });
+  const sectionConnectionTerminals = [];
+  for (const conn of connectionsWithNodes) {
+    if (!conn.path) continue;
+    let startNodeId = null;
+    let endNodeId = null;
+    for (const node of conn.path) {
+      if (sectionNodeIds.has(node.capacityMeshNodeId)) {
+        startNodeId = node.capacityMeshNodeId;
+        break;
+      }
+    }
+    for (let i = conn.path.length - 1; i >= 0; i--) {
+      const node = conn.path[i];
+      if (sectionNodeIds.has(node.capacityMeshNodeId)) {
+        endNodeId = node.capacityMeshNodeId;
+        break;
+      }
+    }
+    if (startNodeId && endNodeId) {
+      sectionConnectionTerminals.push({
+        connectionName: conn.connection.name,
+        startNodeId,
+        endNodeId
+      });
+    }
+  }
+  return {
+    sectionConnectionTerminals,
+    sectionNodes,
+    sectionEdges,
+    centerNodeId
+  };
 };
 
 // lib/solvers/CapacityPathingSectionSolver/CapacityPathingMultiSectionSolver.ts
@@ -10950,6 +11979,7 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
   simpleRouteJson;
   nodes;
   edges;
+  nodeEdgeMap;
   connectionsWithNodes = [];
   // Initialize here
   colorMap;
@@ -10961,6 +11991,7 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
   // Added
   nodeCapacityPercentMap = /* @__PURE__ */ new Map();
   nodeOptimizationAttemptCountMap = /* @__PURE__ */ new Map();
+  currentSection = null;
   sectionSolver = null;
   MAX_ATTEMPTS_PER_NODE = 10;
   MINIMUM_PROBABILITY_OF_FAILURE_TO_OPTIMIZE = 0.05;
@@ -10975,6 +12006,7 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
     this.nodeMap = new Map(
       this.nodes.map((node) => [node.capacityMeshNodeId, node])
     );
+    this.nodeEdgeMap = getNodeEdgeMap(this.edges);
     this.initialSolver = new CapacityPathingGreedySolver({
       simpleRouteJson: this.simpleRouteJson,
       nodes: this.nodes,
@@ -11040,16 +12072,21 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
         this.solved = true;
         return;
       }
-      this.sectionSolver = new CapacityPathingSingleSectionSolver({
+      const section = computeSectionNodesTerminalsAndEdges({
         centerNodeId,
         connectionsWithNodes: this.connectionsWithNodes,
-        nodes: this.nodes,
+        nodeMap: this.nodeMap,
         edges: this.edges,
+        expansionDegrees: this.MAX_EXPANSION_DEGREES,
+        nodeEdgeMap: this.nodeEdgeMap
+      });
+      this.currentSection = section;
+      this.sectionSolver = new HyperCapacityPathingSingleSectionSolver({
+        sectionConnectionTerminals: section.sectionConnectionTerminals,
+        sectionEdges: section.sectionEdges,
+        sectionNodes: section.sectionNodes,
         colorMap: this.colorMap,
-        hyperParameters: {
-          EXPANSION_DEGREES: this.MAX_EXPANSION_DEGREES,
-          SHUFFLE_SEED: this.iterations
-        }
+        centerNodeId: section.centerNodeId
       });
       this.activeSubSolver = this.sectionSolver;
       this.nodeOptimizationAttemptCountMap.set(
@@ -11060,7 +12097,7 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
     this.sectionSolver.step();
     if (this.sectionSolver.failed) {
       console.warn(
-        `Section solver failed for node ${this.sectionSolver.centerNodeId}. Error: ${this.sectionSolver.error}`
+        `Section solver failed for node ${this.currentSection.centerNodeId}. Error: ${this.sectionSolver.error}`
       );
       this.sectionSolver = null;
       this.activeSubSolver = null;
@@ -11068,12 +12105,12 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
     }
     if (this.sectionSolver.solved) {
       const solvedSectionSolver = this.sectionSolver;
-      const pathingSolver = solvedSectionSolver.activeSubSolver;
+      const pathingSolver = solvedSectionSolver?.activeSubSolver || solvedSectionSolver;
       this.sectionSolver = null;
       this.activeSubSolver = null;
       if (!pathingSolver || !pathingSolver.solved) {
         console.warn(
-          `Pathing sub-solver for section ${solvedSectionSolver.centerNodeId} did not complete successfully. Discarding results.`
+          `Pathing sub-solver for section ${this.currentSection.centerNodeId} did not complete successfully. Discarding results.`
         );
         return;
       }
@@ -11134,18 +12171,18 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
    * connectionsWithNodes list.
    */
   _mergeSolvedSectionPaths(solvedSectionSolver) {
-    const pathingSolver = solvedSectionSolver.activeSubSolver;
-    if (!pathingSolver || !pathingSolver.solved) {
+    const centerNodeId = solvedSectionSolver.centerNodeId;
+    if (!solvedSectionSolver || !solvedSectionSolver.solved) {
       console.warn(
-        `Pathing sub-solver for section ${solvedSectionSolver.centerNodeId} did not complete successfully. Skipping merge.`
+        `Pathing sub-solver for section ${centerNodeId} did not complete successfully. Skipping merge.`
       );
       return;
     }
-    const solvedTerminals = pathingSolver.sectionConnectionTerminals;
+    const solvedTerminals = solvedSectionSolver.sectionConnectionTerminals;
     for (const solvedTerminal of solvedTerminals) {
       if (!solvedTerminal.path) {
         console.warn(
-          `No path found for connection ${solvedTerminal.connectionName} in section ${solvedSectionSolver.centerNodeId}`
+          `No path found for connection ${solvedTerminal.connectionName} in section ${centerNodeId}`
         );
         continue;
       }
@@ -13299,7 +14336,7 @@ var SingleRouteUselessViaRemovalSolver = class extends BaseSolver {
         width: Math.abs(A.x - B.x),
         height: Math.abs(A.y - B.y)
       };
-      const obstacles = this.obstacleSHI.getNodesInArea(
+      const obstacles = this.obstacleSHI.searchArea(
         segmentBox.centerX,
         segmentBox.centerY,
         segmentBox.width + (this.TRACE_THICKNESS + this.OBSTACLE_MARGIN) * 2,
@@ -13372,7 +14409,7 @@ var UselessViaRemovalSolver = class extends BaseSolver {
     this.unsimplifiedHdRoutes = input.unsimplifiedHdRoutes;
     this.optimizedHdRoutes = [];
     this.unprocessedRoutes = [...input.unsimplifiedHdRoutes];
-    this.obstacleSHI = new ObstacleSpatialHashIndex(input.obstacles);
+    this.obstacleSHI = new ObstacleSpatialHashIndex("flatbush", input.obstacles);
     this.hdRouteSHI = new HighDensityRouteSpatialIndex(
       this.unsimplifiedHdRoutes
     );