@tscircuit/capacity-autorouter 0.0.2 → 0.0.4

package/dist/index.js

@@ -0,0 +1,4188 @@
+// lib/utils/combineVisualizations.ts
+var combineVisualizations = (...visualizations) => {
+  const combined = {
+    points: [],
+    lines: [],
+    circles: [],
+    rects: []
+  };
+  visualizations.forEach((viz, i) => {
+    if (viz.lines) {
+      combined.lines = [
+        ...combined.lines || [],
+        ...viz.lines.map((l) => ({ ...l, step: i }))
+      ];
+    }
+    if (viz.points) {
+      combined.points = [
+        ...combined.points || [],
+        ...viz.points.map((p) => ({ ...p, step: i }))
+      ];
+    }
+    if (viz.circles) {
+      combined.circles = [
+        ...combined.circles || [],
+        ...viz.circles.map((c) => ({ ...c, step: i }))
+      ];
+    }
+    if (viz.rects) {
+      combined.rects = [
+        ...combined.rects || [],
+        ...viz.rects.map((r) => ({ ...r, step: i }))
+      ];
+    }
+  });
+  return combined;
+};
+
+// lib/solvers/BaseSolver.ts
+var BaseSolver = class {
+  MAX_ITERATIONS = 1e3;
+  solved = false;
+  failed = false;
+  iterations = 0;
+  progress = 0;
+  error = null;
+  /** DO NOT OVERRIDE! Override _step() instead */
+  step() {
+    if (this.solved) return;
+    if (this.failed) return;
+    this.iterations++;
+    try {
+      this._step();
+    } catch (e) {
+      this.error = `${this.constructor.name} error: ${e}`;
+      console.error(this.error);
+      this.failed = true;
+      throw e;
+    }
+    if (!this.solved && this.iterations > this.MAX_ITERATIONS) {
+      this.error = `${this.constructor.name} did not converge`;
+      console.error(this.error);
+      this.failed = true;
+    }
+  }
+  _step() {
+  }
+  solve() {
+    while (!this.solved && !this.failed) {
+      this.step();
+    }
+  }
+  visualize() {
+    return {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: []
+    };
+  }
+};
+
+// node_modules/@tscircuit/math-utils/dist/chunk-CHQOCSFB.js
+function doSegmentsIntersect(p1, q1, p2, q2) {
+  const o1 = orientation(p1, q1, p2);
+  const o2 = orientation(p1, q1, q2);
+  const o3 = orientation(p2, q2, p1);
+  const o4 = orientation(p2, q2, q1);
+  if (o1 !== o2 && o3 !== o4) {
+    return true;
+  }
+  if (o1 === 0 && onSegment(p1, p2, q1)) return true;
+  if (o2 === 0 && onSegment(p1, q2, q1)) return true;
+  if (o3 === 0 && onSegment(p2, p1, q2)) return true;
+  if (o4 === 0 && onSegment(p2, q1, q2)) return true;
+  return false;
+}
+function orientation(p, q, r) {
+  const val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+  if (val === 0) return 0;
+  return val > 0 ? 1 : 2;
+}
+function onSegment(p, q, r) {
+  return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+}
+function pointToSegmentDistance(p, v, w) {
+  const l2 = (w.x - v.x) ** 2 + (w.y - v.y) ** 2;
+  if (l2 === 0) return distance(p, v);
+  let t = ((p.x - v.x) * (w.x - v.x) + (p.y - v.y) * (w.y - v.y)) / l2;
+  t = Math.max(0, Math.min(1, t));
+  const projection = {
+    x: v.x + t * (w.x - v.x),
+    y: v.y + t * (w.y - v.y)
+  };
+  return distance(p, projection);
+}
+function distance(p1, p2) {
+  const dx = p1.x - p2.x;
+  const dy = p1.y - p2.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
+// lib/solvers/CapacityMeshSolver/CapacityMeshEdgeSolver.ts
+var CapacityMeshEdgeSolver = class extends BaseSolver {
+  constructor(nodes) {
+    super();
+    this.nodes = nodes;
+    this.edges = [];
+  }
+  edges;
+  getNextCapacityMeshEdgeId() {
+    return `ce${this.edges.length}`;
+  }
+  step() {
+    this.edges = [];
+    for (let i = 0; i < this.nodes.length; i++) {
+      for (let j = i + 1; j < this.nodes.length; j++) {
+        if (this.areNodesBordering(this.nodes[i], this.nodes[j])) {
+          this.edges.push({
+            capacityMeshEdgeId: this.getNextCapacityMeshEdgeId(),
+            nodeIds: [
+              this.nodes[i].capacityMeshNodeId,
+              this.nodes[j].capacityMeshNodeId
+            ]
+          });
+        }
+      }
+    }
+    const targetNodes = this.nodes.filter((node) => node._containsTarget);
+    for (const targetNode of targetNodes) {
+      const hasEdge = this.edges.some(
+        (edge) => edge.nodeIds.includes(targetNode.capacityMeshNodeId)
+      );
+      if (hasEdge) continue;
+      let nearestNode = null;
+      let nearestDistance = Infinity;
+      for (const node of this.nodes) {
+        if (node._containsObstacle) continue;
+        if (node._containsTarget) continue;
+        const dist = distance(targetNode.center, node.center);
+        if (dist < nearestDistance) {
+          nearestDistance = dist;
+          nearestNode = node;
+        }
+      }
+      if (nearestNode) {
+        this.edges.push({
+          capacityMeshEdgeId: this.getNextCapacityMeshEdgeId(),
+          nodeIds: [
+            targetNode.capacityMeshNodeId,
+            nearestNode.capacityMeshNodeId
+          ]
+        });
+      }
+    }
+    this.solved = true;
+  }
+  areNodesBordering(node1, node2) {
+    const n1Left = node1.center.x - node1.width / 2;
+    const n1Right = node1.center.x + node1.width / 2;
+    const n1Top = node1.center.y - node1.height / 2;
+    const n1Bottom = node1.center.y + node1.height / 2;
+    const n2Left = node2.center.x - node2.width / 2;
+    const n2Right = node2.center.x + node2.width / 2;
+    const n2Top = node2.center.y - node2.height / 2;
+    const n2Bottom = node2.center.y + node2.height / 2;
+    const epsilon = 1e-3;
+    const shareVerticalBorder = (Math.abs(n1Right - n2Left) < epsilon || Math.abs(n1Left - n2Right) < epsilon) && Math.min(n1Bottom, n2Bottom) - Math.max(n1Top, n2Top) >= epsilon;
+    const shareHorizontalBorder = (Math.abs(n1Bottom - n2Top) < epsilon || Math.abs(n1Top - n2Bottom) < epsilon) && Math.min(n1Right, n2Right) - Math.max(n1Left, n2Left) >= epsilon;
+    return shareVerticalBorder || shareHorizontalBorder;
+  }
+  visualize() {
+    const graphics = {
+      lines: [],
+      points: [],
+      rects: this.nodes.map((node) => ({
+        width: Math.max(node.width - 2, node.width * 0.8),
+        height: Math.max(node.height - 2, node.height * 0.8),
+        center: node.center,
+        fill: node._containsObstacle ? "rgba(255,0,0,0.1)" : node._containsTarget ? "rgba(0,255,0,0.2)" : "rgba(0,0,0,0.1)"
+      })),
+      circles: []
+    };
+    for (const edge of this.edges) {
+      const node1 = this.nodes.find(
+        (node) => node.capacityMeshNodeId === edge.nodeIds[0]
+      );
+      const node2 = this.nodes.find(
+        (node) => node.capacityMeshNodeId === edge.nodeIds[1]
+      );
+      if (node1?.center && node2?.center) {
+        graphics.lines.push({
+          points: [node1.center, node2.center]
+        });
+      }
+    }
+    return graphics;
+  }
+};
+
+// node_modules/@babel/runtime/helpers/esm/extends.js
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+
+// node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js
+function _assertThisInitialized(e) {
+  if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
+}
+
+// node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t2, e2) {
+    return t2.__proto__ = e2, t2;
+  }, _setPrototypeOf(t, e);
+}
+
+// node_modules/@babel/runtime/helpers/esm/inheritsLoose.js
+function _inheritsLoose(t, o) {
+  t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
+}
+
+// node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js
+function _getPrototypeOf(t) {
+  return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(t2) {
+    return t2.__proto__ || Object.getPrototypeOf(t2);
+  }, _getPrototypeOf(t);
+}
+
+// node_modules/@babel/runtime/helpers/esm/isNativeFunction.js
+function _isNativeFunction(t) {
+  try {
+    return -1 !== Function.toString.call(t).indexOf("[native code]");
+  } catch (n) {
+    return "function" == typeof t;
+  }
+}
+
+// node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch (t2) {
+  }
+  return (_isNativeReflectConstruct = function _isNativeReflectConstruct2() {
+    return !!t;
+  })();
+}
+
+// node_modules/@babel/runtime/helpers/esm/construct.js
+function _construct(t, e, r) {
+  if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
+  var o = [null];
+  o.push.apply(o, e);
+  var p = new (t.bind.apply(t, o))();
+  return r && _setPrototypeOf(p, r.prototype), p;
+}
+
+// node_modules/@babel/runtime/helpers/esm/wrapNativeSuper.js
+function _wrapNativeSuper(t) {
+  var r = "function" == typeof Map ? /* @__PURE__ */ new Map() : void 0;
+  return _wrapNativeSuper = function _wrapNativeSuper2(t2) {
+    if (null === t2 || !_isNativeFunction(t2)) return t2;
+    if ("function" != typeof t2) throw new TypeError("Super expression must either be null or a function");
+    if (void 0 !== r) {
+      if (r.has(t2)) return r.get(t2);
+      r.set(t2, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(t2, arguments, _getPrototypeOf(this).constructor);
+    }
+    return Wrapper.prototype = Object.create(t2.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    }), _setPrototypeOf(Wrapper, t2);
+  }, _wrapNativeSuper(t);
+}
+
+// node_modules/polished/dist/polished.esm.js
+var ERRORS = {
+  "1": "Passed invalid arguments to hsl, please pass multiple numbers e.g. hsl(360, 0.75, 0.4) or an object e.g. rgb({ hue: 255, saturation: 0.4, lightness: 0.75 }).\n\n",
+  "2": "Passed invalid arguments to hsla, please pass multiple numbers e.g. hsla(360, 0.75, 0.4, 0.7) or an object e.g. rgb({ hue: 255, saturation: 0.4, lightness: 0.75, alpha: 0.7 }).\n\n",
+  "3": "Passed an incorrect argument to a color function, please pass a string representation of a color.\n\n",
+  "4": "Couldn't generate valid rgb string from %s, it returned %s.\n\n",
+  "5": "Couldn't parse the color string. Please provide the color as a string in hex, rgb, rgba, hsl or hsla notation.\n\n",
+  "6": "Passed invalid arguments to rgb, please pass multiple numbers e.g. rgb(255, 205, 100) or an object e.g. rgb({ red: 255, green: 205, blue: 100 }).\n\n",
+  "7": "Passed invalid arguments to rgba, please pass multiple numbers e.g. rgb(255, 205, 100, 0.75) or an object e.g. rgb({ red: 255, green: 205, blue: 100, alpha: 0.75 }).\n\n",
+  "8": "Passed invalid argument to toColorString, please pass a RgbColor, RgbaColor, HslColor or HslaColor object.\n\n",
+  "9": "Please provide a number of steps to the modularScale helper.\n\n",
+  "10": "Please pass a number or one of the predefined scales to the modularScale helper as the ratio.\n\n",
+  "11": 'Invalid value passed as base to modularScale, expected number or em string but got "%s"\n\n',
+  "12": 'Expected a string ending in "px" or a number passed as the first argument to %s(), got "%s" instead.\n\n',
+  "13": 'Expected a string ending in "px" or a number passed as the second argument to %s(), got "%s" instead.\n\n',
+  "14": 'Passed invalid pixel value ("%s") to %s(), please pass a value like "12px" or 12.\n\n',
+  "15": 'Passed invalid base value ("%s") to %s(), please pass a value like "12px" or 12.\n\n',
+  "16": "You must provide a template to this method.\n\n",
+  "17": "You passed an unsupported selector state to this method.\n\n",
+  "18": "minScreen and maxScreen must be provided as stringified numbers with the same units.\n\n",
+  "19": "fromSize and toSize must be provided as stringified numbers with the same units.\n\n",
+  "20": "expects either an array of objects or a single object with the properties prop, fromSize, and toSize.\n\n",
+  "21": "expects the objects in the first argument array to have the properties `prop`, `fromSize`, and `toSize`.\n\n",
+  "22": "expects the first argument object to have the properties `prop`, `fromSize`, and `toSize`.\n\n",
+  "23": "fontFace expects a name of a font-family.\n\n",
+  "24": "fontFace expects either the path to the font file(s) or a name of a local copy.\n\n",
+  "25": "fontFace expects localFonts to be an array.\n\n",
+  "26": "fontFace expects fileFormats to be an array.\n\n",
+  "27": "radialGradient requries at least 2 color-stops to properly render.\n\n",
+  "28": "Please supply a filename to retinaImage() as the first argument.\n\n",
+  "29": "Passed invalid argument to triangle, please pass correct pointingDirection e.g. 'right'.\n\n",
+  "30": "Passed an invalid value to `height` or `width`. Please provide a pixel based unit.\n\n",
+  "31": "The animation shorthand only takes 8 arguments. See the specification for more information: http://mdn.io/animation\n\n",
+  "32": "To pass multiple animations please supply them in arrays, e.g. animation(['rotate', '2s'], ['move', '1s'])\nTo pass a single animation please supply them in simple values, e.g. animation('rotate', '2s')\n\n",
+  "33": "The animation shorthand arrays can only have 8 elements. See the specification for more information: http://mdn.io/animation\n\n",
+  "34": "borderRadius expects a radius value as a string or number as the second argument.\n\n",
+  "35": 'borderRadius expects one of "top", "bottom", "left" or "right" as the first argument.\n\n',
+  "36": "Property must be a string value.\n\n",
+  "37": "Syntax Error at %s.\n\n",
+  "38": "Formula contains a function that needs parentheses at %s.\n\n",
+  "39": "Formula is missing closing parenthesis at %s.\n\n",
+  "40": "Formula has too many closing parentheses at %s.\n\n",
+  "41": "All values in a formula must have the same unit or be unitless.\n\n",
+  "42": "Please provide a number of steps to the modularScale helper.\n\n",
+  "43": "Please pass a number or one of the predefined scales to the modularScale helper as the ratio.\n\n",
+  "44": "Invalid value passed as base to modularScale, expected number or em/rem string but got %s.\n\n",
+  "45": "Passed invalid argument to hslToColorString, please pass a HslColor or HslaColor object.\n\n",
+  "46": "Passed invalid argument to rgbToColorString, please pass a RgbColor or RgbaColor object.\n\n",
+  "47": "minScreen and maxScreen must be provided as stringified numbers with the same units.\n\n",
+  "48": "fromSize and toSize must be provided as stringified numbers with the same units.\n\n",
+  "49": "Expects either an array of objects or a single object with the properties prop, fromSize, and toSize.\n\n",
+  "50": "Expects the objects in the first argument array to have the properties prop, fromSize, and toSize.\n\n",
+  "51": "Expects the first argument object to have the properties prop, fromSize, and toSize.\n\n",
+  "52": "fontFace expects either the path to the font file(s) or a name of a local copy.\n\n",
+  "53": "fontFace expects localFonts to be an array.\n\n",
+  "54": "fontFace expects fileFormats to be an array.\n\n",
+  "55": "fontFace expects a name of a font-family.\n\n",
+  "56": "linearGradient requries at least 2 color-stops to properly render.\n\n",
+  "57": "radialGradient requries at least 2 color-stops to properly render.\n\n",
+  "58": "Please supply a filename to retinaImage() as the first argument.\n\n",
+  "59": "Passed invalid argument to triangle, please pass correct pointingDirection e.g. 'right'.\n\n",
+  "60": "Passed an invalid value to `height` or `width`. Please provide a pixel based unit.\n\n",
+  "61": "Property must be a string value.\n\n",
+  "62": "borderRadius expects a radius value as a string or number as the second argument.\n\n",
+  "63": 'borderRadius expects one of "top", "bottom", "left" or "right" as the first argument.\n\n',
+  "64": "The animation shorthand only takes 8 arguments. See the specification for more information: http://mdn.io/animation.\n\n",
+  "65": "To pass multiple animations please supply them in arrays, e.g. animation(['rotate', '2s'], ['move', '1s'])\\nTo pass a single animation please supply them in simple values, e.g. animation('rotate', '2s').\n\n",
+  "66": "The animation shorthand arrays can only have 8 elements. See the specification for more information: http://mdn.io/animation.\n\n",
+  "67": "You must provide a template to this method.\n\n",
+  "68": "You passed an unsupported selector state to this method.\n\n",
+  "69": 'Expected a string ending in "px" or a number passed as the first argument to %s(), got %s instead.\n\n',
+  "70": 'Expected a string ending in "px" or a number passed as the second argument to %s(), got %s instead.\n\n',
+  "71": 'Passed invalid pixel value %s to %s(), please pass a value like "12px" or 12.\n\n',
+  "72": 'Passed invalid base value %s to %s(), please pass a value like "12px" or 12.\n\n',
+  "73": "Please provide a valid CSS variable.\n\n",
+  "74": "CSS variable not found and no default was provided.\n\n",
+  "75": "important requires a valid style object, got a %s instead.\n\n",
+  "76": "fromSize and toSize must be provided as stringified numbers with the same units as minScreen and maxScreen.\n\n",
+  "77": 'remToPx expects a value in "rem" but you provided it in "%s".\n\n',
+  "78": 'base must be set in "px" or "%" but you set it in "%s".\n'
+};
+function format() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  var a = args[0];
+  var b = [];
+  var c;
+  for (c = 1; c < args.length; c += 1) {
+    b.push(args[c]);
+  }
+  b.forEach(function(d) {
+    a = a.replace(/%[a-z]/, d);
+  });
+  return a;
+}
+var PolishedError = /* @__PURE__ */ function(_Error) {
+  _inheritsLoose(PolishedError2, _Error);
+  function PolishedError2(code) {
+    var _this;
+    if (process.env.NODE_ENV === "production") {
+      _this = _Error.call(this, "An error occurred. See https://github.com/styled-components/polished/blob/main/src/internalHelpers/errors.md#" + code + " for more information.") || this;
+    } else {
+      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        args[_key2 - 1] = arguments[_key2];
+      }
+      _this = _Error.call(this, format.apply(void 0, [ERRORS[code]].concat(args))) || this;
+    }
+    return _assertThisInitialized(_this);
+  }
+  return PolishedError2;
+}(/* @__PURE__ */ _wrapNativeSuper(Error));
+function endsWith(string, suffix) {
+  return string.substr(-suffix.length) === suffix;
+}
+var cssRegex$1 = /^([+-]?(?:\d+|\d*\.\d+))([a-z]*|%)$/;
+function stripUnit(value) {
+  if (typeof value !== "string") return value;
+  var matchedValue = value.match(cssRegex$1);
+  return matchedValue ? parseFloat(value) : value;
+}
+var pxtoFactory = function pxtoFactory2(to) {
+  return function(pxval, base) {
+    if (base === void 0) {
+      base = "16px";
+    }
+    var newPxval = pxval;
+    var newBase = base;
+    if (typeof pxval === "string") {
+      if (!endsWith(pxval, "px")) {
+        throw new PolishedError(69, to, pxval);
+      }
+      newPxval = stripUnit(pxval);
+    }
+    if (typeof base === "string") {
+      if (!endsWith(base, "px")) {
+        throw new PolishedError(70, to, base);
+      }
+      newBase = stripUnit(base);
+    }
+    if (typeof newPxval === "string") {
+      throw new PolishedError(71, pxval, to);
+    }
+    if (typeof newBase === "string") {
+      throw new PolishedError(72, base, to);
+    }
+    return "" + newPxval / newBase + to;
+  };
+};
+var pixelsto = pxtoFactory;
+var em = pixelsto("em");
+var rem = pixelsto("rem");
+function colorToInt(color) {
+  return Math.round(color * 255);
+}
+function convertToInt(red, green, blue) {
+  return colorToInt(red) + "," + colorToInt(green) + "," + colorToInt(blue);
+}
+function hslToRgb(hue, saturation, lightness, convert) {
+  if (convert === void 0) {
+    convert = convertToInt;
+  }
+  if (saturation === 0) {
+    return convert(lightness, lightness, lightness);
+  }
+  var huePrime = (hue % 360 + 360) % 360 / 60;
+  var chroma = (1 - Math.abs(2 * lightness - 1)) * saturation;
+  var secondComponent = chroma * (1 - Math.abs(huePrime % 2 - 1));
+  var red = 0;
+  var green = 0;
+  var blue = 0;
+  if (huePrime >= 0 && huePrime < 1) {
+    red = chroma;
+    green = secondComponent;
+  } else if (huePrime >= 1 && huePrime < 2) {
+    red = secondComponent;
+    green = chroma;
+  } else if (huePrime >= 2 && huePrime < 3) {
+    green = chroma;
+    blue = secondComponent;
+  } else if (huePrime >= 3 && huePrime < 4) {
+    green = secondComponent;
+    blue = chroma;
+  } else if (huePrime >= 4 && huePrime < 5) {
+    red = secondComponent;
+    blue = chroma;
+  } else if (huePrime >= 5 && huePrime < 6) {
+    red = chroma;
+    blue = secondComponent;
+  }
+  var lightnessModification = lightness - chroma / 2;
+  var finalRed = red + lightnessModification;
+  var finalGreen = green + lightnessModification;
+  var finalBlue = blue + lightnessModification;
+  return convert(finalRed, finalGreen, finalBlue);
+}
+var namedColorMap = {
+  aliceblue: "f0f8ff",
+  antiquewhite: "faebd7",
+  aqua: "00ffff",
+  aquamarine: "7fffd4",
+  azure: "f0ffff",
+  beige: "f5f5dc",
+  bisque: "ffe4c4",
+  black: "000",
+  blanchedalmond: "ffebcd",
+  blue: "0000ff",
+  blueviolet: "8a2be2",
+  brown: "a52a2a",
+  burlywood: "deb887",
+  cadetblue: "5f9ea0",
+  chartreuse: "7fff00",
+  chocolate: "d2691e",
+  coral: "ff7f50",
+  cornflowerblue: "6495ed",
+  cornsilk: "fff8dc",
+  crimson: "dc143c",
+  cyan: "00ffff",
+  darkblue: "00008b",
+  darkcyan: "008b8b",
+  darkgoldenrod: "b8860b",
+  darkgray: "a9a9a9",
+  darkgreen: "006400",
+  darkgrey: "a9a9a9",
+  darkkhaki: "bdb76b",
+  darkmagenta: "8b008b",
+  darkolivegreen: "556b2f",
+  darkorange: "ff8c00",
+  darkorchid: "9932cc",
+  darkred: "8b0000",
+  darksalmon: "e9967a",
+  darkseagreen: "8fbc8f",
+  darkslateblue: "483d8b",
+  darkslategray: "2f4f4f",
+  darkslategrey: "2f4f4f",
+  darkturquoise: "00ced1",
+  darkviolet: "9400d3",
+  deeppink: "ff1493",
+  deepskyblue: "00bfff",
+  dimgray: "696969",
+  dimgrey: "696969",
+  dodgerblue: "1e90ff",
+  firebrick: "b22222",
+  floralwhite: "fffaf0",
+  forestgreen: "228b22",
+  fuchsia: "ff00ff",
+  gainsboro: "dcdcdc",
+  ghostwhite: "f8f8ff",
+  gold: "ffd700",
+  goldenrod: "daa520",
+  gray: "808080",
+  green: "008000",
+  greenyellow: "adff2f",
+  grey: "808080",
+  honeydew: "f0fff0",
+  hotpink: "ff69b4",
+  indianred: "cd5c5c",
+  indigo: "4b0082",
+  ivory: "fffff0",
+  khaki: "f0e68c",
+  lavender: "e6e6fa",
+  lavenderblush: "fff0f5",
+  lawngreen: "7cfc00",
+  lemonchiffon: "fffacd",
+  lightblue: "add8e6",
+  lightcoral: "f08080",
+  lightcyan: "e0ffff",
+  lightgoldenrodyellow: "fafad2",
+  lightgray: "d3d3d3",
+  lightgreen: "90ee90",
+  lightgrey: "d3d3d3",
+  lightpink: "ffb6c1",
+  lightsalmon: "ffa07a",
+  lightseagreen: "20b2aa",
+  lightskyblue: "87cefa",
+  lightslategray: "789",
+  lightslategrey: "789",
+  lightsteelblue: "b0c4de",
+  lightyellow: "ffffe0",
+  lime: "0f0",
+  limegreen: "32cd32",
+  linen: "faf0e6",
+  magenta: "f0f",
+  maroon: "800000",
+  mediumaquamarine: "66cdaa",
+  mediumblue: "0000cd",
+  mediumorchid: "ba55d3",
+  mediumpurple: "9370db",
+  mediumseagreen: "3cb371",
+  mediumslateblue: "7b68ee",
+  mediumspringgreen: "00fa9a",
+  mediumturquoise: "48d1cc",
+  mediumvioletred: "c71585",
+  midnightblue: "191970",
+  mintcream: "f5fffa",
+  mistyrose: "ffe4e1",
+  moccasin: "ffe4b5",
+  navajowhite: "ffdead",
+  navy: "000080",
+  oldlace: "fdf5e6",
+  olive: "808000",
+  olivedrab: "6b8e23",
+  orange: "ffa500",
+  orangered: "ff4500",
+  orchid: "da70d6",
+  palegoldenrod: "eee8aa",
+  palegreen: "98fb98",
+  paleturquoise: "afeeee",
+  palevioletred: "db7093",
+  papayawhip: "ffefd5",
+  peachpuff: "ffdab9",
+  peru: "cd853f",
+  pink: "ffc0cb",
+  plum: "dda0dd",
+  powderblue: "b0e0e6",
+  purple: "800080",
+  rebeccapurple: "639",
+  red: "f00",
+  rosybrown: "bc8f8f",
+  royalblue: "4169e1",
+  saddlebrown: "8b4513",
+  salmon: "fa8072",
+  sandybrown: "f4a460",
+  seagreen: "2e8b57",
+  seashell: "fff5ee",
+  sienna: "a0522d",
+  silver: "c0c0c0",
+  skyblue: "87ceeb",
+  slateblue: "6a5acd",
+  slategray: "708090",
+  slategrey: "708090",
+  snow: "fffafa",
+  springgreen: "00ff7f",
+  steelblue: "4682b4",
+  tan: "d2b48c",
+  teal: "008080",
+  thistle: "d8bfd8",
+  tomato: "ff6347",
+  turquoise: "40e0d0",
+  violet: "ee82ee",
+  wheat: "f5deb3",
+  white: "fff",
+  whitesmoke: "f5f5f5",
+  yellow: "ff0",
+  yellowgreen: "9acd32"
+};
+function nameToHex(color) {
+  if (typeof color !== "string") return color;
+  var normalizedColorName = color.toLowerCase();
+  return namedColorMap[normalizedColorName] ? "#" + namedColorMap[normalizedColorName] : color;
+}
+var hexRegex = /^#[a-fA-F0-9]{6}$/;
+var hexRgbaRegex = /^#[a-fA-F0-9]{8}$/;
+var reducedHexRegex = /^#[a-fA-F0-9]{3}$/;
+var reducedRgbaHexRegex = /^#[a-fA-F0-9]{4}$/;
+var rgbRegex = /^rgb\(\s*(\d{1,3})\s*(?:,)?\s*(\d{1,3})\s*(?:,)?\s*(\d{1,3})\s*\)$/i;
+var rgbaRegex = /^rgb(?:a)?\(\s*(\d{1,3})\s*(?:,)?\s*(\d{1,3})\s*(?:,)?\s*(\d{1,3})\s*(?:,|\/)\s*([-+]?\d*[.]?\d+[%]?)\s*\)$/i;
+var hslRegex = /^hsl\(\s*(\d{0,3}[.]?[0-9]+(?:deg)?)\s*(?:,)?\s*(\d{1,3}[.]?[0-9]?)%\s*(?:,)?\s*(\d{1,3}[.]?[0-9]?)%\s*\)$/i;
+var hslaRegex = /^hsl(?:a)?\(\s*(\d{0,3}[.]?[0-9]+(?:deg)?)\s*(?:,)?\s*(\d{1,3}[.]?[0-9]?)%\s*(?:,)?\s*(\d{1,3}[.]?[0-9]?)%\s*(?:,|\/)\s*([-+]?\d*[.]?\d+[%]?)\s*\)$/i;
+function parseToRgb(color) {
+  if (typeof color !== "string") {
+    throw new PolishedError(3);
+  }
+  var normalizedColor = nameToHex(color);
+  if (normalizedColor.match(hexRegex)) {
+    return {
+      red: parseInt("" + normalizedColor[1] + normalizedColor[2], 16),
+      green: parseInt("" + normalizedColor[3] + normalizedColor[4], 16),
+      blue: parseInt("" + normalizedColor[5] + normalizedColor[6], 16)
+    };
+  }
+  if (normalizedColor.match(hexRgbaRegex)) {
+    var alpha = parseFloat((parseInt("" + normalizedColor[7] + normalizedColor[8], 16) / 255).toFixed(2));
+    return {
+      red: parseInt("" + normalizedColor[1] + normalizedColor[2], 16),
+      green: parseInt("" + normalizedColor[3] + normalizedColor[4], 16),
+      blue: parseInt("" + normalizedColor[5] + normalizedColor[6], 16),
+      alpha
+    };
+  }
+  if (normalizedColor.match(reducedHexRegex)) {
+    return {
+      red: parseInt("" + normalizedColor[1] + normalizedColor[1], 16),
+      green: parseInt("" + normalizedColor[2] + normalizedColor[2], 16),
+      blue: parseInt("" + normalizedColor[3] + normalizedColor[3], 16)
+    };
+  }
+  if (normalizedColor.match(reducedRgbaHexRegex)) {
+    var _alpha = parseFloat((parseInt("" + normalizedColor[4] + normalizedColor[4], 16) / 255).toFixed(2));
+    return {
+      red: parseInt("" + normalizedColor[1] + normalizedColor[1], 16),
+      green: parseInt("" + normalizedColor[2] + normalizedColor[2], 16),
+      blue: parseInt("" + normalizedColor[3] + normalizedColor[3], 16),
+      alpha: _alpha
+    };
+  }
+  var rgbMatched = rgbRegex.exec(normalizedColor);
+  if (rgbMatched) {
+    return {
+      red: parseInt("" + rgbMatched[1], 10),
+      green: parseInt("" + rgbMatched[2], 10),
+      blue: parseInt("" + rgbMatched[3], 10)
+    };
+  }
+  var rgbaMatched = rgbaRegex.exec(normalizedColor.substring(0, 50));
+  if (rgbaMatched) {
+    return {
+      red: parseInt("" + rgbaMatched[1], 10),
+      green: parseInt("" + rgbaMatched[2], 10),
+      blue: parseInt("" + rgbaMatched[3], 10),
+      alpha: parseFloat("" + rgbaMatched[4]) > 1 ? parseFloat("" + rgbaMatched[4]) / 100 : parseFloat("" + rgbaMatched[4])
+    };
+  }
+  var hslMatched = hslRegex.exec(normalizedColor);
+  if (hslMatched) {
+    var hue = parseInt("" + hslMatched[1], 10);
+    var saturation = parseInt("" + hslMatched[2], 10) / 100;
+    var lightness = parseInt("" + hslMatched[3], 10) / 100;
+    var rgbColorString = "rgb(" + hslToRgb(hue, saturation, lightness) + ")";
+    var hslRgbMatched = rgbRegex.exec(rgbColorString);
+    if (!hslRgbMatched) {
+      throw new PolishedError(4, normalizedColor, rgbColorString);
+    }
+    return {
+      red: parseInt("" + hslRgbMatched[1], 10),
+      green: parseInt("" + hslRgbMatched[2], 10),
+      blue: parseInt("" + hslRgbMatched[3], 10)
+    };
+  }
+  var hslaMatched = hslaRegex.exec(normalizedColor.substring(0, 50));
+  if (hslaMatched) {
+    var _hue = parseInt("" + hslaMatched[1], 10);
+    var _saturation = parseInt("" + hslaMatched[2], 10) / 100;
+    var _lightness = parseInt("" + hslaMatched[3], 10) / 100;
+    var _rgbColorString = "rgb(" + hslToRgb(_hue, _saturation, _lightness) + ")";
+    var _hslRgbMatched = rgbRegex.exec(_rgbColorString);
+    if (!_hslRgbMatched) {
+      throw new PolishedError(4, normalizedColor, _rgbColorString);
+    }
+    return {
+      red: parseInt("" + _hslRgbMatched[1], 10),
+      green: parseInt("" + _hslRgbMatched[2], 10),
+      blue: parseInt("" + _hslRgbMatched[3], 10),
+      alpha: parseFloat("" + hslaMatched[4]) > 1 ? parseFloat("" + hslaMatched[4]) / 100 : parseFloat("" + hslaMatched[4])
+    };
+  }
+  throw new PolishedError(5);
+}
+function rgbToHsl(color) {
+  var red = color.red / 255;
+  var green = color.green / 255;
+  var blue = color.blue / 255;
+  var max = Math.max(red, green, blue);
+  var min = Math.min(red, green, blue);
+  var lightness = (max + min) / 2;
+  if (max === min) {
+    if (color.alpha !== void 0) {
+      return {
+        hue: 0,
+        saturation: 0,
+        lightness,
+        alpha: color.alpha
+      };
+    } else {
+      return {
+        hue: 0,
+        saturation: 0,
+        lightness
+      };
+    }
+  }
+  var hue;
+  var delta = max - min;
+  var saturation = lightness > 0.5 ? delta / (2 - max - min) : delta / (max + min);
+  switch (max) {
+    case red:
+      hue = (green - blue) / delta + (green < blue ? 6 : 0);
+      break;
+    case green:
+      hue = (blue - red) / delta + 2;
+      break;
+    default:
+      hue = (red - green) / delta + 4;
+      break;
+  }
+  hue *= 60;
+  if (color.alpha !== void 0) {
+    return {
+      hue,
+      saturation,
+      lightness,
+      alpha: color.alpha
+    };
+  }
+  return {
+    hue,
+    saturation,
+    lightness
+  };
+}
+function parseToHsl(color) {
+  return rgbToHsl(parseToRgb(color));
+}
+var reduceHexValue = function reduceHexValue2(value) {
+  if (value.length === 7 && value[1] === value[2] && value[3] === value[4] && value[5] === value[6]) {
+    return "#" + value[1] + value[3] + value[5];
+  }
+  return value;
+};
+var reduceHexValue$1 = reduceHexValue;
+function numberToHex(value) {
+  var hex = value.toString(16);
+  return hex.length === 1 ? "0" + hex : hex;
+}
+function colorToHex(color) {
+  return numberToHex(Math.round(color * 255));
+}
+function convertToHex(red, green, blue) {
+  return reduceHexValue$1("#" + colorToHex(red) + colorToHex(green) + colorToHex(blue));
+}
+function hslToHex(hue, saturation, lightness) {
+  return hslToRgb(hue, saturation, lightness, convertToHex);
+}
+function hsl(value, saturation, lightness) {
+  if (typeof value === "number" && typeof saturation === "number" && typeof lightness === "number") {
+    return hslToHex(value, saturation, lightness);
+  } else if (typeof value === "object" && saturation === void 0 && lightness === void 0) {
+    return hslToHex(value.hue, value.saturation, value.lightness);
+  }
+  throw new PolishedError(1);
+}
+function hsla(value, saturation, lightness, alpha) {
+  if (typeof value === "number" && typeof saturation === "number" && typeof lightness === "number" && typeof alpha === "number") {
+    return alpha >= 1 ? hslToHex(value, saturation, lightness) : "rgba(" + hslToRgb(value, saturation, lightness) + "," + alpha + ")";
+  } else if (typeof value === "object" && saturation === void 0 && lightness === void 0 && alpha === void 0) {
+    return value.alpha >= 1 ? hslToHex(value.hue, value.saturation, value.lightness) : "rgba(" + hslToRgb(value.hue, value.saturation, value.lightness) + "," + value.alpha + ")";
+  }
+  throw new PolishedError(2);
+}
+function rgb(value, green, blue) {
+  if (typeof value === "number" && typeof green === "number" && typeof blue === "number") {
+    return reduceHexValue$1("#" + numberToHex(value) + numberToHex(green) + numberToHex(blue));
+  } else if (typeof value === "object" && green === void 0 && blue === void 0) {
+    return reduceHexValue$1("#" + numberToHex(value.red) + numberToHex(value.green) + numberToHex(value.blue));
+  }
+  throw new PolishedError(6);
+}
+function rgba(firstValue, secondValue, thirdValue, fourthValue) {
+  if (typeof firstValue === "string" && typeof secondValue === "number") {
+    var rgbValue = parseToRgb(firstValue);
+    return "rgba(" + rgbValue.red + "," + rgbValue.green + "," + rgbValue.blue + "," + secondValue + ")";
+  } else if (typeof firstValue === "number" && typeof secondValue === "number" && typeof thirdValue === "number" && typeof fourthValue === "number") {
+    return fourthValue >= 1 ? rgb(firstValue, secondValue, thirdValue) : "rgba(" + firstValue + "," + secondValue + "," + thirdValue + "," + fourthValue + ")";
+  } else if (typeof firstValue === "object" && secondValue === void 0 && thirdValue === void 0 && fourthValue === void 0) {
+    return firstValue.alpha >= 1 ? rgb(firstValue.red, firstValue.green, firstValue.blue) : "rgba(" + firstValue.red + "," + firstValue.green + "," + firstValue.blue + "," + firstValue.alpha + ")";
+  }
+  throw new PolishedError(7);
+}
+var isRgb = function isRgb2(color) {
+  return typeof color.red === "number" && typeof color.green === "number" && typeof color.blue === "number" && (typeof color.alpha !== "number" || typeof color.alpha === "undefined");
+};
+var isRgba = function isRgba2(color) {
+  return typeof color.red === "number" && typeof color.green === "number" && typeof color.blue === "number" && typeof color.alpha === "number";
+};
+var isHsl = function isHsl2(color) {
+  return typeof color.hue === "number" && typeof color.saturation === "number" && typeof color.lightness === "number" && (typeof color.alpha !== "number" || typeof color.alpha === "undefined");
+};
+var isHsla = function isHsla2(color) {
+  return typeof color.hue === "number" && typeof color.saturation === "number" && typeof color.lightness === "number" && typeof color.alpha === "number";
+};
+function toColorString(color) {
+  if (typeof color !== "object") throw new PolishedError(8);
+  if (isRgba(color)) return rgba(color);
+  if (isRgb(color)) return rgb(color);
+  if (isHsla(color)) return hsla(color);
+  if (isHsl(color)) return hsl(color);
+  throw new PolishedError(8);
+}
+function curried(f, length, acc) {
+  return function fn() {
+    var combined = acc.concat(Array.prototype.slice.call(arguments));
+    return combined.length >= length ? f.apply(this, combined) : curried(f, length, combined);
+  };
+}
+function curry(f) {
+  return curried(f, f.length, []);
+}
+function adjustHue(degree, color) {
+  if (color === "transparent") return color;
+  var hslColor = parseToHsl(color);
+  return toColorString(_extends({}, hslColor, {
+    hue: hslColor.hue + parseFloat(degree)
+  }));
+}
+var curriedAdjustHue = curry(adjustHue);
+function guard(lowerBoundary, upperBoundary, value) {
+  return Math.max(lowerBoundary, Math.min(upperBoundary, value));
+}
+function darken(amount, color) {
+  if (color === "transparent") return color;
+  var hslColor = parseToHsl(color);
+  return toColorString(_extends({}, hslColor, {
+    lightness: guard(0, 1, hslColor.lightness - parseFloat(amount))
+  }));
+}
+var curriedDarken = curry(darken);
+function desaturate(amount, color) {
+  if (color === "transparent") return color;
+  var hslColor = parseToHsl(color);
+  return toColorString(_extends({}, hslColor, {
+    saturation: guard(0, 1, hslColor.saturation - parseFloat(amount))
+  }));
+}
+var curriedDesaturate = curry(desaturate);
+function lighten(amount, color) {
+  if (color === "transparent") return color;
+  var hslColor = parseToHsl(color);
+  return toColorString(_extends({}, hslColor, {
+    lightness: guard(0, 1, hslColor.lightness + parseFloat(amount))
+  }));
+}
+var curriedLighten = curry(lighten);
+function mix(weight, color, otherColor) {
+  if (color === "transparent") return otherColor;
+  if (otherColor === "transparent") return color;
+  if (weight === 0) return otherColor;
+  var parsedColor1 = parseToRgb(color);
+  var color1 = _extends({}, parsedColor1, {
+    alpha: typeof parsedColor1.alpha === "number" ? parsedColor1.alpha : 1
+  });
+  var parsedColor2 = parseToRgb(otherColor);
+  var color2 = _extends({}, parsedColor2, {
+    alpha: typeof parsedColor2.alpha === "number" ? parsedColor2.alpha : 1
+  });
+  var alphaDelta = color1.alpha - color2.alpha;
+  var x = parseFloat(weight) * 2 - 1;
+  var y = x * alphaDelta === -1 ? x : x + alphaDelta;
+  var z = 1 + x * alphaDelta;
+  var weight1 = (y / z + 1) / 2;
+  var weight2 = 1 - weight1;
+  var mixedColor = {
+    red: Math.floor(color1.red * weight1 + color2.red * weight2),
+    green: Math.floor(color1.green * weight1 + color2.green * weight2),
+    blue: Math.floor(color1.blue * weight1 + color2.blue * weight2),
+    alpha: color1.alpha * parseFloat(weight) + color2.alpha * (1 - parseFloat(weight))
+  };
+  return rgba(mixedColor);
+}
+var curriedMix = curry(mix);
+var mix$1 = curriedMix;
+function opacify(amount, color) {
+  if (color === "transparent") return color;
+  var parsedColor = parseToRgb(color);
+  var alpha = typeof parsedColor.alpha === "number" ? parsedColor.alpha : 1;
+  var colorWithAlpha = _extends({}, parsedColor, {
+    alpha: guard(0, 1, (alpha * 100 + parseFloat(amount) * 100) / 100)
+  });
+  return rgba(colorWithAlpha);
+}
+var curriedOpacify = curry(opacify);
+function saturate(amount, color) {
+  if (color === "transparent") return color;
+  var hslColor = parseToHsl(color);
+  return toColorString(_extends({}, hslColor, {
+    saturation: guard(0, 1, hslColor.saturation + parseFloat(amount))
+  }));
+}
+var curriedSaturate = curry(saturate);
+function setHue(hue, color) {
+  if (color === "transparent") return color;
+  return toColorString(_extends({}, parseToHsl(color), {
+    hue: parseFloat(hue)
+  }));
+}
+var curriedSetHue = curry(setHue);
+function setLightness(lightness, color) {
+  if (color === "transparent") return color;
+  return toColorString(_extends({}, parseToHsl(color), {
+    lightness: parseFloat(lightness)
+  }));
+}
+var curriedSetLightness = curry(setLightness);
+function setSaturation(saturation, color) {
+  if (color === "transparent") return color;
+  return toColorString(_extends({}, parseToHsl(color), {
+    saturation: parseFloat(saturation)
+  }));
+}
+var curriedSetSaturation = curry(setSaturation);
+function shade(percentage, color) {
+  if (color === "transparent") return color;
+  return mix$1(parseFloat(percentage), "rgb(0, 0, 0)", color);
+}
+var curriedShade = curry(shade);
+function tint(percentage, color) {
+  if (color === "transparent") return color;
+  return mix$1(parseFloat(percentage), "rgb(255, 255, 255)", color);
+}
+var curriedTint = curry(tint);
+function transparentize(amount, color) {
+  if (color === "transparent") return color;
+  var parsedColor = parseToRgb(color);
+  var alpha = typeof parsedColor.alpha === "number" ? parsedColor.alpha : 1;
+  var colorWithAlpha = _extends({}, parsedColor, {
+    alpha: guard(0, 1, +(alpha * 100 - parseFloat(amount) * 100).toFixed(2) / 100)
+  });
+  return rgba(colorWithAlpha);
+}
+var curriedTransparentize = curry(transparentize);
+var curriedTransparentize$1 = curriedTransparentize;
+
+// lib/solvers/colors.ts
+var COLORS = [
+  "blue",
+  "orange",
+  "purple",
+  "cyan",
+  "magenta",
+  "yellowgreen",
+  "darkgoldenrod",
+  "deeppink"
+];
+var getColorMap = (srj, connMap) => {
+  const colorMap = {};
+  for (let i = 0; i < srj.connections.length; i++) {
+    const connection = srj.connections[i];
+    const netName = connMap?.getNetConnectedToId(connection.name);
+    if (netName && !colorMap[netName]) {
+      colorMap[netName] = `hsl(${i * 300 / srj.connections.length}, 100%, 50%)`;
+    }
+    colorMap[connection.name] = (netName ? colorMap[netName] : null) ?? `hsl(${i * 340 / srj.connections.length}, 100%, 50%)`;
+  }
+  return colorMap;
+};
+var safeTransparentize = (color, amount) => {
+  try {
+    return curriedTransparentize$1(amount, color);
+  } catch (e) {
+    console.error(e);
+    return color;
+  }
+};
+
+// lib/utils/isPointInRect.ts
+function isPointInRect(point, rect) {
+  return point.x >= rect.center.x - rect.width / 2 && point.x <= rect.center.x + rect.width / 2 && point.y >= rect.center.y - rect.height / 2 && point.y <= rect.center.y + rect.height / 2;
+}
+
+// lib/utils/doRectsOverlap.ts
+function doRectsOverlap(rect1, rect2) {
+  const rect1Left = rect1.center.x - rect1.width / 2;
+  const rect1Right = rect1.center.x + rect1.width / 2;
+  const rect1Top = rect1.center.y - rect1.height / 2;
+  const rect1Bottom = rect1.center.y + rect1.height / 2;
+  const rect2Left = rect2.center.x - rect2.width / 2;
+  const rect2Right = rect2.center.x + rect2.width / 2;
+  const rect2Top = rect2.center.y - rect2.height / 2;
+  const rect2Bottom = rect2.center.y + rect2.height / 2;
+  return rect1Left <= rect2Right && rect1Right >= rect2Left && rect1Top <= rect2Bottom && rect1Bottom >= rect2Top;
+}
+
+// lib/solvers/CapacityMeshSolver/CapacityMeshNodeSolver.ts
+var CapacityMeshNodeSolver = class extends BaseSolver {
+  constructor(srj, opts = {}) {
+    super();
+    this.srj = srj;
+    this.opts = opts;
+    this.MAX_DEPTH = opts?.capacityDepth ?? this.MAX_DEPTH;
+    this.MAX_ITERATIONS = 1e5;
+    const boundsCenter = {
+      x: (srj.bounds.minX + srj.bounds.maxX) / 2,
+      y: (srj.bounds.minY + srj.bounds.maxY) / 2
+    };
+    const boundsSize = {
+      width: srj.bounds.maxX - srj.bounds.minX,
+      height: srj.bounds.maxY - srj.bounds.minY
+    };
+    const maxWidthHeight = Math.max(boundsSize.width, boundsSize.height);
+    this.unfinishedNodes = [
+      {
+        capacityMeshNodeId: this.getNextNodeId(),
+        center: boundsCenter,
+        width: maxWidthHeight,
+        height: maxWidthHeight,
+        layer: "top",
+        _depth: 0,
+        _containsTarget: true,
+        _containsObstacle: true,
+        _completelyInsideObstacle: false
+      }
+    ];
+    this.finishedNodes = [];
+    this.nodeToOverlappingObstaclesMap = /* @__PURE__ */ new Map();
+    this.targets = this.srj.connections.flatMap(
+      (c) => c.pointsToConnect.map((p) => ({ ...p, connectionName: c.name }))
+    );
+  }
+  unfinishedNodes;
+  finishedNodes;
+  nodeToOverlappingObstaclesMap;
+  // targetObstacleMap: Record<string, { obstacle: Obstacle, node: CapacityMeshNode }>
+  MAX_DEPTH = 4;
+  targets;
+  _nextNodeCounter = 0;
+  getNextNodeId() {
+    return `cn${this._nextNodeCounter++}`;
+  }
+  getCapacityFromDepth(depth) {
+    return (this.MAX_DEPTH - depth + 1) ** 2;
+  }
+  getTargetNameIfNodeContainsTarget(node) {
+    const overlappingObstacles = this.getOverlappingObstacles(node);
+    for (const target of this.targets) {
+      const targetObstacle = overlappingObstacles.find(
+        (o) => isPointInRect(target, o)
+      );
+      if (targetObstacle) {
+        if (doRectsOverlap(node, targetObstacle)) {
+          return target.connectionName;
+        }
+      }
+      if (target.x >= node.center.x - node.width / 2 && target.x <= node.center.x + node.width / 2 && target.y >= node.center.y - node.height / 2 && target.y <= node.center.y + node.height / 2) {
+        return target.connectionName;
+      }
+    }
+    return null;
+  }
+  getOverlappingObstacles(node) {
+    const cachedObstacles = this.nodeToOverlappingObstaclesMap.get(
+      node.capacityMeshNodeId
+    );
+    if (cachedObstacles) {
+      return cachedObstacles;
+    }
+    const overlappingObstacles = [];
+    const nodeLeft = node.center.x - node.width / 2;
+    const nodeRight = node.center.x + node.width / 2;
+    const nodeTop = node.center.y - node.height / 2;
+    const nodeBottom = node.center.y + node.height / 2;
+    const obstacles = node._parent ? this.getOverlappingObstacles(node._parent) : this.srj.obstacles;
+    for (const obstacle of obstacles) {
+      const obsLeft = obstacle.center.x - obstacle.width / 2;
+      const obsRight = obstacle.center.x + obstacle.width / 2;
+      const obsTop = obstacle.center.y - obstacle.height / 2;
+      const obsBottom = obstacle.center.y + obstacle.height / 2;
+      if (nodeRight >= obsLeft && nodeLeft <= obsRight && nodeBottom >= obsTop && nodeTop <= obsBottom) {
+        overlappingObstacles.push(obstacle);
+      }
+    }
+    this.nodeToOverlappingObstaclesMap.set(
+      node.capacityMeshNodeId,
+      overlappingObstacles
+    );
+    return overlappingObstacles;
+  }
+  /**
+   * Checks if the given mesh node overlaps with any obstacle.
+   * We treat both obstacles and nodes as axis‐aligned rectangles.
+   */
+  doesNodeOverlapObstacle(node) {
+    const overlappingObstacles = this.getOverlappingObstacles(node);
+    if (overlappingObstacles.length > 0) {
+      return true;
+    }
+    const nodeLeft = node.center.x - node.width / 2;
+    const nodeRight = node.center.x + node.width / 2;
+    const nodeTop = node.center.y - node.height / 2;
+    const nodeBottom = node.center.y + node.height / 2;
+    if (nodeLeft < this.srj.bounds.minX || nodeRight > this.srj.bounds.maxX || nodeTop < this.srj.bounds.minY || nodeBottom > this.srj.bounds.maxY) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Checks if the entire node is contained within any obstacle.
+   */
+  isNodeCompletelyInsideObstacle(node) {
+    const overlappingObstacles = this.getOverlappingObstacles(node);
+    const nodeLeft = node.center.x - node.width / 2;
+    const nodeRight = node.center.x + node.width / 2;
+    const nodeTop = node.center.y - node.height / 2;
+    const nodeBottom = node.center.y + node.height / 2;
+    for (const obstacle of overlappingObstacles) {
+      const obsLeft = obstacle.center.x - obstacle.width / 2;
+      const obsRight = obstacle.center.x + obstacle.width / 2;
+      const obsTop = obstacle.center.y - obstacle.height / 2;
+      const obsBottom = obstacle.center.y + obstacle.height / 2;
+      if (nodeLeft >= obsLeft && nodeRight <= obsRight && nodeTop >= obsTop && nodeBottom <= obsBottom) {
+        return true;
+      }
+    }
+    if (nodeRight < this.srj.bounds.minX || nodeLeft > this.srj.bounds.maxX || nodeBottom < this.srj.bounds.minY || nodeTop > this.srj.bounds.maxY) {
+      return true;
+    }
+    return false;
+  }
+  getChildNodes(parent) {
+    if (parent._depth === this.MAX_DEPTH) return [];
+    const childNodes = [];
+    const childNodeSize = { width: parent.width / 2, height: parent.height / 2 };
+    const childNodePositions = [
+      {
+        x: parent.center.x - childNodeSize.width / 2,
+        y: parent.center.y - childNodeSize.height / 2
+      },
+      {
+        x: parent.center.x + childNodeSize.width / 2,
+        y: parent.center.y - childNodeSize.height / 2
+      },
+      {
+        x: parent.center.x - childNodeSize.width / 2,
+        y: parent.center.y + childNodeSize.height / 2
+      },
+      {
+        x: parent.center.x + childNodeSize.width / 2,
+        y: parent.center.y + childNodeSize.height / 2
+      }
+    ];
+    for (const position of childNodePositions) {
+      const childNode = {
+        capacityMeshNodeId: this.getNextNodeId(),
+        center: position,
+        width: childNodeSize.width,
+        height: childNodeSize.height,
+        layer: parent.layer,
+        _depth: (parent._depth ?? 0) + 1,
+        _parent: parent
+      };
+      childNode._containsObstacle = this.doesNodeOverlapObstacle(childNode);
+      childNode._targetConnectionName = this.getTargetNameIfNodeContainsTarget(childNode) ?? void 0;
+      childNode._containsTarget = Boolean(childNode._targetConnectionName);
+      if (childNode._containsObstacle) {
+        childNode._completelyInsideObstacle = this.isNodeCompletelyInsideObstacle(childNode);
+      }
+      if (childNode._completelyInsideObstacle && !childNode._containsTarget)
+        continue;
+      childNodes.push(childNode);
+    }
+    return childNodes;
+  }
+  shouldNodeBeSubdivided(node) {
+    if (node._depth >= this.MAX_DEPTH) return false;
+    if (node._containsTarget) return true;
+    if (node._containsObstacle && !node._completelyInsideObstacle) return true;
+    return false;
+  }
+  _step() {
+    const nextNode = this.unfinishedNodes.pop();
+    if (!nextNode) {
+      this.solved = true;
+      return;
+    }
+    const newNodes = this.getChildNodes(nextNode);
+    const finishedNewNodes = [];
+    const unfinishedNewNodes = [];
+    for (const newNode of newNodes) {
+      const shouldBeSubdivided = this.shouldNodeBeSubdivided(newNode);
+      if (shouldBeSubdivided) {
+        unfinishedNewNodes.push(newNode);
+      } else if (!shouldBeSubdivided && !newNode._containsObstacle) {
+        finishedNewNodes.push(newNode);
+      } else if (!shouldBeSubdivided && newNode._containsTarget) {
+        finishedNewNodes.push(newNode);
+      }
+    }
+    this.unfinishedNodes.push(...unfinishedNewNodes);
+    this.finishedNodes.push(...finishedNewNodes);
+  }
+  /**
+   * Creates a GraphicsObject to visualize the mesh, its nodes, obstacles, and connection points.
+   *
+   * - Mesh nodes are rendered as rectangles.
+   *   - Nodes that have an obstacle intersection are outlined in red.
+   *   - Other nodes are outlined in green.
+   * - Lines are drawn from a node to its parent.
+   * - Obstacles are drawn as semi-transparent red rectangles.
+   * - Points for each connection’s pointsToConnect are drawn in a unique color.
+   */
+  visualize() {
+    const graphics = {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: [],
+      coordinateSystem: "cartesian",
+      title: "Capacity Mesh Visualization"
+    };
+    const allNodes = [...this.finishedNodes, ...this.unfinishedNodes];
+    for (const node of allNodes) {
+      graphics.rects.push({
+        center: node.center,
+        width: Math.max(node.width - 2, node.width * 0.8),
+        height: Math.max(node.height - 2, node.height * 0.8),
+        fill: node._containsObstacle ? "rgba(255,0,0,0.1)" : "rgba(0,0,0,0.1)",
+        label: node.capacityMeshNodeId
+      });
+    }
+    for (const obstacle of this.srj.obstacles) {
+      graphics.rects.push({
+        center: obstacle.center,
+        width: obstacle.width,
+        height: obstacle.height,
+        fill: "rgba(255,0,0,0.3)",
+        stroke: "red",
+        label: "obstacle"
+      });
+    }
+    this.srj.connections.forEach((connection, index) => {
+      const color = COLORS[index % COLORS.length];
+      for (const pt of connection.pointsToConnect) {
+        graphics.points.push({
+          x: pt.x,
+          y: pt.y,
+          label: `conn-${index}`,
+          color
+        });
+      }
+    });
+    return graphics;
+  }
+};
+
+// lib/solvers/CapacityMeshSolver/getNodeEdgeMap.ts
+function getNodeEdgeMap(edges) {
+  const nodeEdgeMap = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    for (const nodeId of edge.nodeIds) {
+      nodeEdgeMap.set(nodeId, [...nodeEdgeMap.get(nodeId) ?? [], edge]);
+    }
+  }
+  return nodeEdgeMap;
+}
+
+// lib/solvers/CapacityMeshSolver/CapacityEdgeToPortSegmentSolver.ts
+var CapacityEdgeToPortSegmentSolver = class extends BaseSolver {
+  nodes;
+  edges;
+  capacityPaths;
+  nodeMap;
+  nodeEdgeMap;
+  unprocessedNodeIds;
+  nodePortSegments;
+  colorMap;
+  constructor({
+    nodes,
+    edges,
+    capacityPaths,
+    colorMap
+  }) {
+    super();
+    this.nodes = nodes;
+    this.edges = edges;
+    this.nodeMap = new Map(nodes.map((node) => [node.capacityMeshNodeId, node]));
+    this.nodeEdgeMap = getNodeEdgeMap(edges);
+    this.capacityPaths = capacityPaths;
+    this.colorMap = colorMap ?? {};
+    this.unprocessedNodeIds = [
+      ...new Set(capacityPaths.flatMap((path) => path.nodeIds))
+    ];
+    this.nodePortSegments = /* @__PURE__ */ new Map();
+  }
+  step() {
+    const nodeId = this.unprocessedNodeIds.pop();
+    if (!nodeId) {
+      this.solved = true;
+      return;
+    }
+    const pathsGoingThroughNode = [];
+    for (const path of this.capacityPaths) {
+      const indexOfNodeInPath = path.nodeIds.indexOf(nodeId);
+      if (indexOfNodeInPath !== -1) {
+        pathsGoingThroughNode.push({ path, indexOfNodeInPath });
+      }
+    }
+    const node = this.nodeMap.get(nodeId);
+    const nodePortSegments = [];
+    for (const { path, indexOfNodeInPath } of pathsGoingThroughNode) {
+      const entryNodeId = path.nodeIds[indexOfNodeInPath - 1];
+      const exitNodeId = path.nodeIds[indexOfNodeInPath + 1];
+      for (const adjNodeId of [entryNodeId, exitNodeId]) {
+        const adjNode = this.nodeMap.get(adjNodeId);
+        if (!adjNode) continue;
+        const segment = findOverlappingSegment(node, adjNode);
+        const portSegment = {
+          capacityMeshNodeId: nodeId,
+          start: segment.start,
+          end: segment.end,
+          connectionNames: [path.connectionName]
+        };
+        nodePortSegments.push(portSegment);
+      }
+    }
+    const combinedSegments = combineSegments(nodePortSegments);
+    this.nodePortSegments.set(nodeId, combinedSegments);
+  }
+  visualize() {
+    const graphics = {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: []
+    };
+    this.nodePortSegments.forEach((segments, nodeId) => {
+      const node = this.nodeMap.get(nodeId);
+      segments.forEach((segment) => {
+        const isVertical = segment.start.x === segment.end.x;
+        const THICKNESS = 0.5 / segment.connectionNames.length;
+        for (let i = 0; i < segment.connectionNames.length; i++) {
+          const offsetAmount = (i / (segment.connectionNames.length - 1 + 1e-6) - 0.5) * THICKNESS;
+          const offset = {
+            x: isVertical ? offsetAmount : 0,
+            y: isVertical ? 0 : offsetAmount
+          };
+          const trueSegmentCenter = {
+            x: (segment.start.x + segment.end.x) / 2 + offset.x,
+            y: (segment.start.y + segment.end.y) / 2 + offset.y
+          };
+          graphics.rects.push({
+            center: {
+              x: (trueSegmentCenter.x * 6 + node.center.x) / 7,
+              y: (trueSegmentCenter.y * 6 + node.center.y) / 7
+            },
+            width: isVertical ? THICKNESS : Math.abs(segment.end.x - segment.start.x),
+            height: isVertical ? Math.abs(segment.end.y - segment.start.y) : THICKNESS,
+            fill: safeTransparentize(
+              this.colorMap[segment.connectionNames[i]],
+              0.6
+            ),
+            label: `${nodeId}: ${segment.connectionNames.join(", ")}`
+          });
+        }
+      });
+    });
+    return graphics;
+  }
+};
+function findOverlappingSegment(node, adjNode) {
+  const xOverlap = {
+    start: Math.max(
+      node.center.x - node.width / 2,
+      adjNode.center.x - adjNode.width / 2
+    ),
+    end: Math.min(
+      node.center.x + node.width / 2,
+      adjNode.center.x + adjNode.width / 2
+    )
+  };
+  const yOverlap = {
+    start: Math.max(
+      node.center.y - node.height / 2,
+      adjNode.center.y - adjNode.height / 2
+    ),
+    end: Math.min(
+      node.center.y + node.height / 2,
+      adjNode.center.y + adjNode.height / 2
+    )
+  };
+  const xRange = xOverlap.end - xOverlap.start;
+  const yRange = yOverlap.end - yOverlap.start;
+  if (xRange < yRange) {
+    const x = (xOverlap.start + xOverlap.end) / 2;
+    return {
+      start: { x, y: yOverlap.start },
+      end: { x, y: yOverlap.end }
+    };
+  } else {
+    const y = (yOverlap.start + yOverlap.end) / 2;
+    return {
+      start: { x: xOverlap.start, y },
+      end: { x: xOverlap.end, y }
+    };
+  }
+}
+function combineSegments(segments) {
+  const mergedSegments = [];
+  const remainingSegments = [...segments];
+  while (remainingSegments.length > 0) {
+    const segmentUnderTest = remainingSegments.pop();
+    const overlappingMergedSegment = mergedSegments.find((segment) => {
+      return segment.start.x === segmentUnderTest.start.x && segment.start.y === segmentUnderTest.start.y && segment.end.x === segmentUnderTest.end.x && segment.end.y === segmentUnderTest.end.y;
+    });
+    if (overlappingMergedSegment) {
+      overlappingMergedSegment.connectionNames.push(
+        ...segmentUnderTest.connectionNames
+      );
+    } else {
+      mergedSegments.push(segmentUnderTest);
+    }
+  }
+  return mergedSegments;
+}
+
+// lib/solvers/CapacityMeshSolver/CapacitySegmentToPointSolver.ts
+var CapacitySegmentToPointSolver = class extends BaseSolver {
+  unsolvedSegments;
+  solvedSegments;
+  nodeMap;
+  colorMap;
+  // We use an extra property on segments to remember assigned points.
+  // Each segment will get an added property "assignedPoints" which is an array of:
+  // { connectionName: string, point: {x: number, y: number } }
+  // This is a temporary extension used by the solver.
+  constructor({
+    segments,
+    colorMap,
+    nodes
+  }) {
+    super();
+    this.MAX_ITERATIONS = 1e5;
+    this.unsolvedSegments = segments;
+    this.solvedSegments = [];
+    this.colorMap = colorMap ?? {};
+    this.nodeMap = Object.fromEntries(
+      nodes.map((node) => [node.capacityMeshNodeId, node])
+    );
+  }
+  /**
+   * Perform one iteration step.
+   */
+  _step() {
+    let updated = false;
+    const unsolved = [...this.unsolvedSegments];
+    for (const seg of unsolved) {
+      const n = seg.connectionNames.length;
+      if ("assignedPoints" in seg && seg.assignedPoints?.length === n) continue;
+      if (n === 1) {
+        const center = {
+          x: (seg.start.x + seg.end.x) / 2,
+          y: (seg.start.y + seg.end.y) / 2,
+          z: 0
+        };
+        seg.assignedPoints = [
+          { connectionName: seg.connectionNames[0], point: center }
+        ];
+        this.unsolvedSegments.splice(this.unsolvedSegments.indexOf(seg), 1);
+        this.solvedSegments.push(seg);
+        updated = true;
+      }
+    }
+    if (!updated && unsolved.length > 0) {
+      let candidate = unsolved[0];
+      for (const seg of unsolved) {
+        if (seg.connectionNames.length < candidate.connectionNames.length) {
+          candidate = seg;
+        }
+      }
+      const sortedConnections = [...candidate.connectionNames].sort();
+      const dx = candidate.end.x - candidate.start.x;
+      const dy = candidate.end.y - candidate.start.y;
+      const n = sortedConnections.length;
+      const points = [];
+      for (let i = 1; i <= n; i++) {
+        const fraction = i / (n + 1);
+        points.push({
+          x: candidate.start.x + dx * fraction,
+          y: candidate.start.y + dy * fraction,
+          z: 0
+        });
+      }
+      ;
+      candidate.assignedPoints = sortedConnections.map(
+        (conn, idx) => ({
+          connectionName: conn,
+          point: points[idx]
+        })
+      );
+      this.unsolvedSegments.splice(this.unsolvedSegments.indexOf(candidate), 1);
+      this.solvedSegments.push(candidate);
+      updated = true;
+    }
+    if (this.unsolvedSegments.length === 0) {
+      this.solved = true;
+    }
+  }
+  /**
+   * Return the assigned points for each segment.
+   */
+  getNodesWithPortPoints() {
+    if (!this.solved) {
+      throw new Error(
+        "CapacitySegmentToPointSolver not solved, can't give port points yet"
+      );
+    }
+    const map = /* @__PURE__ */ new Map();
+    for (const seg of this.solvedSegments) {
+      const nodeId = seg.capacityMeshNodeId;
+      const node = this.nodeMap[nodeId];
+      if (!map.has(nodeId)) {
+        map.set(nodeId, {
+          capacityMeshNodeId: nodeId,
+          portPoints: [],
+          center: node.center,
+          width: node.width,
+          height: node.height
+        });
+      }
+      map.get(nodeId).portPoints.push(
+        ...seg.assignedPoints.map((ap) => ({
+          ...ap.point,
+          connectionName: ap.connectionName
+        }))
+      );
+    }
+    return Array.from(map.values());
+  }
+  /**
+   * Return a GraphicsObject that visualizes the segments with assigned points.
+   */
+  visualize() {
+    const graphics = {
+      points: this.solvedSegments.flatMap(
+        (seg) => seg.assignedPoints.map((ap) => ({
+          x: ap.point.x,
+          y: ap.point.y,
+          label: `${seg.capacityMeshNodeId}-${ap.connectionName}`,
+          color: this.colorMap[ap.connectionName],
+          step: 4
+        }))
+      ),
+      lines: this.solvedSegments.map((seg) => ({
+        points: [seg.start, seg.end],
+        step: 4
+      })),
+      rects: [],
+      circles: []
+    };
+    const dashedLines = [];
+    const nodeConnections = {};
+    for (const seg of this.solvedSegments) {
+      const nodeId = seg.capacityMeshNodeId;
+      if (!nodeConnections[nodeId]) {
+        nodeConnections[nodeId] = {};
+      }
+      for (const ap of seg.assignedPoints) {
+        if (!nodeConnections[nodeId][ap.connectionName]) {
+          nodeConnections[nodeId][ap.connectionName] = [];
+        }
+        nodeConnections[nodeId][ap.connectionName].push({
+          x: ap.point.x,
+          y: ap.point.y
+        });
+      }
+    }
+    for (const nodeId in nodeConnections) {
+      for (const conn in nodeConnections[nodeId]) {
+        const points = nodeConnections[nodeId][conn];
+        if (points.length > 1) {
+          dashedLines.push({
+            points,
+            step: 4,
+            strokeDash: "5 5",
+            strokeColor: this.colorMap[conn] || "#000"
+          });
+        }
+      }
+    }
+    graphics.lines.push(...dashedLines);
+    return graphics;
+  }
+};
+
+// lib/solvers/HighDensitySolver/SingleHighDensityRouteSolver.ts
+var SingleHighDensityRouteSolver = class extends BaseSolver {
+  obstacleRoutes;
+  bounds;
+  boundsSize;
+  boundsCenter;
+  A;
+  B;
+  straightLineDistance;
+  viaDiameter;
+  traceThickness;
+  obstacleMargin;
+  layerCount;
+  minCellSize = 0.05;
+  cellStep = 0.05;
+  GREEDY_MULTIPLER = 1.1;
+  numRoutes;
+  VIA_PENALTY_FACTOR = 0.3;
+  CELL_SIZE_FACTOR;
+  exploredNodes;
+  candidates;
+  connectionName;
+  solvedPath = null;
+  futureConnections;
+  hyperParameters;
+  connMap;
+  /** For debugging/animating the exploration */
+  debug_exploredNodesOrdered;
+  debug_nodesTooCloseToObstacle;
+  debug_nodePathToParentIntersectsObstacle;
+  debugEnabled = true;
+  constructor(opts) {
+    super();
+    this.bounds = opts.bounds;
+    this.connMap = opts.connMap;
+    this.hyperParameters = opts.hyperParameters ?? {};
+    this.CELL_SIZE_FACTOR = this.hyperParameters.CELL_SIZE_FACTOR ?? 1;
+    this.boundsSize = {
+      width: this.bounds.maxX - this.bounds.minX,
+      height: this.bounds.maxY - this.bounds.minY
+    };
+    this.boundsCenter = {
+      x: (this.bounds.minX + this.bounds.maxX) / 2,
+      y: (this.bounds.minY + this.bounds.maxY) / 2
+    };
+    this.connectionName = opts.connectionName;
+    this.obstacleRoutes = opts.obstacleRoutes;
+    this.A = opts.A;
+    this.B = opts.B;
+    this.viaDiameter = opts.viaDiameter ?? 0.6;
+    this.traceThickness = opts.traceThickness ?? 0.15;
+    this.obstacleMargin = opts.obstacleMargin ?? 0.2;
+    this.layerCount = opts.layerCount ?? 2;
+    this.exploredNodes = /* @__PURE__ */ new Set();
+    this.candidates = [
+      {
+        ...opts.A,
+        z: opts.A.z ?? 0,
+        g: 0,
+        h: 0,
+        f: 0,
+        parent: null
+      }
+    ];
+    this.straightLineDistance = distance(this.A, this.B);
+    this.futureConnections = opts.futureConnections ?? [];
+    this.MAX_ITERATIONS = 5e3;
+    this.debug_exploredNodesOrdered = [];
+    this.debug_nodesTooCloseToObstacle = /* @__PURE__ */ new Set();
+    this.debug_nodePathToParentIntersectsObstacle = /* @__PURE__ */ new Set();
+    this.numRoutes = this.obstacleRoutes.length + this.futureConnections.length;
+    const bestRowOrColumnCount = Math.ceil(5 * (this.numRoutes + 1));
+    let numXCells = this.boundsSize.width / this.cellStep;
+    let numYCells = this.boundsSize.height / this.cellStep;
+    while (numXCells * numYCells > bestRowOrColumnCount ** 2) {
+      if (this.cellStep * 2 > opts.minDistBetweenEnteringPoints) {
+        break;
+      }
+      this.cellStep *= 2;
+      numXCells = this.boundsSize.width / this.cellStep;
+      numYCells = this.boundsSize.height / this.cellStep;
+    }
+    this.cellStep *= this.CELL_SIZE_FACTOR;
+    if (this.futureConnections && this.futureConnections.length === 0 && this.obstacleRoutes.length === 0) {
+      this.handleSimpleCases();
+    }
+  }
+  handleSimpleCases() {
+    this.solved = true;
+    this.solvedPath = {
+      connectionName: this.connectionName,
+      route: [
+        this.A,
+        { ...this.boundsCenter, z: this.A.z },
+        {
+          ...this.boundsCenter,
+          z: this.B.z
+        },
+        this.B
+      ],
+      traceThickness: this.traceThickness,
+      viaDiameter: this.viaDiameter,
+      vias: this.A.z === this.B.z ? [] : [this.boundsCenter]
+    };
+  }
+  get viaPenaltyDistance() {
+    return this.cellStep + this.straightLineDistance * this.VIA_PENALTY_FACTOR;
+  }
+  isNodeTooCloseToObstacle(node, margin, isVia) {
+    margin ??= this.obstacleMargin;
+    if (isVia && node.parent) {
+      const viasInMyRoute = this.getViasInNodePath(node.parent);
+      for (const via of viasInMyRoute) {
+        if (distance(node, via) < this.viaDiameter / 2 + margin) {
+          return true;
+        }
+      }
+    }
+    for (const route of this.obstacleRoutes) {
+      const connectedToObstacle = this.connMap?.areIdsConnected?.(
+        this.connectionName,
+        route.connectionName
+      );
+      if (!connectedToObstacle) {
+        const pointPairs = getSameLayerPointPairs(route);
+        for (const pointPair of pointPairs) {
+          if ((isVia || pointPair.z === node.z) && pointToSegmentDistance(node, pointPair.A, pointPair.B) < this.traceThickness + margin) {
+            return true;
+          }
+        }
+      }
+      for (const via of route.vias) {
+        if (distance(node, via) < this.viaDiameter / 2 + margin) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  isNodeTooCloseToEdge(node) {
+    const viaRadius = this.viaDiameter / 2;
+    return node.x < this.bounds.minX + viaRadius || node.x > this.bounds.maxX - viaRadius || node.y < this.bounds.minY + viaRadius || node.y > this.bounds.maxY - viaRadius;
+  }
+  doesPathToParentIntersectObstacle(node) {
+    const parent = node.parent;
+    if (!parent) return false;
+    for (const route of this.obstacleRoutes) {
+      const obstacleIsConnectedToNewPath = this.connMap?.areIdsConnected?.(
+        this.connectionName,
+        route.connectionName
+      );
+      if (obstacleIsConnectedToNewPath) continue;
+      for (const pointPair of getSameLayerPointPairs(route)) {
+        if (pointPair.z !== node.z) continue;
+        if (doSegmentsIntersect(node, parent, pointPair.A, pointPair.B)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  computeH(node) {
+    return distance(node, this.B) + // via penalty
+    Math.abs(node.z - this.B.z) * this.viaPenaltyDistance;
+  }
+  computeG(node) {
+    return (node.parent?.g ?? 0) + (node.z === 0 ? 0 : this.viaPenaltyDistance) + distance(node, node.parent);
+  }
+  computeF(g, h) {
+    return g + h * this.GREEDY_MULTIPLER;
+  }
+  getNodeKey(node) {
+    return `${Math.round(node.x / this.cellStep) * this.cellStep},${Math.round(node.y / this.cellStep) * this.cellStep},${node.z}`;
+  }
+  getNeighbors(node) {
+    const neighbors = [];
+    const { maxX, minX, maxY, minY } = this.bounds;
+    for (let x = -1; x <= 1; x++) {
+      for (let y = -1; y <= 1; y++) {
+        if (x === 0 && y === 0) continue;
+        const neighbor = {
+          ...node,
+          parent: node,
+          x: clamp2(node.x + x * this.cellStep, minX, maxX),
+          y: clamp2(node.y + y * this.cellStep, minY, maxY)
+        };
+        const neighborKey = this.getNodeKey(neighbor);
+        if (this.exploredNodes.has(neighborKey)) {
+          continue;
+        }
+        if (this.isNodeTooCloseToObstacle(neighbor)) {
+          this.debug_nodesTooCloseToObstacle.add(neighborKey);
+          this.exploredNodes.add(neighborKey);
+          continue;
+        }
+        if (this.doesPathToParentIntersectObstacle(neighbor)) {
+          this.debug_nodePathToParentIntersectsObstacle.add(neighborKey);
+          this.exploredNodes.add(neighborKey);
+          continue;
+        }
+        neighbor.g = this.computeG(neighbor);
+        neighbor.h = this.computeH(neighbor);
+        neighbor.f = this.computeF(neighbor.g, neighbor.h);
+        neighbors.push(neighbor);
+      }
+    }
+    const viaNeighbor = {
+      ...node,
+      parent: node,
+      z: node.z === 0 ? this.layerCount - 1 : 0
+    };
+    if (!this.exploredNodes.has(this.getNodeKey(viaNeighbor)) && !this.isNodeTooCloseToObstacle(
+      viaNeighbor,
+      this.viaDiameter / 2 + this.obstacleMargin,
+      true
+    ) && !this.isNodeTooCloseToEdge(viaNeighbor)) {
+      viaNeighbor.g = this.computeG(viaNeighbor);
+      viaNeighbor.h = this.computeH(viaNeighbor);
+      viaNeighbor.f = this.computeF(viaNeighbor.g, viaNeighbor.h);
+      neighbors.push(viaNeighbor);
+    }
+    return neighbors;
+  }
+  getNodePath(node) {
+    const path = [];
+    while (node) {
+      path.push(node);
+      node = node.parent;
+    }
+    return path;
+  }
+  getViasInNodePath(node) {
+    const path = this.getNodePath(node);
+    const vias = [];
+    for (let i = 0; i < path.length - 1; i++) {
+      if (path[i].z !== path[i + 1].z) {
+        vias.push({ x: path[i].x, y: path[i].y });
+      }
+    }
+    return vias;
+  }
+  setSolvedPath(node) {
+    const path = this.getNodePath(node);
+    path.reverse();
+    const vias = [];
+    for (let i = 0; i < path.length - 1; i++) {
+      if (path[i].z !== path[i + 1].z) {
+        vias.push({ x: path[i].x, y: path[i].y });
+      }
+    }
+    this.solvedPath = {
+      connectionName: this.connectionName,
+      traceThickness: this.traceThickness,
+      viaDiameter: this.viaDiameter,
+      route: path.map((node2) => ({ x: node2.x, y: node2.y, z: node2.z })).concat([this.B]),
+      vias
+    };
+  }
+  computeProgress(currentNode, goalDist, isOnLayer) {
+    if (!isOnLayer) goalDist += this.viaPenaltyDistance;
+    const goalDistPercent = 1 - goalDist / this.straightLineDistance;
+    return Math.max(
+      this.progress || 0,
+      // 0.112 = ~90% -> 50%
+      //         ~25% -> 2%
+      //         ~99% -> 94%
+      //         ~95% -> 72%
+      2 / Math.PI * Math.atan(0.112 * goalDistPercent / (1 - goalDistPercent))
+    );
+  }
+  _step() {
+    this.candidates.sort((a, b) => b.f - a.f);
+    let currentNode = this.candidates.pop();
+    while (currentNode && this.exploredNodes.has(this.getNodeKey(currentNode))) {
+      currentNode = this.candidates.pop();
+    }
+    if (!currentNode) {
+      this.failed = true;
+      return;
+    }
+    this.exploredNodes.add(this.getNodeKey(currentNode));
+    this.debug_exploredNodesOrdered.push(this.getNodeKey(currentNode));
+    const goalDist = distance(currentNode, this.B);
+    this.progress = this.computeProgress(
+      currentNode,
+      goalDist,
+      currentNode.z === this.B.z
+    );
+    if (goalDist <= this.cellStep && currentNode.z === this.B.z) {
+      this.solved = true;
+      this.setSolvedPath(currentNode);
+    }
+    const neighbors = this.getNeighbors(currentNode);
+    for (const neighbor of neighbors) {
+      this.candidates.push(neighbor);
+    }
+  }
+  visualize() {
+    const graphics = {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: []
+    };
+    graphics.points.push({
+      x: this.A.x,
+      y: this.A.y,
+      label: "Input A",
+      color: "orange"
+    });
+    graphics.points.push({
+      x: this.B.x,
+      y: this.B.y,
+      label: "Input B",
+      color: "orange"
+    });
+    graphics.lines.push({
+      points: [this.A, this.B],
+      strokeColor: "rgba(255, 0, 0, 0.5)",
+      label: "Direct Input Connection"
+    });
+    for (let routeIndex = 0; routeIndex < this.obstacleRoutes.length; routeIndex++) {
+      const route = this.obstacleRoutes[routeIndex];
+      for (let i = 0; i < route.route.length - 1; i++) {
+        const z = route.route[i].z;
+        graphics.lines.push({
+          points: [route.route[i], route.route[i + 1]],
+          strokeColor: z === 0 ? "rgba(255, 0, 0, 0.75)" : "rgba(255, 128, 0, 0.25)",
+          strokeWidth: route.traceThickness,
+          label: "Obstacle Route",
+          layer: `obstacle${routeIndex.toString()}`
+        });
+      }
+    }
+    for (let i = 0; i < this.debug_exploredNodesOrdered.length; i++) {
+      const nodeKey = this.debug_exploredNodesOrdered[i];
+      const [x, y, z] = nodeKey.split(",").map(Number);
+      if (this.debug_nodesTooCloseToObstacle.has(nodeKey)) continue;
+      if (this.debug_nodePathToParentIntersectsObstacle.has(nodeKey)) continue;
+      graphics.rects.push({
+        center: {
+          x: x + z * this.cellStep / 20,
+          y: y + z * this.cellStep / 20
+        },
+        fill: z === 0 ? `rgba(255,0,255,${0.3 - i / this.debug_exploredNodesOrdered.length * 0.2})` : `rgba(0,0,255,${0.3 - i / this.debug_exploredNodesOrdered.length * 0.2})`,
+        width: this.cellStep * 0.9,
+        height: this.cellStep * 0.9,
+        label: `Explored (z=${z})`
+      });
+    }
+    for (const route of this.obstacleRoutes) {
+      for (const via of route.vias) {
+        graphics.circles.push({
+          center: {
+            x: via.x,
+            y: via.y
+          },
+          radius: this.viaDiameter / 2,
+          fill: "rgba(255, 0, 0, 0.5)",
+          label: "Via"
+        });
+      }
+    }
+    if (this.solvedPath) {
+      graphics.lines.push({
+        points: this.solvedPath.route,
+        strokeColor: "green",
+        label: "Solved Route"
+      });
+      for (const via of this.solvedPath.vias) {
+        graphics.circles.push({
+          center: via,
+          radius: this.viaDiameter / 2,
+          fill: "green",
+          label: "Via"
+        });
+      }
+    }
+    return graphics;
+  }
+};
+function getSameLayerPointPairs(route) {
+  const pointPairs = [];
+  for (let i = 0; i < route.route.length - 1; i++) {
+    if (route.route[i].z === route.route[i + 1].z) {
+      pointPairs.push({
+        z: route.route[i].z,
+        A: route.route[i],
+        B: route.route[i + 1]
+      });
+    }
+  }
+  return pointPairs;
+}
+function clamp2(value, min, max) {
+  return Math.max(min, Math.min(value, max));
+}
+
+// lib/solvers/HighDensitySolver/SingleHighDensityRouteSolver6_VertHorzLayer_FutureCost.ts
+var SingleHighDensityRouteSolver6_VertHorzLayer_FutureCost = class extends SingleHighDensityRouteSolver {
+  FUTURE_CONNECTION_PROX_TRACE_PENALTY_FACTOR = 2;
+  FUTURE_CONNECTION_PROX_VIA_PENALTY_FACTOR = 1;
+  FUTURE_CONNECTION_PROXIMITY_VD = 10;
+  MISALIGNED_DIST_PENALTY_FACTOR = 5;
+  VIA_PENALTY_FACTOR_2 = 1;
+  FLIP_TRACE_ALIGNMENT_DIRECTION = false;
+  constructor(opts) {
+    super(opts);
+    for (const key in opts.hyperParameters) {
+      this[key] = opts.hyperParameters[key];
+    }
+    const viasThatCanFitHorz = this.boundsSize.width / this.viaDiameter;
+    this.VIA_PENALTY_FACTOR = 0.3 * (viasThatCanFitHorz / this.numRoutes) * this.VIA_PENALTY_FACTOR_2;
+  }
+  getClosestFutureConnectionPoint(node) {
+    let minDist = Infinity;
+    let closestPoint = null;
+    for (const futureConnection of this.futureConnections) {
+      for (const point of futureConnection.points) {
+        const dist = distance(node, point);
+        if (dist < minDist) {
+          minDist = dist;
+          closestPoint = point;
+        }
+      }
+    }
+    return closestPoint;
+  }
+  /**
+   * Rapidly approaches 0 as the goal distance approaches 0
+   */
+  diminishCloseToGoal(node) {
+    const goalDist = distance(node, this.B);
+    return 1 - Math.exp(-goalDist / this.straightLineDistance * 5);
+  }
+  getFutureConnectionPenalty(node, isVia) {
+    let futureConnectionPenalty = 0;
+    const closestFuturePoint = this.getClosestFutureConnectionPoint(node);
+    const goalDist = distance(node, this.B);
+    if (closestFuturePoint) {
+      const distToFuturePoint = distance(node, closestFuturePoint);
+      if (goalDist <= distToFuturePoint) return 0;
+      const maxDist = this.viaDiameter * this.FUTURE_CONNECTION_PROXIMITY_VD;
+      const distRatio = distToFuturePoint / maxDist;
+      const maxPenalty = isVia ? this.straightLineDistance * this.FUTURE_CONNECTION_PROX_VIA_PENALTY_FACTOR : this.straightLineDistance * this.FUTURE_CONNECTION_PROX_TRACE_PENALTY_FACTOR;
+      futureConnectionPenalty = maxPenalty * Math.exp(-distRatio * 5);
+    }
+    return futureConnectionPenalty;
+  }
+  computeH(node) {
+    const goalDist = distance(node, this.B) ** 1.6;
+    const goalDistRatio = goalDist / this.straightLineDistance;
+    const baseCost = goalDist + (node.z !== this.B.z ? this.viaPenaltyDistance : 0);
+    return baseCost + this.getFutureConnectionPenalty(node, node.z !== node.parent?.z);
+  }
+  computeG(node) {
+    const dx = Math.abs(node.x - node.parent.x);
+    const dy = Math.abs(node.y - node.parent.y);
+    const dist = Math.sqrt(dx ** 2 + dy ** 2);
+    const misalignedDist = !this.FLIP_TRACE_ALIGNMENT_DIRECTION ? node.z === 0 ? dy : dx : node.z === 0 ? dx : dy;
+    const baseCost = (node.parent?.g ?? 0) + (node.z === node.parent?.z ? 0 : this.viaPenaltyDistance) + dist + misalignedDist * this.MISALIGNED_DIST_PENALTY_FACTOR;
+    return baseCost + this.getFutureConnectionPenalty(node, node.z !== node.parent?.z);
+  }
+};
+
+// lib/utils/cloneAndShuffleArray.ts
+function seededRandom(seed) {
+  let s = seed;
+  for (let i = 0; i < 10; i++) {
+    s = s * 16807 % 2147483647;
+  }
+  let state0 = s;
+  s = (seed * 69069 + 1) % 2147483647;
+  for (let i = 0; i < 10; i++) {
+    s = s * 48271 % 2147483647;
+  }
+  let state1 = s;
+  return () => {
+    let s1 = state0;
+    const s0 = state1;
+    state0 = s0;
+    s1 ^= s1 << 23;
+    s1 ^= s1 >>> 17;
+    s1 ^= s0;
+    s1 ^= s0 >>> 26;
+    state1 = s1;
+    const result = (state0 + state1) / 4294967296;
+    return result - Math.floor(result);
+  };
+}
+function cloneAndShuffleArray(arr, seed) {
+  if (seed === 0) return arr;
+  const random = seededRandom(seed);
+  const shuffled = arr.slice();
+  for (let i = 0; i < shuffled.length; i++) {
+    const i1 = Math.floor(random() * shuffled.length);
+    const i2 = Math.floor(random() * (i + 1));
+    [shuffled[i1], shuffled[i2]] = [shuffled[i2], shuffled[i1]];
+  }
+  return shuffled;
+}
+
+// lib/utils/getBoundsFromNodeWithPortPoints.ts
+function getBoundsFromNodeWithPortPoints(nodeWithPortPoints) {
+  const bounds = {
+    minX: nodeWithPortPoints.center.x - nodeWithPortPoints.width / 2,
+    maxX: nodeWithPortPoints.center.x + nodeWithPortPoints.width / 2,
+    minY: nodeWithPortPoints.center.y - nodeWithPortPoints.height / 2,
+    maxY: nodeWithPortPoints.center.y + nodeWithPortPoints.height / 2
+  };
+  for (const pt of nodeWithPortPoints.portPoints) {
+    if (pt.x < bounds.minX) {
+      bounds.minX = pt.x;
+    }
+    if (pt.x > bounds.maxX) {
+      bounds.maxX = pt.x;
+    }
+    if (pt.y < bounds.minY) {
+      bounds.minY = pt.y;
+    }
+    if (pt.y > bounds.maxY) {
+      bounds.maxY = pt.y;
+    }
+  }
+  return bounds;
+}
+
+// lib/utils/getMinDistBetweenEnteringPoints.ts
+var getMinDistBetweenEnteringPoints = (node) => {
+  let minDist = Infinity;
+  const points = node.portPoints;
+  for (let i = 0; i < points.length; i++) {
+    for (let j = i + 1; j < points.length; j++) {
+      const p1 = points[i];
+      const p2 = points[j];
+      const dist = Math.sqrt((p1.x - p2.x) ** 2 + (p1.y - p2.y) ** 2);
+      minDist = Math.min(minDist, dist);
+    }
+  }
+  return minDist === Infinity ? 0 : minDist;
+};
+
+// lib/solvers/HighDensitySolver/SingleIntraNodeRouteSolver.ts
+var SingleIntraNodeRouteSolver = class extends BaseSolver {
+  nodeWithPortPoints;
+  colorMap;
+  unsolvedConnections;
+  totalConnections;
+  solvedRoutes;
+  failedSolvers;
+  hyperParameters;
+  minDistBetweenEnteringPoints;
+  activeSolver = null;
+  connMap;
+  constructor(params) {
+    const { nodeWithPortPoints, colorMap } = params;
+    super();
+    this.nodeWithPortPoints = nodeWithPortPoints;
+    this.colorMap = colorMap ?? {};
+    this.solvedRoutes = [];
+    this.hyperParameters = params.hyperParameters ?? {};
+    this.failedSolvers = [];
+    this.connMap = params.connMap;
+    const unsolvedConnectionsMap = /* @__PURE__ */ new Map();
+    for (const { connectionName, x, y, z } of nodeWithPortPoints.portPoints) {
+      unsolvedConnectionsMap.set(connectionName, [
+        ...unsolvedConnectionsMap.get(connectionName) ?? [],
+        { x, y, z: z ?? 0 }
+      ]);
+    }
+    this.unsolvedConnections = Array.from(
+      unsolvedConnectionsMap.entries().map(([connectionName, points]) => ({
+        connectionName,
+        points
+      }))
+    );
+    if (this.hyperParameters.SHUFFLE_SEED) {
+      this.unsolvedConnections = cloneAndShuffleArray(
+        this.unsolvedConnections,
+        this.hyperParameters.SHUFFLE_SEED ?? 0
+      );
+      this.unsolvedConnections = this.unsolvedConnections.map(
+        ({ points, ...rest }, i) => ({
+          ...rest,
+          points: cloneAndShuffleArray(
+            points,
+            i * 7117 + (this.hyperParameters.SHUFFLE_SEED ?? 0)
+          )
+        })
+      );
+    }
+    this.totalConnections = this.unsolvedConnections.length;
+    this.MAX_ITERATIONS = 1e3 * this.totalConnections ** 1.5;
+    this.minDistBetweenEnteringPoints = getMinDistBetweenEnteringPoints(
+      this.nodeWithPortPoints
+    );
+  }
+  // handleSimpleNoCrossingsCase() {
+  //   // TODO check to make sure there are no crossings due to trace width
+  //   this.solved = true
+  //   this.solvedRoutes = this.unsolvedConnections.map(
+  //     ({ connectionName, points }) => ({
+  //       connectionName,
+  //       route: points,
+  //       traceThickness: 0.1, // TODO load from hyperParameters
+  //       viaDiameter: 0.6,
+  //       vias: [],
+  //     }),
+  //   )
+  //   this.unsolvedConnections = []
+  // }
+  computeProgress() {
+    return (this.solvedRoutes.length + (this.activeSolver?.progress || 0)) / this.totalConnections;
+  }
+  _step() {
+    if (this.activeSolver) {
+      this.activeSolver.step();
+      this.progress = this.computeProgress();
+      if (this.activeSolver.solved) {
+        this.solvedRoutes.push(this.activeSolver.solvedPath);
+        this.activeSolver = null;
+      } else if (this.activeSolver.failed) {
+        this.failedSolvers.push(this.activeSolver);
+        this.activeSolver = null;
+        this.error = this.failedSolvers.map((s) => s.error).join("\n");
+        this.failed = true;
+      }
+      return;
+    }
+    const unsolvedConnection = this.unsolvedConnections.pop();
+    this.progress = this.computeProgress();
+    if (!unsolvedConnection) {
+      this.solved = this.failedSolvers.length === 0;
+      return;
+    }
+    const { connectionName, points } = unsolvedConnection;
+    this.activeSolver = new SingleHighDensityRouteSolver6_VertHorzLayer_FutureCost({
+      connectionName,
+      minDistBetweenEnteringPoints: this.minDistBetweenEnteringPoints,
+      bounds: getBoundsFromNodeWithPortPoints(this.nodeWithPortPoints),
+      A: { x: points[0].x, y: points[0].y, z: points[0].z },
+      B: {
+        x: points[points.length - 1].x,
+        y: points[points.length - 1].y,
+        z: points[points.length - 1].z
+      },
+      obstacleRoutes: this.solvedRoutes,
+      futureConnections: this.unsolvedConnections,
+      layerCount: 2,
+      hyperParameters: this.hyperParameters,
+      connMap: this.connMap
+    });
+  }
+  visualize() {
+    const graphics = {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: []
+    };
+    for (const pt of this.nodeWithPortPoints.portPoints) {
+      graphics.points.push({
+        x: pt.x,
+        y: pt.y,
+        label: [pt.connectionName, `layer: ${pt.z}`].join("\n"),
+        color: this.colorMap[pt.connectionName] ?? "blue"
+      });
+    }
+    for (let routeIndex = 0; routeIndex < this.solvedRoutes.length; routeIndex++) {
+      const route = this.solvedRoutes[routeIndex];
+      if (route.route.length > 0) {
+        const routeColor = this.colorMap[route.connectionName] ?? "blue";
+        for (let i = 0; i < route.route.length - 1; i++) {
+          const p1 = route.route[i];
+          const p2 = route.route[i + 1];
+          graphics.lines.push({
+            points: [p1, p2],
+            strokeColor: p1.z === 0 ? safeTransparentize(routeColor, 0.2) : safeTransparentize(routeColor, 0.8),
+            layer: `route-layer-${p1.z}`,
+            step: routeIndex,
+            strokeWidth: route.traceThickness
+          });
+        }
+        for (const via of route.vias) {
+          graphics.circles.push({
+            center: { x: via.x, y: via.y },
+            radius: route.viaDiameter / 2,
+            fill: safeTransparentize(routeColor, 0.5),
+            layer: "via",
+            step: routeIndex
+          });
+        }
+      }
+    }
+    return graphics;
+  }
+};
+
+// lib/solvers/HyperParameterSupervisorSolver.ts
+var HyperParameterSupervisorSolver = class extends BaseSolver {
+  GREEDY_MULTIPLIER = 1.2;
+  MIN_SUBSTEPS = 1;
+  supervisedSolvers;
+  getHyperParameterDefs() {
+    throw new Error("Not implemented");
+  }
+  getCombinationDefs() {
+    return null;
+  }
+  getHyperParameterCombinations(hyperParameterDefs) {
+    if (!hyperParameterDefs) {
+      hyperParameterDefs = this.getHyperParameterDefs();
+    }
+    const combinations = [];
+    if (hyperParameterDefs.length === 0) {
+      return [{}];
+    }
+    const [currentDef, ...remainingDefs] = hyperParameterDefs;
+    const subCombinations = this.getHyperParameterCombinations(remainingDefs);
+    currentDef.possibleValues.forEach((value) => {
+      subCombinations.forEach((subCombo) => {
+        combinations.push({
+          ...subCombo,
+          ...value
+        });
+      });
+    });
+    return combinations;
+  }
+  initializeSolvers() {
+    const hyperParameterDefs = this.getHyperParameterDefs();
+    const combinationDefs = this.getCombinationDefs() ?? [
+      hyperParameterDefs.map((def) => def.name)
+    ];
+    this.supervisedSolvers = [];
+    for (const combinationDef of combinationDefs) {
+      const hyperParameterCombinations = this.getHyperParameterCombinations(
+        hyperParameterDefs.filter((hpd) => combinationDef.includes(hpd.name))
+      );
+      for (const hyperParameters of hyperParameterCombinations) {
+        const solver = this.generateSolver(hyperParameters);
+        this.supervisedSolvers.push({
+          hyperParameters,
+          solver,
+          h: 0,
+          g: 0,
+          f: 0
+        });
+      }
+    }
+  }
+  generateSolver(hyperParameters) {
+    throw new Error("Not implemented");
+  }
+  computeG(solver) {
+    return solver.iterations / solver.MAX_ITERATIONS;
+  }
+  computeH(solver) {
+    return 1 - (solver.progress || 0);
+  }
+  computeF(g, h) {
+    return g + h * this.GREEDY_MULTIPLIER;
+  }
+  getSupervisedSolverWithBestFitness() {
+    let bestFitness = Infinity;
+    let bestSolver = null;
+    for (const supervisedSolver of this.supervisedSolvers ?? []) {
+      if (supervisedSolver.solver.solved) {
+        return supervisedSolver;
+      }
+      if (supervisedSolver.solver.failed) {
+        continue;
+      }
+      const fitness = supervisedSolver.f;
+      if (fitness < bestFitness) {
+        bestFitness = fitness;
+        bestSolver = supervisedSolver;
+      }
+    }
+    return bestSolver;
+  }
+  _step() {
+    if (!this.supervisedSolvers) this.initializeSolvers();
+    const supervisedSolver = this.getSupervisedSolverWithBestFitness();
+    if (!supervisedSolver) {
+      this.failed = true;
+      this.error = "All solvers failed";
+      return;
+    }
+    for (let i = 0; i < this.MIN_SUBSTEPS; i++) {
+      supervisedSolver.solver.step();
+    }
+    supervisedSolver.g = this.computeG(supervisedSolver.solver);
+    supervisedSolver.h = this.computeH(supervisedSolver.solver);
+    supervisedSolver.f = this.computeF(supervisedSolver.g, supervisedSolver.h);
+    if (supervisedSolver.solver.solved) {
+      this.solved = true;
+      this.onSolve?.(supervisedSolver);
+    }
+  }
+  onSolve(solver) {
+  }
+  visualize() {
+    const bestSupervisedSolver = this.getSupervisedSolverWithBestFitness();
+    let graphics = {
+      lines: [],
+      circles: [],
+      points: [],
+      rects: []
+    };
+    if (bestSupervisedSolver) {
+      graphics = bestSupervisedSolver.solver.visualize();
+    }
+    return graphics;
+  }
+};
+
+// lib/solvers/HyperHighDensitySolver/HyperSingleIntraNodeSolver.ts
+var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
+  constructorParams;
+  solvedRoutes = [];
+  nodeWithPortPoints;
+  constructor(opts) {
+    super();
+    this.nodeWithPortPoints = opts.nodeWithPortPoints;
+    this.constructorParams = opts;
+    this.MAX_ITERATIONS = 25e4;
+    this.GREEDY_MULTIPLIER = 5;
+    this.MIN_SUBSTEPS = 100;
+  }
+  getCombinationDefs() {
+    return [
+      ["majorCombinations", "orderings6", "cellSizeFactor"],
+      ["noVias"],
+      ["orderings50"],
+      ["flipTraceAlignmentDirection", "orderings6"]
+    ];
+  }
+  getHyperParameterDefs() {
+    return [
+      {
+        name: "majorCombinations",
+        possibleValues: [
+          {
+            FUTURE_CONNECTION_PROX_TRACE_PENALTY_FACTOR: 2,
+            FUTURE_CONNECTION_PROX_VIA_PENALTY_FACTOR: 1,
+            FUTURE_CONNECTION_PROXIMITY_VD: 10,
+            MISALIGNED_DIST_PENALTY_FACTOR: 5
+          },
+          {
+            FUTURE_CONNECTION_PROX_TRACE_PENALTY_FACTOR: 1,
+            FUTURE_CONNECTION_PROX_VIA_PENALTY_FACTOR: 0.5,
+            FUTURE_CONNECTION_PROXIMITY_VD: 5,
+            MISALIGNED_DIST_PENALTY_FACTOR: 2
+          },
+          {
+            FUTURE_CONNECTION_PROX_TRACE_PENALTY_FACTOR: 10,
+            FUTURE_CONNECTION_PROX_VIA_PENALTY_FACTOR: 1,
+            FUTURE_CONNECTION_PROXIMITY_VD: 5,
+            MISALIGNED_DIST_PENALTY_FACTOR: 10,
+            VIA_PENALTY_FACTOR_2: 1
+          }
+        ]
+      },
+      {
+        name: "orderings6",
+        possibleValues: [
+          {
+            SHUFFLE_SEED: 0
+          },
+          {
+            SHUFFLE_SEED: 1
+          },
+          {
+            SHUFFLE_SEED: 2
+          },
+          {
+            SHUFFLE_SEED: 3
+          },
+          {
+            SHUFFLE_SEED: 4
+          },
+          {
+            SHUFFLE_SEED: 5
+          }
+        ]
+      },
+      {
+        name: "cellSizeFactor",
+        possibleValues: [
+          {
+            CELL_SIZE_FACTOR: 0.5
+          },
+          {
+            CELL_SIZE_FACTOR: 1
+          }
+        ]
+      },
+      {
+        name: "flipTraceAlignmentDirection",
+        possibleValues: [
+          {
+            FLIP_TRACE_ALIGNMENT_DIRECTION: true
+          }
+        ]
+      },
+      {
+        name: "noVias",
+        possibleValues: [
+          {
+            CELL_SIZE_FACTOR: 2,
+            VIA_PENALTY_FACTOR_2: 10
+          }
+        ]
+      },
+      {
+        name: "orderings50",
+        possibleValues: Array.from({ length: 50 }, (_, i) => ({
+          SHUFFLE_SEED: 100 + i
+        }))
+      }
+    ];
+  }
+  computeG(solver) {
+    return solver.iterations / 1e4;
+  }
+  computeH(solver) {
+    return 1 - (solver.progress || 0);
+  }
+  generateSolver(hyperParameters) {
+    return new SingleIntraNodeRouteSolver({
+      ...this.constructorParams,
+      hyperParameters
+    });
+  }
+  onSolve(solver) {
+    this.solvedRoutes = solver.solver.solvedRoutes;
+  }
+};
+
+// lib/utils/mergeRouteSegments.ts
+function mergeRouteSegments(route, connectionName, color) {
+  const segments = [];
+  let currentSegment = null;
+  for (let i = 0; i < route.length; i++) {
+    const point = route[i];
+    if (!currentSegment) {
+      currentSegment = {
+        points: [{ x: point.x, y: point.y }],
+        z: point.z,
+        connectionName,
+        color
+      };
+    } else if (currentSegment.z === point.z) {
+      currentSegment.points.push({ x: point.x, y: point.y });
+    } else {
+      segments.push(currentSegment);
+      currentSegment = {
+        points: [{ x: point.x, y: point.y }],
+        z: point.z,
+        connectionName,
+        color
+      };
+    }
+    if (i === route.length - 1 && currentSegment) {
+      segments.push(currentSegment);
+    }
+  }
+  return segments;
+}
+
+// lib/solvers/HighDensitySolver/HighDensityRouteSolver.ts
+var HighDensityRouteSolver = class extends BaseSolver {
+  unsolvedNodePortPoints;
+  routes;
+  colorMap;
+  // Defaults as specified: viaDiameter of 0.6 and traceThickness of 0.15
+  defaultViaDiameter = 0.6;
+  defaultTraceThickness = 0.15;
+  failedSolvers;
+  activeSubSolver = null;
+  connMap;
+  constructor({
+    nodePortPoints,
+    colorMap,
+    connMap
+  }) {
+    super();
+    this.unsolvedNodePortPoints = nodePortPoints;
+    this.colorMap = colorMap ?? {};
+    this.connMap = connMap;
+    this.routes = [];
+    this.failedSolvers = [];
+    this.MAX_ITERATIONS = 1e6;
+  }
+  /**
+   * Each iteration, pop an unsolved node and attempt to find the routes inside
+   * of it.
+   */
+  _step() {
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step();
+      if (this.activeSubSolver.solved) {
+        this.routes.push(...this.activeSubSolver.solvedRoutes);
+        this.activeSubSolver = null;
+      } else if (this.activeSubSolver.failed) {
+        this.failedSolvers.push(this.activeSubSolver);
+        this.activeSubSolver = null;
+      }
+      return;
+    }
+    if (this.unsolvedNodePortPoints.length === 0) {
+      this.solved = true;
+      return;
+    }
+    const node = this.unsolvedNodePortPoints.pop();
+    this.activeSubSolver = new HyperSingleIntraNodeSolver({
+      nodeWithPortPoints: node,
+      colorMap: this.colorMap,
+      connMap: this.connMap
+    });
+  }
+  visualize() {
+    let graphics = {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: []
+    };
+    for (const route of this.routes) {
+      const mergedSegments = mergeRouteSegments(
+        route.route,
+        route.connectionName,
+        this.colorMap[route.connectionName]
+      );
+      for (const segment of mergedSegments) {
+        graphics.lines.push({
+          points: segment.points,
+          label: segment.connectionName,
+          strokeColor: segment.z === 0 ? segment.color : safeTransparentize(segment.color, 0.75),
+          strokeWidth: route.traceThickness,
+          strokeDash: segment.z !== 0 ? "10, 5" : void 0
+        });
+      }
+      for (const via of route.vias) {
+        graphics.circles.push({
+          center: via,
+          radius: route.viaDiameter / 2,
+          fill: this.colorMap[route.connectionName],
+          label: `${route.connectionName} via`
+        });
+      }
+    }
+    for (const solver of this.failedSolvers) {
+      const node = solver.nodeWithPortPoints;
+      const connectionGroups = {};
+      for (const pt of node.portPoints) {
+        if (!connectionGroups[pt.connectionName]) {
+          connectionGroups[pt.connectionName] = [];
+        }
+        connectionGroups[pt.connectionName].push({ x: pt.x, y: pt.y, z: pt.z });
+      }
+      for (const [connectionName, points] of Object.entries(connectionGroups)) {
+        for (let i = 0; i < points.length - 1; i++) {
+          const start = points[i];
+          const end = points[i + 1];
+          graphics.lines.push({
+            points: [start, end],
+            strokeColor: "red",
+            strokeDash: "10, 5"
+          });
+        }
+      }
+    }
+    if (this.activeSubSolver) {
+      graphics = combineVisualizations(
+        graphics,
+        this.activeSubSolver.visualize()
+      );
+    }
+    return graphics;
+  }
+};
+
+// lib/solvers/CapacityPathingSolver/CapacityPathingSolver.ts
+var CapacityPathingSolver = class extends BaseSolver {
+  connectionsWithNodes;
+  usedNodeCapacityMap;
+  simpleRouteJson;
+  nodes;
+  edges;
+  GREEDY_MULTIPLIER = 1.1;
+  nodeMap;
+  nodeEdgeMap;
+  connectionNameToGoalNodeIds;
+  colorMap;
+  maxDepthOfNodes;
+  activeCandidateStraightLineDistance;
+  hyperParameters;
+  constructor({
+    simpleRouteJson,
+    nodes,
+    edges,
+    colorMap,
+    MAX_ITERATIONS = 1e6,
+    hyperParameters = {}
+  }) {
+    super();
+    this.MAX_ITERATIONS = MAX_ITERATIONS;
+    this.simpleRouteJson = simpleRouteJson;
+    this.nodes = nodes;
+    this.edges = edges;
+    this.colorMap = colorMap ?? {};
+    const { connectionsWithNodes, connectionNameToGoalNodeIds } = this.getConnectionsWithNodes();
+    this.connectionsWithNodes = connectionsWithNodes;
+    this.connectionNameToGoalNodeIds = connectionNameToGoalNodeIds;
+    this.hyperParameters = hyperParameters;
+    this.usedNodeCapacityMap = new Map(
+      this.nodes.map((node) => [node.capacityMeshNodeId, 0])
+    );
+    this.nodeMap = new Map(
+      this.nodes.map((node) => [node.capacityMeshNodeId, node])
+    );
+    this.nodeEdgeMap = getNodeEdgeMap(this.edges);
+    this.maxDepthOfNodes = Math.max(
+      ...this.nodes.map((node) => node._depth ?? 0)
+    );
+  }
+  getTotalCapacity(node) {
+    const depth = node._depth ?? 0;
+    return (this.maxDepthOfNodes - depth + 1) ** 2;
+  }
+  getConnectionsWithNodes() {
+    const connectionsWithNodes = [];
+    const nodesWithTargets = this.nodes.filter((node) => node._containsTarget);
+    const connectionNameToGoalNodeIds = /* @__PURE__ */ new Map();
+    for (const connection of this.simpleRouteJson.connections) {
+      const nodesForConnection = [];
+      for (const point of connection.pointsToConnect) {
+        let closestNode = this.nodes[0];
+        let minDistance = Number.MAX_VALUE;
+        for (const node of nodesWithTargets) {
+          const distance3 = Math.sqrt(
+            (node.center.x - point.x) ** 2 + (node.center.y - point.y) ** 2
+          );
+          if (distance3 < minDistance) {
+            minDistance = distance3;
+            closestNode = node;
+          }
+        }
+        nodesForConnection.push(closestNode);
+      }
+      if (nodesForConnection.length < 2) {
+        throw new Error(
+          `Not enough nodes for connection "${connection.name}", only ${nodesForConnection.length} found`
+        );
+      }
+      connectionNameToGoalNodeIds.set(
+        connection.name,
+        nodesForConnection.map((n) => n.capacityMeshNodeId)
+      );
+      connectionsWithNodes.push({
+        connection,
+        nodes: nodesForConnection,
+        pathFound: false
+      });
+    }
+    return { connectionsWithNodes, connectionNameToGoalNodeIds };
+  }
+  currentConnectionIndex = 0;
+  candidates;
+  visitedNodes;
+  computeG(prevCandidate, node, endGoal) {
+    return prevCandidate.g + this.getDistanceBetweenNodes(prevCandidate.node, node);
+  }
+  computeH(prevCandidate, node, endGoal) {
+    return this.getDistanceBetweenNodes(node, endGoal);
+  }
+  getBacktrackedPath(candidate) {
+    const path = [];
+    let currentCandidate = candidate;
+    while (currentCandidate) {
+      path.push(currentCandidate.node);
+      currentCandidate = currentCandidate.prevCandidate;
+    }
+    return path;
+  }
+  getNeighboringNodes(node) {
+    return this.nodeEdgeMap.get(node.capacityMeshNodeId).flatMap(
+      (edge) => edge.nodeIds.filter((n) => n !== node.capacityMeshNodeId)
+    ).map((n) => this.nodeMap.get(n));
+  }
+  getCapacityPaths() {
+    const capacityPaths = [];
+    for (const connection of this.connectionsWithNodes) {
+      const path = connection.path;
+      if (path) {
+        capacityPaths.push({
+          capacityPathId: connection.connection.name,
+          connectionName: connection.connection.name,
+          nodeIds: path.map((node) => node.capacityMeshNodeId)
+        });
+      }
+    }
+    return capacityPaths;
+  }
+  doesNodeHaveCapacityForTrace(node) {
+    const usedCapacity = this.usedNodeCapacityMap.get(node.capacityMeshNodeId) ?? 0;
+    const totalCapacity = this.getTotalCapacity(node);
+    return usedCapacity < totalCapacity;
+  }
+  canTravelThroughObstacle(node, connectionName) {
+    const goalNodeIds = this.connectionNameToGoalNodeIds.get(connectionName);
+    return goalNodeIds?.includes(node.capacityMeshNodeId) ?? false;
+  }
+  getDistanceBetweenNodes(A, B) {
+    return Math.sqrt(
+      (A.center.x - B.center.x) ** 2 + (A.center.y - B.center.y) ** 2
+    );
+  }
+  reduceCapacityAlongPath(nextConnection) {
+    for (const node of nextConnection.path ?? []) {
+      this.usedNodeCapacityMap.set(
+        node.capacityMeshNodeId,
+        this.usedNodeCapacityMap.get(node.capacityMeshNodeId) + 1
+      );
+    }
+  }
+  _step() {
+    const nextConnection = this.connectionsWithNodes[this.currentConnectionIndex];
+    if (!nextConnection) {
+      this.solved = true;
+      return;
+    }
+    const [start, end] = nextConnection.nodes;
+    if (!this.candidates) {
+      this.candidates = [{ prevCandidate: null, node: start, f: 0, g: 0, h: 0 }];
+      this.visitedNodes = /* @__PURE__ */ new Set([start.capacityMeshNodeId]);
+      this.activeCandidateStraightLineDistance = distance(
+        start.center,
+        end.center
+      );
+    }
+    this.candidates.sort((a, b) => a.f - b.f);
+    const currentCandidate = this.candidates.shift();
+    if (!currentCandidate) {
+      console.error(
+        `Ran out of candidates on connection ${nextConnection.connection.name}`
+      );
+      this.currentConnectionIndex++;
+      this.candidates = null;
+      this.visitedNodes = null;
+      return;
+    }
+    if (currentCandidate.node.capacityMeshNodeId === end.capacityMeshNodeId) {
+      nextConnection.path = this.getBacktrackedPath(currentCandidate);
+      this.reduceCapacityAlongPath(nextConnection);
+      this.currentConnectionIndex++;
+      this.candidates = null;
+      this.visitedNodes = null;
+      return;
+    }
+    const neighborNodes = this.getNeighboringNodes(currentCandidate.node);
+    for (const neighborNode of neighborNodes) {
+      if (this.visitedNodes?.has(neighborNode.capacityMeshNodeId)) {
+        continue;
+      }
+      if (!this.doesNodeHaveCapacityForTrace(neighborNode)) {
+        continue;
+      }
+      const connectionName = this.connectionsWithNodes[this.currentConnectionIndex].connection.name;
+      if (neighborNode._containsObstacle && !this.canTravelThroughObstacle(neighborNode, connectionName)) {
+        continue;
+      }
+      const g = this.computeG(currentCandidate, neighborNode, end);
+      const h = this.computeH(currentCandidate, neighborNode, end);
+      const f = g + h * this.GREEDY_MULTIPLIER;
+      const newCandidate = {
+        prevCandidate: currentCandidate,
+        node: neighborNode,
+        f,
+        g,
+        h
+      };
+      this.candidates.push(newCandidate);
+    }
+    this.visitedNodes.add(currentCandidate.node.capacityMeshNodeId);
+  }
+  visualize() {
+    const graphics = {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: []
+    };
+    if (this.connectionsWithNodes) {
+      for (let i = 0; i < this.connectionsWithNodes.length; i++) {
+        const conn = this.connectionsWithNodes[i];
+        if (conn.path && conn.path.length > 0) {
+          const pathPoints = conn.path.map(({ center: { x, y }, width }) => ({
+            // slight offset to allow viewing overlapping paths
+            x: x + (i % 10 + i % 19) * (0.01 * width),
+            y: y + (i % 10 + i % 19) * (0.01 * width)
+          }));
+          graphics.lines.push({
+            points: pathPoints,
+            strokeColor: this.colorMap[conn.connection.name]
+          });
+        }
+      }
+    }
+    for (const node of this.nodes) {
+      graphics.rects.push({
+        center: node.center,
+        width: Math.max(node.width - 2, node.width * 0.8),
+        height: Math.max(node.height - 2, node.height * 0.8),
+        fill: node._containsObstacle ? "rgba(255,0,0,0.1)" : "rgba(0,0,0,0.1)",
+        label: `${node.capacityMeshNodeId}
+${this.usedNodeCapacityMap.get(node.capacityMeshNodeId)}/${this.getTotalCapacity(node).toFixed(2)}
+${node.width.toFixed(2)}x${node.height.toFixed(2)}`
+      });
+    }
+    if (this.connectionsWithNodes) {
+      for (const conn of this.connectionsWithNodes) {
+        if (conn.connection?.pointsToConnect) {
+          for (const point of conn.connection.pointsToConnect) {
+            graphics.points.push({
+              x: point.x,
+              y: point.y
+            });
+          }
+        }
+      }
+    }
+    if (this.candidates) {
+      const topCandidates = this.candidates.slice(0, 50);
+      const connectionName = this.connectionsWithNodes[this.currentConnectionIndex].connection.name;
+      topCandidates.forEach((candidate, index) => {
+        const opacity = 0.05 * (1 - index / 50);
+        const backtrackedPath = this.getBacktrackedPath(candidate);
+        graphics.lines.push({
+          points: backtrackedPath.map(({ center: { x, y } }) => ({ x, y })),
+          strokeColor: safeTransparentize(
+            this.colorMap[connectionName] ?? "red",
+            1 - opacity
+          ),
+          strokeWidth: 0.5
+        });
+      });
+    }
+    return graphics;
+  }
+};
+
+// lib/utils/getTunedTotalCapacity1.ts
+var getTunedTotalCapacity1 = (nodeOrWidth, maxCapacityFactor = 1) => {
+  const VIA_DIAMETER = 0.6;
+  const TRACE_WIDTH = 0.15;
+  const obstacleMargin = 0.2;
+  const width = "width" in nodeOrWidth ? nodeOrWidth.width : nodeOrWidth;
+  const viaLengthAcross = width / (VIA_DIAMETER / 2 + obstacleMargin);
+  return (viaLengthAcross / 2) ** 1.1 * maxCapacityFactor;
+};
+var calculateOptimalCapacityDepth = (initialWidth, targetMinCapacity = 0.5, maxDepth = 16) => {
+  let depth = 0;
+  let width = initialWidth;
+  while (depth < maxDepth) {
+    const capacity = getTunedTotalCapacity1({ width });
+    if (capacity <= targetMinCapacity) {
+      break;
+    }
+    width /= 2;
+    depth++;
+  }
+  return Math.max(1, depth);
+};
+
+// lib/solvers/CapacityPathingSolver/CapacityPathingSolver4_FlexibleNegativeCapacity_AvoidLowCapacity_FixedDistanceCost.ts
+var CapacityPathingSolver4_FlexibleNegativeCapacity = class extends CapacityPathingSolver {
+  NEGATIVE_CAPACITY_PENALTY_FACTOR = 1;
+  REDUCED_CAPACITY_PENALTY_FACTOR = 1;
+  get maxCapacityFactor() {
+    return this.hyperParameters.MAX_CAPACITY_FACTOR ?? 1;
+  }
+  /**
+   * In the FlexibleNegativeCapacity mode, we allow negative capacity
+   */
+  doesNodeHaveCapacityForTrace(node) {
+    return true;
+  }
+  getTotalCapacity(node) {
+    return getTunedTotalCapacity1(node, this.maxCapacityFactor);
+  }
+  /**
+   * Penalty you pay for using this node
+   */
+  getNodeCapacityPenalty(node) {
+    const totalCapacity = this.getTotalCapacity(node);
+    const usedCapacity = this.usedNodeCapacityMap.get(node.capacityMeshNodeId) ?? 0;
+    const remainingCapacity = totalCapacity - usedCapacity;
+    const dist = this.activeCandidateStraightLineDistance;
+    if (remainingCapacity <= 0) {
+      const penalty = (-remainingCapacity + 1) / totalCapacity * dist * (this.NEGATIVE_CAPACITY_PENALTY_FACTOR / 4);
+      return penalty ** 2;
+    }
+    return 1 / remainingCapacity * dist * this.REDUCED_CAPACITY_PENALTY_FACTOR / 8;
+  }
+  /**
+   * We're rewarding travel into big nodes.
+   *
+   * To minimize shortest path, you'd want to comment this out.
+   */
+  getDistanceBetweenNodes(A, B) {
+    const dx = A.center.x - B.center.x;
+    const dy = A.center.y - B.center.y;
+    const szx = Math.max(A.width, B.width);
+    const szy = Math.max(A.height, B.height);
+    const dist = Math.sqrt(dx ** 2 + dy ** 2) / (szx * szy);
+    return dist;
+  }
+  computeG(prevCandidate, node, endGoal) {
+    return prevCandidate.g + this.getDistanceBetweenNodes(prevCandidate.node, node) + this.getNodeCapacityPenalty(node);
+  }
+  computeH(prevCandidate, node, endGoal) {
+    return this.getDistanceBetweenNodes(node, endGoal) + this.getNodeCapacityPenalty(node);
+  }
+};
+
+// node_modules/circuit-json-to-connectivity-map/dist/index.js
+var ConnectivityMap = class {
+  netMap;
+  idToNetMap;
+  constructor(netMap) {
+    this.netMap = netMap;
+    this.idToNetMap = {};
+    for (const [netId, ids] of Object.entries(netMap)) {
+      for (const id of ids) {
+        this.idToNetMap[id] = netId;
+      }
+    }
+  }
+  addConnections(connections) {
+    for (const connection of connections) {
+      const existingNets = /* @__PURE__ */ new Set();
+      for (const id of connection) {
+        const existingNetId = this.idToNetMap[id];
+        if (existingNetId) {
+          existingNets.add(existingNetId);
+        }
+      }
+      let targetNetId;
+      if (existingNets.size === 0) {
+        targetNetId = `connectivity_net${Object.keys(this.netMap).length}`;
+        this.netMap[targetNetId] = [];
+      } else if (existingNets.size === 1) {
+        targetNetId = existingNets.values().next().value ?? `connectivity_net${Object.keys(this.netMap).length}`;
+      } else {
+        targetNetId = existingNets.values().next().value ?? `connectivity_net${Object.keys(this.netMap).length}`;
+        for (const netId of existingNets) {
+          if (netId !== targetNetId) {
+            this.netMap[targetNetId].push(...this.netMap[netId]);
+            this.netMap[netId] = this.netMap[targetNetId];
+            for (const id of this.netMap[targetNetId]) {
+              this.idToNetMap[id] = targetNetId;
+            }
+          }
+        }
+      }
+      for (const id of connection) {
+        if (!this.netMap[targetNetId].includes(id)) {
+          this.netMap[targetNetId].push(id);
+        }
+        this.idToNetMap[id] = targetNetId;
+      }
+    }
+  }
+  getIdsConnectedToNet(netId) {
+    return this.netMap[netId] || [];
+  }
+  getNetConnectedToId(id) {
+    return this.idToNetMap[id];
+  }
+  areIdsConnected(id1, id2) {
+    if (id1 === id2) return true;
+    const netId1 = this.getNetConnectedToId(id1);
+    if (!netId1) return false;
+    const netId2 = this.getNetConnectedToId(id2);
+    if (!netId2) return false;
+    return netId1 === netId2 || netId2 === id1 || netId2 === id1;
+  }
+  areAllIdsConnected(ids) {
+    const netId = this.getNetConnectedToId(ids[0]);
+    for (const id of ids) {
+      const nextNetId = this.getNetConnectedToId(id);
+      if (nextNetId === void 0) {
+        return false;
+      }
+      if (nextNetId !== netId) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// lib/utils/getConnectivityMapFromSimpleRouteJson.ts
+var getConnectivityMapFromSimpleRouteJson = (srj) => {
+  const connMap = new ConnectivityMap({});
+  for (const connection of srj.connections) {
+    for (const point of connection.pointsToConnect) {
+      if ("pcb_port_id" in point && point.pcb_port_id) {
+        connMap.addConnections([[connection.name, point.pcb_port_id]]);
+      }
+    }
+  }
+  return connMap;
+};
+
+// lib/solvers/CapacityMeshSolver/CapacityNodeTargetMerger.ts
+var CapacityNodeTargetMerger = class extends BaseSolver {
+  constructor(nodes, obstacles, connMap) {
+    super();
+    this.nodes = nodes;
+    this.connMap = connMap;
+    this.MAX_ITERATIONS = 1e5;
+    this.unprocessedObstacles = [...obstacles];
+    this.newNodes = [];
+    this.removedNodeIds = /* @__PURE__ */ new Set();
+  }
+  unprocessedObstacles;
+  newNodes;
+  removedNodeIds;
+  _step() {
+    const obstacle = this.unprocessedObstacles.pop();
+    if (!obstacle) {
+      for (const node of this.nodes) {
+        if (this.removedNodeIds.has(node.capacityMeshNodeId)) continue;
+        this.newNodes.push(node);
+      }
+      this.solved = true;
+      return;
+    }
+    const connectedNodes = this.nodes.filter((n) => {
+      if (!n._targetConnectionName) return false;
+      const implicitlyConnected = doRectsOverlap(n, obstacle);
+      return implicitlyConnected;
+    });
+    if (connectedNodes.length === 0) return;
+    const connectionName = connectedNodes[0]._targetConnectionName;
+    const bounds = {
+      minX: Infinity,
+      minY: Infinity,
+      maxX: -Infinity,
+      maxY: -Infinity
+    };
+    for (const node of connectedNodes) {
+      bounds.minX = Math.min(bounds.minX, node.center.x - node.width / 2);
+      bounds.minY = Math.min(bounds.minY, node.center.y - node.height / 2);
+      bounds.maxX = Math.max(bounds.maxX, node.center.x + node.width / 2);
+      bounds.maxY = Math.max(bounds.maxY, node.center.y + node.height / 2);
+    }
+    const newNode = {
+      capacityMeshNodeId: connectedNodes[0].capacityMeshNodeId,
+      center: {
+        x: (bounds.minX + bounds.maxX) / 2,
+        y: (bounds.minY + bounds.maxY) / 2
+      },
+      width: bounds.maxX - bounds.minX,
+      height: bounds.maxY - bounds.minY,
+      layer: connectedNodes[0].layer,
+      _completelyInsideObstacle: false,
+      _containsObstacle: true,
+      _containsTarget: true,
+      _targetConnectionName: connectionName,
+      _depth: connectedNodes[0]._depth,
+      _parent: connectedNodes[0]._parent
+    };
+    this.newNodes.push(newNode);
+    for (const node of connectedNodes) {
+      this.removedNodeIds.add(node.capacityMeshNodeId);
+    }
+  }
+  visualize() {
+    const graphics = {
+      rects: []
+    };
+    for (const node of this.newNodes) {
+      graphics.rects.push({
+        center: node.center,
+        width: Math.max(node.width - 2, node.width * 0.8),
+        height: Math.max(node.height - 2, node.height * 0.8),
+        fill: node._containsObstacle ? "rgba(255,0,0,0.1)" : "rgba(0,0,0,0.1)",
+        label: node.capacityMeshNodeId
+      });
+    }
+    return graphics;
+  }
+};
+
+// lib/utils/getIntraNodeCrossingsFromSegments.ts
+var getIntraNodeCrossingsFromSegments = (segments) => {
+  let numSameLayerCrossings = 0;
+  const pointPairs = [];
+  const transitionPairPoints = [];
+  let numEntryExitLayerChanges = 0;
+  const portPoints = segments.flatMap((seg) => seg.assignedPoints);
+  for (const { connectionName: aConnName, point: A } of portPoints) {
+    if (pointPairs.some((p) => p.connectionName === aConnName)) {
+      continue;
+    }
+    if (transitionPairPoints.some((p) => p.connectionName === aConnName)) {
+      continue;
+    }
+    const pointPair = {
+      connectionName: aConnName,
+      z: A.z,
+      points: [A]
+    };
+    for (const { connectionName: bConnName, point: B } of portPoints) {
+      if (aConnName !== bConnName) continue;
+      if (A === B) continue;
+      pointPair.points.push(B);
+    }
+    if (pointPair.points.some((p) => p.z !== pointPair.z)) {
+      numEntryExitLayerChanges++;
+      transitionPairPoints.push(pointPair);
+      continue;
+    }
+    pointPairs.push(pointPair);
+  }
+  for (let i = 0; i < pointPairs.length; i++) {
+    for (let j = i + 1; j < pointPairs.length; j++) {
+      const pair1 = pointPairs[i];
+      const pair2 = pointPairs[j];
+      if (pair1.z === pair2.z && doSegmentsIntersect(
+        pair1.points[0],
+        pair1.points[1],
+        pair2.points[0],
+        pair2.points[1]
+      )) {
+        numSameLayerCrossings++;
+      }
+    }
+  }
+  let numTransitionCrossings = 0;
+  for (let i = 0; i < transitionPairPoints.length; i++) {
+    for (let j = i + 1; j < transitionPairPoints.length; j++) {
+      const pair1 = transitionPairPoints[i];
+      const pair2 = transitionPairPoints[j];
+      if (doSegmentsIntersect(
+        pair1.points[0],
+        pair1.points[1],
+        pair2.points[0],
+        pair2.points[1]
+      )) {
+        numTransitionCrossings++;
+      }
+    }
+  }
+  for (let i = 0; i < transitionPairPoints.length; i++) {
+    for (let j = 0; j < pointPairs.length; j++) {
+      const pair1 = transitionPairPoints[i];
+      const pair2 = pointPairs[j];
+      if (doSegmentsIntersect(
+        pair1.points[0],
+        pair1.points[1],
+        pair2.points[0],
+        pair2.points[1]
+      )) {
+        numTransitionCrossings++;
+      }
+    }
+  }
+  return {
+    numSameLayerCrossings,
+    numEntryExitLayerChanges,
+    numTransitionCrossings
+  };
+};
+
+// lib/solvers/CapacitySegmentPointOptimizer/CapacitySegmentPointOptimizer.ts
+var CapacitySegmentPointOptimizer = class extends BaseSolver {
+  assignedSegments;
+  colorMap;
+  nodeMap;
+  nodeIdToSegmentIds;
+  segmentIdToNodeIds;
+  currentMutatedSegments;
+  allSegmentIds;
+  lastAppliedOperation = null;
+  lastCreatedOperation = null;
+  currentNodeCosts;
+  lastAcceptedIteration = 0;
+  currentCost;
+  randomSeed;
+  numNodes;
+  probabilityOfFailure;
+  nodesThatCantFitVias;
+  mutableSegments;
+  VIA_DIAMETER = 0.6;
+  OBSTACLE_MARGIN = 0.15;
+  MAX_OPERATIONS_PER_MUTATION = 5;
+  MAX_NODE_CHAIN_PER_MUTATION = 2;
+  NOOP_ITERATIONS_BEFORE_EARLY_STOP = 2e4;
+  // We use an extra property on segments to remember assigned points.
+  // Each segment will get an added property "assignedPoints" which is an array of:
+  // { connectionName: string, point: {x: number, y: number } }
+  // This is a temporary extension used by the solver.
+  constructor({
+    assignedSegments,
+    colorMap,
+    nodes
+  }) {
+    super();
+    this.MAX_ITERATIONS = 5e5;
+    this.assignedSegments = assignedSegments;
+    const dedupedSegments = [];
+    const dedupedSegPointMap = /* @__PURE__ */ new Map();
+    let highestSegmentId = -1;
+    for (const seg of this.assignedSegments) {
+      const segKey = `${seg.start.x}-${seg.start.y}-${seg.end.x}-${seg.end.y}`;
+      const existingSeg = dedupedSegPointMap.get(segKey);
+      if (!existingSeg) {
+        highestSegmentId++;
+        seg.nodePortSegmentId = `SEG${highestSegmentId}`;
+        dedupedSegPointMap.set(segKey, seg);
+        dedupedSegments.push(seg);
+        continue;
+      }
+      seg.nodePortSegmentId = existingSeg.nodePortSegmentId;
+    }
+    this.currentMutatedSegments = /* @__PURE__ */ new Map();
+    for (const seg of dedupedSegments) {
+      this.currentMutatedSegments.set(seg.nodePortSegmentId, {
+        ...seg,
+        assignedPoints: seg.assignedPoints?.map((p) => ({
+          ...p,
+          point: { x: p.point.x, y: p.point.y, z: p.point.z }
+        }))
+      });
+    }
+    this.nodeIdToSegmentIds = /* @__PURE__ */ new Map();
+    this.segmentIdToNodeIds = /* @__PURE__ */ new Map();
+    for (const segment of this.assignedSegments) {
+      this.segmentIdToNodeIds.set(segment.nodePortSegmentId, [
+        ...this.segmentIdToNodeIds.get(segment.nodePortSegmentId) ?? [],
+        segment.capacityMeshNodeId
+      ]);
+      this.nodeIdToSegmentIds.set(segment.capacityMeshNodeId, [
+        ...this.nodeIdToSegmentIds.get(segment.capacityMeshNodeId) ?? [],
+        segment.nodePortSegmentId
+      ]);
+    }
+    this.colorMap = colorMap ?? {};
+    this.nodeMap = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      this.nodeMap.set(node.capacityMeshNodeId, node);
+    }
+    this.numNodes = this.segmentIdToNodeIds.size;
+    const { cost, nodeCosts, probabilityOfFailure } = this.computeCurrentCost();
+    this.currentCost = cost;
+    this.currentNodeCosts = nodeCosts;
+    this.probabilityOfFailure = probabilityOfFailure;
+    this.randomSeed = 1;
+    this.allSegmentIds = Array.from(this.currentMutatedSegments.keys());
+    this.nodesThatCantFitVias = /* @__PURE__ */ new Set();
+    for (const nodeId of this.nodeIdToSegmentIds.keys()) {
+      const node = this.nodeMap.get(nodeId);
+      if (node.width < this.VIA_DIAMETER + this.OBSTACLE_MARGIN) {
+        this.nodesThatCantFitVias.add(nodeId);
+      }
+    }
+    this.mutableSegments = this.getMutableSegments();
+  }
+  random() {
+    this.randomSeed = this.randomSeed * 16807 % 2147483647;
+    return (this.randomSeed - 1) / 2147483646;
+  }
+  /**
+   * The cost is the "probability of failure" of the node.
+   */
+  computeNodeCost(nodeId) {
+    const node = this.nodeMap.get(nodeId);
+    if (node?._containsTarget) return 0;
+    const totalCapacity = getTunedTotalCapacity1(node);
+    const usedViaCapacity = this.getUsedViaCapacity(nodeId);
+    const usedTraceCapacity = this.getUsedTraceCapacity(nodeId);
+    const approxProb = usedViaCapacity * usedTraceCapacity / totalCapacity ** 2;
+    const K = -2.3;
+    return 1 - Math.exp(approxProb * K);
+  }
+  /**
+   * Number of traces that can go through this node if they are completely
+   * straight without crossings
+   */
+  getUsedTraceCapacity(nodeId) {
+    const segmentIds = this.nodeIdToSegmentIds.get(nodeId);
+    const segments = segmentIds.map(
+      (segmentId) => this.currentMutatedSegments.get(segmentId)
+    );
+    const points = segments.flatMap((s) => s.assignedPoints);
+    const numTracesThroughNode = points.length / 2;
+    const numLayers = 2;
+    return numTracesThroughNode / numLayers;
+  }
+  /**
+   * Granular via capacity is a consideration of capacity that includes...
+   * - The number of traces
+   * - The number of trace crossings (0-2 vias per trace crossing)
+   *   - Empirically, each crossing typically results in 0.82 vias
+   *   - e.g. 17 traces would typically have 51 crossings & 42 vias
+   * - The number of layer changes (at least 1 via per layer change)
+   *   - We don't know how a entry/exit being on separated layers effects
+   *     the capacity/number of vias yet
+   *
+   * - Generally minimizing the number of crossings is pretty good, if there
+   *   is no trace crossing you basically don't have any used capacity
+   * - If the entry/exit layer is different, you're guaranteed to have at least
+   *   one via
+   *
+   * - Total capacity is computed by estimating the number of vias that could
+   *   be created using the formula (viaFitAcross / 2) ** 1.1
+   */
+  getUsedViaCapacity(nodeId) {
+    const segmentIds = this.nodeIdToSegmentIds.get(nodeId);
+    const segments = segmentIds.map(
+      (segmentId) => this.currentMutatedSegments.get(segmentId)
+    );
+    const points = segments.flatMap((s) => s.assignedPoints);
+    if (points.length <= 2) {
+      if (points.length <= 1) return 0;
+      return 0;
+    }
+    const {
+      numEntryExitLayerChanges,
+      numSameLayerCrossings,
+      numTransitionCrossings
+    } = getIntraNodeCrossingsFromSegments(segments);
+    const estNumVias = numSameLayerCrossings * 0.82 + numEntryExitLayerChanges * 0.41 + numTransitionCrossings * 0.2;
+    const estUsedCapacity = (estNumVias / 2) ** 1.1;
+    return estUsedCapacity;
+  }
+  getRandomWeightedNodeId() {
+    const nodeIdsWithCosts = [...this.currentNodeCosts.entries()].filter(([nodeId, cost]) => cost > 1e-5).filter(([nodeId]) => !this.nodeMap.get(nodeId)?._containsTarget);
+    if (nodeIdsWithCosts.length === 0) {
+      console.error(
+        "No nodes with cost > 0.00001 (why are you even running this solver)"
+      );
+      return this.currentNodeCosts.keys().next().value;
+    }
+    const totalCost = nodeIdsWithCosts.reduce((acc, [, cost]) => acc + cost, 0);
+    const randomValue = this.random() * totalCost;
+    let cumulativeCost = 0;
+    for (let i = 0; i < nodeIdsWithCosts.length; i++) {
+      const [nodeId, cost] = nodeIdsWithCosts[i];
+      cumulativeCost += cost;
+      if (cumulativeCost >= randomValue) {
+        return nodeId;
+      }
+    }
+    throw new Error("RANDOM SELECTION FAILURE FOR NODES (this is a bug)");
+  }
+  getRandomWeightedSegmentId() {
+    const nodeId = this.getRandomWeightedNodeId();
+    const segmentsIds = this.nodeIdToSegmentIds.get(nodeId).filter((s) => this.isSegmentMutable(s));
+    return segmentsIds[Math.floor(this.random() * segmentsIds.length)];
+  }
+  getMutableSegments() {
+    const mutableSegments = /* @__PURE__ */ new Set();
+    for (const segmentId of this.currentMutatedSegments.keys()) {
+      const segment = this.currentMutatedSegments.get(segmentId);
+      const nodes = this.segmentIdToNodeIds.get(segmentId);
+      const isMutable = nodes.every(
+        (nodeId) => !this.nodeMap.get(nodeId)?._containsTarget
+      );
+      if (isMutable) {
+        mutableSegments.add(segmentId);
+      }
+    }
+    return mutableSegments;
+  }
+  isSegmentMutable(segmentId) {
+    return this.mutableSegments.has(segmentId);
+  }
+  getRandomOperationForSegment(randomSegmentId) {
+    const segment = this.currentMutatedSegments.get(randomSegmentId);
+    let operationType = this.random() < 0.5 ? "switch" : "changeLayer";
+    if (segment.assignedPoints.length <= 1) {
+      operationType = "changeLayer";
+    }
+    if (operationType === "switch") {
+      const randomPointIndex1 = Math.floor(
+        this.random() * segment.assignedPoints.length
+      );
+      let randomPointIndex2 = randomPointIndex1;
+      while (randomPointIndex1 === randomPointIndex2) {
+        randomPointIndex2 = Math.floor(
+          this.random() * segment.assignedPoints.length
+        );
+      }
+      return {
+        op: "switch",
+        segmentId: randomSegmentId,
+        point1Index: randomPointIndex1,
+        point2Index: randomPointIndex2
+      };
+    }
+    const nodeIds = this.segmentIdToNodeIds.get(segment.nodePortSegmentId);
+    if (nodeIds?.some((nodeId) => this.nodesThatCantFitVias.has(nodeId))) {
+      return null;
+    }
+    const randomPointIndex = Math.floor(
+      this.random() * segment.assignedPoints.length
+    );
+    const point = segment.assignedPoints[randomPointIndex];
+    return {
+      op: "changeLayer",
+      segmentId: randomSegmentId,
+      pointIndex: randomPointIndex,
+      newLayer: point.point.y > 0 ? 0 : 1
+    };
+  }
+  getNodesNearNode(nodeId, hops = 1) {
+    if (hops === 0) return [nodeId];
+    const segments = this.nodeIdToSegmentIds.get(nodeId);
+    const nodes = /* @__PURE__ */ new Set();
+    for (const segmentId of segments) {
+      const adjacentNodeIds = this.segmentIdToNodeIds.get(segmentId);
+      for (const adjacentNodeId of adjacentNodeIds) {
+        const ancestors = this.getNodesNearNode(adjacentNodeId, hops - 1);
+        for (const ancestor of ancestors) {
+          nodes.add(ancestor);
+        }
+      }
+    }
+    return Array.from(nodes);
+  }
+  getRandomCombinedOperationNearNode(nodeId) {
+    const adjacentNodeIds = this.getNodesNearNode(
+      nodeId,
+      this.MAX_NODE_CHAIN_PER_MUTATION
+    );
+    const subOperations = [];
+    const adjacentSegments = adjacentNodeIds.flatMap((nodeId2) => this.nodeIdToSegmentIds.get(nodeId2)).filter((s) => this.isSegmentMutable(s));
+    const numOperations = Math.floor(this.random() * this.MAX_OPERATIONS_PER_MUTATION) + 1;
+    for (let i = 0; i < numOperations; i++) {
+      const randomSegmentId = adjacentSegments[Math.floor(this.random() * adjacentSegments.length)];
+      const newOp = this.getRandomOperationForSegment(randomSegmentId);
+      if (newOp) {
+        subOperations.push(newOp);
+      }
+    }
+    return {
+      op: "combined",
+      subOperations
+    };
+  }
+  /**
+   * A combined operation can perform multiple operations on a single node, this
+   * allows it to reach outcomes that may not be beneficial with since
+   * operations
+   */
+  getRandomCombinedOperationOnSingleNode(max = 7) {
+    const numSubOperations = max === 1 ? 1 : Math.floor(this.random() * max) + 1;
+    const subOperations = [];
+    const nodeId = this.getRandomWeightedNodeId();
+    const segmentsIds = this.nodeIdToSegmentIds.get(nodeId).filter((s) => this.isSegmentMutable(s));
+    for (let i = 0; i < numSubOperations; i++) {
+      const randomSegmentId = segmentsIds[Math.floor(this.random() * segmentsIds.length)];
+      const newOp = this.getRandomOperationForSegment(randomSegmentId);
+      if (newOp) {
+        subOperations.push(newOp);
+      }
+    }
+    return {
+      op: "combined",
+      subOperations
+    };
+  }
+  getRandomOperation() {
+    const randomSegmentId = this.getRandomWeightedSegmentId();
+    const newOp = this.getRandomOperationForSegment(randomSegmentId);
+    if (newOp) {
+      return newOp;
+    }
+    return this.getRandomOperation();
+  }
+  /**
+   * We compute "overall probability of failure" as our overall cost, then
+   * linearize it to make it easier to work with
+   */
+  computeCurrentCost() {
+    let logProbabilityOfSuccess = 0;
+    let costSum = 0;
+    const nodeCosts = /* @__PURE__ */ new Map();
+    for (const nodeId of this.nodeIdToSegmentIds.keys()) {
+      const nodeProbOfFailure = this.computeNodeCost(nodeId);
+      nodeCosts.set(nodeId, nodeProbOfFailure);
+      costSum += nodeProbOfFailure;
+      if (nodeProbOfFailure < 1) {
+        logProbabilityOfSuccess += Math.log(1 - nodeProbOfFailure);
+      } else {
+        logProbabilityOfSuccess = -Infinity;
+      }
+    }
+    const probabilityOfSuccess = Math.exp(logProbabilityOfSuccess);
+    const probabilityOfFailure = 1 - probabilityOfSuccess;
+    const numNodes = this.nodeIdToSegmentIds.size;
+    const linearizedCost = numNodes > 0 ? -logProbabilityOfSuccess / numNodes : 0;
+    return {
+      cost: linearizedCost,
+      // Replace cost with linearized version
+      nodeCosts,
+      probabilityOfFailure,
+      linearizedCost
+      // Also return as separate value if you need original cost sum
+    };
+  }
+  applyOperation(op) {
+    if (op.op === "combined") {
+      for (const subOp of op.subOperations) {
+        this.applyOperation(subOp);
+      }
+      return;
+    }
+    const segment = this.currentMutatedSegments.get(op.segmentId);
+    if (!segment || !segment.assignedPoints) return;
+    if (op.op === "changeLayer") {
+      op.oldLayer = segment.assignedPoints[op.pointIndex].point.z;
+      segment.assignedPoints[op.pointIndex].point.z = op.newLayer;
+    } else if (op.op === "switch") {
+      const point1 = segment.assignedPoints[op.point1Index].point;
+      const point2 = segment.assignedPoints[op.point2Index].point;
+      const tempX = point1.x;
+      const tempY = point1.y;
+      const tempZ = point1.z;
+      point1.x = point2.x;
+      point1.y = point2.y;
+      point1.z = point2.z;
+      point2.x = tempX;
+      point2.y = tempY;
+      point2.z = tempZ;
+    }
+  }
+  reverseOperation(op) {
+    if (op.op === "combined") {
+      for (const subOp of [...op.subOperations].reverse()) {
+        this.reverseOperation(subOp);
+      }
+      return;
+    }
+    const segment = this.currentMutatedSegments.get(op.segmentId);
+    if (!segment || !segment.assignedPoints) return;
+    if (op.op === "changeLayer") {
+      const oldLayer = op.oldLayer;
+      if (oldLayer === void 0) return;
+      segment.assignedPoints[op.pointIndex].point.z = oldLayer;
+    } else if (op.op === "switch") {
+      const point1 = segment.assignedPoints[op.point1Index].point;
+      const point2 = segment.assignedPoints[op.point2Index].point;
+      const tempX = point1.x;
+      const tempY = point1.y;
+      const tempZ = point1.z;
+      point1.x = point2.x;
+      point1.y = point2.y;
+      point1.z = point2.z;
+      point2.x = tempX;
+      point2.y = tempY;
+      point2.z = tempZ;
+    }
+  }
+  isNewCostAcceptable(oldPf, newPf) {
+    if (newPf < oldPf) return true;
+    return false;
+  }
+  /**
+   * FOR OUTPUT: Return the assigned points for each segment.
+   */
+  getNodesWithPortPoints() {
+    if (!this.solved) {
+      throw new Error(
+        "CapacitySegmentToPointSolver not solved, can't give port points yet"
+      );
+    }
+    const map = /* @__PURE__ */ new Map();
+    for (const segId of this.allSegmentIds) {
+      for (const nodeId of this.segmentIdToNodeIds.get(segId)) {
+        const node = this.nodeMap.get(nodeId);
+        if (!map.has(nodeId)) {
+          map.set(nodeId, {
+            capacityMeshNodeId: nodeId,
+            portPoints: [],
+            center: node.center,
+            width: node.width,
+            height: node.height
+          });
+        }
+        map.get(nodeId).portPoints.push(
+          ...this.currentMutatedSegments.get(segId).assignedPoints.map((ap) => ({
+            ...ap.point,
+            connectionName: ap.connectionName
+          }))
+        );
+      }
+    }
+    return Array.from(map.values());
+  }
+  _step() {
+    if (this.iterations === this.MAX_ITERATIONS - 1) {
+      this.solved = true;
+      return;
+    }
+    if (this.currentCost < 1e-3) {
+      this.solved = true;
+      return;
+    }
+    const op = this.getRandomCombinedOperationNearNode(
+      this.getRandomWeightedNodeId()
+    );
+    this.lastCreatedOperation = op;
+    this.applyOperation(op);
+    const {
+      cost: newCost,
+      nodeCosts: newNodeCosts,
+      probabilityOfFailure: newProbabilityOfFailure
+    } = this.computeCurrentCost();
+    op.cost = newCost;
+    const keepChange = this.isNewCostAcceptable(this.currentCost, newCost);
+    if (!keepChange) {
+      this.reverseOperation(op);
+      if (this.iterations - this.lastAcceptedIteration > this.NOOP_ITERATIONS_BEFORE_EARLY_STOP) {
+        this.solved = true;
+      }
+      return;
+    }
+    this.lastAcceptedIteration = this.iterations;
+    this.currentCost = newCost;
+    this.currentNodeCosts = newNodeCosts;
+    this.lastAppliedOperation = op;
+    this.probabilityOfFailure = newProbabilityOfFailure;
+  }
+  visualize() {
+    const immutableSegments = new Set(
+      [...this.currentMutatedSegments.values()].filter(
+        (seg) => !this.isSegmentMutable(seg.nodePortSegmentId)
+      )
+    );
+    const graphics = {
+      points: [...this.currentMutatedSegments.values()].flatMap(
+        (seg, i) => seg.assignedPoints.map((ap) => ({
+          x: ap.point.x,
+          y: ap.point.y,
+          label: `${seg.nodePortSegmentId}
+layer: ${ap.point.z}
+${ap.connectionName}
+${immutableSegments.has(seg) ? "(IMMUTABLE)" : ""}`,
+          color: this.colorMap[ap.connectionName]
+        }))
+      ),
+      lines: [...this.currentMutatedSegments.values()].map((seg) => ({
+        points: [seg.start, seg.end]
+      })),
+      rects: [
+        ...[...this.nodeMap.values()].map((node) => {
+          const segmentIds = this.nodeIdToSegmentIds.get(
+            node.capacityMeshNodeId
+          );
+          if (!segmentIds) return null;
+          const segments = segmentIds.map(
+            (segmentId) => this.currentMutatedSegments.get(segmentId)
+          );
+          let label;
+          if (node._containsTarget) {
+            label = `${node.capacityMeshNodeId}
+${node.width.toFixed(2)}x${node.height.toFixed(2)}`;
+          } else {
+            const intraNodeCrossings = getIntraNodeCrossingsFromSegments(segments);
+            label = `${node.capacityMeshNodeId}
+${this.computeNodeCost(node.capacityMeshNodeId).toFixed(2)}/${getTunedTotalCapacity1(node).toFixed(2)}
+Trace Capacity: ${this.getUsedTraceCapacity(node.capacityMeshNodeId).toFixed(2)}
+X'ings: ${intraNodeCrossings.numSameLayerCrossings}
+Ent/Ex LC: ${intraNodeCrossings.numEntryExitLayerChanges}
+T X'ings: ${intraNodeCrossings.numTransitionCrossings}
+${node.width.toFixed(2)}x${node.height.toFixed(2)}`;
+          }
+          return {
+            center: node.center,
+            label,
+            color: "red",
+            width: node.width / 8,
+            height: node.height / 8
+          };
+        }).filter((r) => r !== null)
+      ],
+      circles: [],
+      coordinateSystem: "cartesian",
+      title: "Capacity Segment Point Optimizer"
+    };
+    const dashedLines = [];
+    const nodeConnections = {};
+    for (const seg of this.currentMutatedSegments.values()) {
+      const nodeIds = this.segmentIdToNodeIds.get(seg.nodePortSegmentId);
+      for (const nodeId of nodeIds) {
+        if (!nodeConnections[nodeId]) {
+          nodeConnections[nodeId] = {};
+        }
+        for (const ap of seg.assignedPoints) {
+          if (!nodeConnections[nodeId][ap.connectionName]) {
+            nodeConnections[nodeId][ap.connectionName] = [];
+          }
+          nodeConnections[nodeId][ap.connectionName].push(ap.point);
+        }
+      }
+    }
+    for (const nodeId in nodeConnections) {
+      for (const conn in nodeConnections[nodeId]) {
+        const points = nodeConnections[nodeId][conn];
+        if (points.length <= 1) continue;
+        const sameLayer = points[0].z === points[1].z;
+        const commonLayer = points[0].z;
+        const type = sameLayer ? commonLayer === 0 ? "top" : "bottom" : "transition";
+        dashedLines.push({
+          points,
+          strokeDash: type === "top" ? void 0 : type === "bottom" ? "10 5" : "3 3 10",
+          strokeColor: this.colorMap[conn] || "#000"
+        });
+      }
+    }
+    graphics.lines.push(...dashedLines);
+    const operationsToShow = [];
+    if (this.lastCreatedOperation?.op === "combined") {
+      operationsToShow.push(...this.lastCreatedOperation.subOperations);
+    } else if (this.lastCreatedOperation) {
+      operationsToShow.push(this.lastCreatedOperation);
+    }
+    for (const op of operationsToShow) {
+      const segment = this.currentMutatedSegments.get(op.segmentId);
+      const node = this.nodeMap.get(segment.capacityMeshNodeId);
+      graphics.circles.push({
+        center: { x: node.center.x, y: node.center.y },
+        radius: node.width / 4,
+        stroke: "#0000ff",
+        fill: "rgba(0, 0, 255, 0.2)",
+        label: `LAST OPERATION: ${op.op}
+Cost: ${op.cost?.toString()}
+${node.capacityMeshNodeId}
+${this.currentNodeCosts.get(node.capacityMeshNodeId)}/${getTunedTotalCapacity1(node)}
+${node.width.toFixed(2)}x${node.height.toFixed(2)}`
+      });
+      if (op.op === "changeLayer") {
+        const point = segment.assignedPoints[op.pointIndex];
+        graphics.circles.push({
+          center: { x: point.point.x, y: point.point.y },
+          radius: this.nodeMap.get(segment.capacityMeshNodeId).width / 8,
+          stroke: "#ff0000",
+          fill: "rgba(255, 0, 0, 0.2)",
+          label: `Layer Changed
+oldLayer: ${op.oldLayer}
+newLayer: ${op.newLayer}`
+        });
+      } else if (op.op === "switch") {
+        const point1 = segment.assignedPoints[op.point1Index];
+        const point2 = segment.assignedPoints[op.point2Index];
+        graphics.circles.push(
+          {
+            center: { x: point1.point.x, y: point1.point.y },
+            radius: node.width / 16,
+            stroke: "#00ff00",
+            fill: "rgba(0, 255, 0, 0.2)",
+            label: `Swapped 1
+${segment.nodePortSegmentId}`
+          },
+          {
+            center: { x: point2.point.x, y: point2.point.y },
+            radius: node.width / 16,
+            stroke: "#00ff00",
+            fill: "rgba(0, 255, 0, 0.2)",
+            label: `Swapped 2
+${segment.nodePortSegmentId}`
+          }
+        );
+        graphics.lines.push({
+          points: [
+            { x: point1.point.x, y: point1.point.y },
+            { x: point2.point.x, y: point2.point.y }
+          ],
+          strokeColor: "#00ff00",
+          strokeDash: "3 3",
+          strokeWidth: node.width / 32
+        });
+      }
+    }
+    return graphics;
+  }
+};
+
+// lib/solvers/CapacityMeshSolver/CapacityMeshSolver.ts
+var CapacityMeshSolver = class extends BaseSolver {
+  constructor(srj, opts = {}) {
+    super();
+    this.srj = srj;
+    this.opts = opts;
+    this.MAX_ITERATIONS = 1e6;
+    if (opts.capacityDepth === void 0) {
+      const boundsWidth = srj.bounds.maxX - srj.bounds.minX;
+      const boundsHeight = srj.bounds.maxY - srj.bounds.minY;
+      const maxWidthHeight = Math.max(boundsWidth, boundsHeight);
+      const targetMinCapacity = opts.targetMinCapacity ?? 0.5;
+      opts.capacityDepth = calculateOptimalCapacityDepth(
+        maxWidthHeight,
+        targetMinCapacity
+      );
+    }
+    this.nodeSolver = new CapacityMeshNodeSolver(srj, this.opts);
+    this.connMap = getConnectivityMapFromSimpleRouteJson(srj);
+    this.colorMap = getColorMap(srj, this.connMap);
+  }
+  nodeSolver;
+  nodeTargetMerger;
+  edgeSolver;
+  pathingSolver;
+  edgeToPortSegmentSolver;
+  colorMap;
+  segmentToPointSolver;
+  segmentToPointOptimizer;
+  highDensityRouteSolver;
+  activeSolver = null;
+  connMap;
+  _step() {
+    if (this.activeSolver) {
+      this.activeSolver.step();
+      if (this.activeSolver.solved) {
+        this.activeSolver = null;
+      } else if (this.activeSolver.failed) {
+        this.error = this.activeSolver?.error;
+        this.failed = true;
+        this.activeSolver = null;
+      }
+      return;
+    }
+    if (!this.nodeSolver.solved) {
+      this.activeSolver = this.nodeSolver;
+      return;
+    }
+    if (!this.nodeTargetMerger) {
+      this.nodeTargetMerger = new CapacityNodeTargetMerger(
+        this.nodeSolver.finishedNodes,
+        this.srj.obstacles,
+        this.connMap
+      );
+      this.activeSolver = this.nodeTargetMerger;
+      return;
+    }
+    const nodes = this.nodeTargetMerger.newNodes;
+    if (!this.edgeSolver) {
+      this.edgeSolver = new CapacityMeshEdgeSolver(nodes);
+      this.activeSolver = this.edgeSolver;
+      return;
+    }
+    if (!this.pathingSolver) {
+      this.pathingSolver = new CapacityPathingSolver4_FlexibleNegativeCapacity({
+        simpleRouteJson: this.srj,
+        nodes,
+        edges: this.edgeSolver.edges,
+        colorMap: this.colorMap,
+        hyperParameters: {
+          MAX_CAPACITY_FACTOR: 1
+        }
+      });
+      this.activeSolver = this.pathingSolver;
+      return;
+    }
+    if (!this.edgeToPortSegmentSolver) {
+      this.edgeToPortSegmentSolver = new CapacityEdgeToPortSegmentSolver({
+        nodes,
+        edges: this.edgeSolver.edges,
+        capacityPaths: this.pathingSolver.getCapacityPaths(),
+        colorMap: this.colorMap
+      });
+      this.activeSolver = this.edgeToPortSegmentSolver;
+      return;
+    }
+    if (!this.segmentToPointSolver) {
+      const allSegments = [];
+      this.edgeToPortSegmentSolver.nodePortSegments.forEach((segs) => {
+        allSegments.push(...segs);
+      });
+      this.segmentToPointSolver = new CapacitySegmentToPointSolver({
+        segments: allSegments,
+        colorMap: this.colorMap,
+        nodes
+      });
+      this.activeSolver = this.segmentToPointSolver;
+      return;
+    }
+    if (!this.segmentToPointOptimizer) {
+      this.segmentToPointOptimizer = new CapacitySegmentPointOptimizer({
+        assignedSegments: this.segmentToPointSolver.solvedSegments,
+        colorMap: this.colorMap,
+        nodes
+      });
+      this.activeSolver = this.segmentToPointOptimizer;
+      return;
+    }
+    if (!this.highDensityRouteSolver) {
+      const nodesWithPortPoints = this.segmentToPointOptimizer.getNodesWithPortPoints();
+      this.highDensityRouteSolver = new HighDensityRouteSolver({
+        nodePortPoints: nodesWithPortPoints,
+        colorMap: this.colorMap,
+        connMap: this.connMap
+      });
+      this.activeSolver = this.highDensityRouteSolver;
+      return;
+    }
+    this.solved = true;
+  }
+  visualize() {
+    if (!this.solved && this.activeSolver) return this.activeSolver.visualize();
+    const nodeViz = this.nodeSolver.visualize();
+    const edgeViz = this.edgeSolver?.visualize();
+    const pathingViz = this.pathingSolver?.visualize();
+    const edgeToPortSegmentViz = this.edgeToPortSegmentSolver?.visualize();
+    const segmentToPointViz = this.segmentToPointSolver?.visualize();
+    const segmentOptimizationViz = this.segmentToPointOptimizer?.visualize();
+    const highDensityViz = this.highDensityRouteSolver?.visualize();
+    const problemViz = {
+      points: [...nodeViz.points],
+      rects: [...nodeViz.rects?.filter((r) => r.label?.includes("obstacle"))]
+    };
+    const visualizations = [
+      problemViz,
+      nodeViz,
+      edgeViz,
+      pathingViz,
+      edgeToPortSegmentViz,
+      segmentToPointViz,
+      segmentOptimizationViz,
+      highDensityViz ? combineVisualizations(problemViz, highDensityViz) : null
+    ].filter(Boolean);
+    return combineVisualizations(...visualizations);
+  }
+  /**
+   * Simplifies a route by merging consecutive points along the same line
+   */
+  simplifyRoute(points) {
+    if (points.length <= 2) return points;
+    const result = [points[0]];
+    for (let i = 1; i < points.length - 1; i++) {
+      const prev = points[i - 1];
+      const curr = points[i];
+      const next = points[i + 1];
+      if (curr.z === prev.z && curr.z === next.z) {
+        const dx1 = curr.x - prev.x;
+        const dy1 = curr.y - prev.y;
+        const dx2 = next.x - curr.x;
+        const dy2 = next.y - curr.y;
+        const crossProduct = dx1 * dy2 - dy1 * dx2;
+        const dotProduct = dx1 * dx2 + dy1 * dy2;
+        if (Math.abs(crossProduct) < 1e-3 && dotProduct > 0) {
+          continue;
+        }
+      }
+      result.push(curr);
+    }
+    result.push(points[points.length - 1]);
+    return result;
+  }
+  /**
+   * Returns the SimpleRouteJson with routes converted to SimplifiedPcbTraces
+   */
+  getOutputSimpleRouteJson() {
+    if (!this.solved || !this.highDensityRouteSolver) {
+      throw new Error("Cannot get output before solving is complete");
+    }
+    const traces = [];
+    for (const route of this.highDensityRouteSolver.routes) {
+      const simplifiedRoute = this.simplifyRoute(route.route);
+      const trace = {
+        type: "pcb_trace",
+        pcb_trace_id: route.connectionName,
+        route: []
+      };
+      let currentLayer = simplifiedRoute[0]?.z.toString() || "0";
+      for (let i = 0; i < simplifiedRoute.length; i++) {
+        const point = simplifiedRoute[i];
+        const nextLayerStr = point.z.toString();
+        if (nextLayerStr !== currentLayer) {
+          trace.route.push({
+            route_type: "via",
+            x: point.x,
+            y: point.y,
+            from_layer: currentLayer,
+            to_layer: nextLayerStr
+          });
+          currentLayer = nextLayerStr;
+        }
+        trace.route.push({
+          route_type: "wire",
+          x: point.x,
+          y: point.y,
+          width: route.traceThickness || this.highDensityRouteSolver.defaultTraceThickness,
+          layer: currentLayer
+        });
+      }
+      traces.push(trace);
+    }
+    return {
+      ...this.srj,
+      traces
+    };
+  }
+};
+export {
+  CapacityMeshSolver,
+  calculateOptimalCapacityDepth,
+  getTunedTotalCapacity1
+};
+//# sourceMappingURL=index.js.map