@tscircuit/capacity-autorouter 0.0.54 → 0.0.55

package/dist/index.js

@@ -968,8 +968,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 +2042,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 +2062,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 = {
@@ -8128,7 +9058,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 +9084,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({
@@ -13299,7 +14261,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 +14334,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
     );