@tscircuit/hypergraph 0.0.1

package/dist/index.js

@@ -0,0 +1,2318 @@
+// lib/JumperGraphSolver/geometry/getBoundsCenter.ts
+var computeBoundsCenter = (bounds) => {
+  return {
+    x: (bounds.minX + bounds.maxX) / 2,
+    y: (bounds.minY + bounds.maxY) / 2
+  };
+};
+
+// lib/JumperGraphSolver/jumper-graph-generator/generateSingleJumperX4Regions.ts
+var dims1206x4 = {
+  padWidth: 0.8,
+  // X direction (horizontal)
+  padHeight: 0.5,
+  // Y direction (vertical)
+  leftPadCenterX: -1.35,
+  // X position of left pads (P1, P2, P3, P4)
+  rightPadCenterX: 1.35,
+  // X position of right pads (P5, P6, P7, P8)
+  row1CenterY: 1.905,
+  // Y position of row 1 (P1, P8)
+  row2CenterY: 0.635,
+  // Y position of row 2 (P2, P7)
+  row3CenterY: -0.635,
+  // Y position of row 3 (P3, P6)
+  row4CenterY: -1.905
+  // Y position of row 4 (P4, P5)
+};
+
+// lib/JumperGraphSolver/jumper-graph-generator/calculateGraphBounds.ts
+var calculateGraphBounds = (regions) => {
+  let minX = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  for (const region of regions) {
+    const { bounds } = region.d;
+    minX = Math.min(minX, bounds.minX);
+    maxX = Math.max(maxX, bounds.maxX);
+    minY = Math.min(minY, bounds.minY);
+    maxY = Math.max(maxY, bounds.maxY);
+  }
+  return { minX, maxX, minY, maxY };
+};
+
+// node_modules/transformation-matrix/src/applyToPoint.js
+function applyToPoint(matrix, point) {
+  return Array.isArray(point) ? [
+    matrix.a * point[0] + matrix.c * point[1] + matrix.e,
+    matrix.b * point[0] + matrix.d * point[1] + matrix.f
+  ] : {
+    x: matrix.a * point.x + matrix.c * point.y + matrix.e,
+    y: matrix.b * point.x + matrix.d * point.y + matrix.f
+  };
+}
+
+// node_modules/transformation-matrix/src/utils.js
+function isUndefined(val) {
+  return typeof val === "undefined";
+}
+
+// node_modules/transformation-matrix/src/translate.js
+function translate(tx, ty = 0) {
+  return {
+    a: 1,
+    c: 0,
+    e: tx,
+    b: 0,
+    d: 1,
+    f: ty
+  };
+}
+
+// node_modules/transformation-matrix/src/transform.js
+function transform(...matrices) {
+  matrices = Array.isArray(matrices[0]) ? matrices[0] : matrices;
+  const multiply = (m1, m2) => {
+    return {
+      a: m1.a * m2.a + m1.c * m2.b,
+      c: m1.a * m2.c + m1.c * m2.d,
+      e: m1.a * m2.e + m1.c * m2.f + m1.e,
+      b: m1.b * m2.a + m1.d * m2.b,
+      d: m1.b * m2.c + m1.d * m2.d,
+      f: m1.b * m2.e + m1.d * m2.f + m1.f
+    };
+  };
+  switch (matrices.length) {
+    case 0:
+      throw new Error("no matrices provided");
+    case 1:
+      return matrices[0];
+    case 2:
+      return multiply(matrices[0], matrices[1]);
+    default: {
+      const [m1, m2, ...rest] = matrices;
+      const m = multiply(m1, m2);
+      return transform(m, ...rest);
+    }
+  }
+}
+function compose(...matrices) {
+  return transform(...matrices);
+}
+
+// node_modules/transformation-matrix/src/rotate.js
+var { cos, sin, PI } = Math;
+function rotate(angle, cx, cy) {
+  const cosAngle = cos(angle);
+  const sinAngle = sin(angle);
+  const rotationMatrix = {
+    a: cosAngle,
+    c: -sinAngle,
+    e: 0,
+    b: sinAngle,
+    d: cosAngle,
+    f: 0
+  };
+  if (isUndefined(cx) || isUndefined(cy)) {
+    return rotationMatrix;
+  }
+  return transform([
+    translate(cx, cy),
+    rotationMatrix,
+    translate(-cx, -cy)
+  ]);
+}
+
+// node_modules/transformation-matrix/src/skew.js
+var { tan } = Math;
+
+// lib/JumperGraphSolver/geometry/applyTransformToGraph.ts
+var applyTransformToGraph = (graph, matrix) => {
+  const transformedRegions = graph.regions.map((region) => {
+    const { bounds, center, ...rest } = region.d;
+    const corners = [
+      { x: bounds.minX, y: bounds.minY },
+      { x: bounds.maxX, y: bounds.minY },
+      { x: bounds.minX, y: bounds.maxY },
+      { x: bounds.maxX, y: bounds.maxY }
+    ].map((corner) => applyToPoint(matrix, corner));
+    const newBounds = {
+      minX: Math.min(...corners.map((c) => c.x)),
+      maxX: Math.max(...corners.map((c) => c.x)),
+      minY: Math.min(...corners.map((c) => c.y)),
+      maxY: Math.max(...corners.map((c) => c.y))
+    };
+    const newCenter = applyToPoint(matrix, center);
+    return {
+      ...region,
+      // Clear ports array - will be rebuilt with new port objects
+      ports: [],
+      d: {
+        ...rest,
+        bounds: newBounds,
+        center: newCenter
+      }
+    };
+  });
+  const regionMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < graph.regions.length; i++) {
+    regionMap.set(graph.regions[i], transformedRegions[i]);
+  }
+  const transformedPorts = graph.ports.map((port) => {
+    const newPosition = applyToPoint(matrix, port.d);
+    const newRegion1 = regionMap.get(port.region1);
+    const newRegion2 = regionMap.get(port.region2);
+    const newPort = {
+      ...port,
+      region1: newRegion1,
+      region2: newRegion2,
+      d: newPosition
+    };
+    newRegion1.ports.push(newPort);
+    newRegion2.ports.push(newPort);
+    return newPort;
+  });
+  return {
+    regions: transformedRegions,
+    ports: transformedPorts
+  };
+};
+var rotateGraph90Degrees = (graph) => {
+  const bounds = calculateGraphBounds(graph.regions);
+  const center = computeBoundsCenter(bounds);
+  const matrix = compose(
+    translate(center.x, center.y),
+    rotate(-Math.PI / 2),
+    // -90 degrees (clockwise)
+    translate(-center.x, -center.y)
+  );
+  return applyTransformToGraph(graph, matrix);
+};
+
+// lib/JumperGraphSolver/jumper-graph-generator/generateJumperX4Grid.ts
+var generateJumperX4Grid = ({
+  cols,
+  rows,
+  marginX,
+  marginY,
+  innerColChannelPointCount = 1,
+  innerRowChannelPointCount = 1,
+  regionsBetweenPads = false,
+  outerPaddingX = 0.5,
+  outerPaddingY = 0.5,
+  outerChannelXPointCount,
+  outerChannelYPointCount,
+  orientation: orientation2 = "vertical",
+  center
+}) => {
+  const effectiveOuterChannelXPoints = outerChannelXPointCount ?? Math.max(1, Math.floor(outerPaddingX / 0.4));
+  const effectiveOuterChannelYPoints = outerChannelYPointCount ?? Math.max(1, Math.floor(outerPaddingY / 0.4));
+  const regions = [];
+  const ports = [];
+  const {
+    padWidth,
+    padHeight,
+    leftPadCenterX,
+    rightPadCenterX,
+    row1CenterY,
+    row2CenterY,
+    row3CenterY,
+    row4CenterY
+  } = dims1206x4;
+  const padHalfWidth = padWidth / 2;
+  const padHalfHeight = padHeight / 2;
+  const cellWidth = rightPadCenterX - leftPadCenterX + padWidth;
+  const horizontalSpacing = cellWidth + marginX;
+  const cellHeight = row1CenterY - row4CenterY + padHeight;
+  const verticalSpacing = cellHeight + marginY;
+  const cells = [];
+  const createRegion = (id, bounds, isPad, isThroughJumper) => ({
+    regionId: id,
+    ports: [],
+    d: { bounds, center: computeBoundsCenter(bounds), isPad, isThroughJumper }
+  });
+  const createPort = (id, region1, region2) => {
+    const b1 = region1.d.bounds;
+    const b2 = region2.d.bounds;
+    let x;
+    let y;
+    if (Math.abs(b1.maxX - b2.minX) < 1e-3) {
+      x = b1.maxX;
+      y = (Math.max(b1.minY, b2.minY) + Math.min(b1.maxY, b2.maxY)) / 2;
+    } else if (Math.abs(b1.minX - b2.maxX) < 1e-3) {
+      x = b1.minX;
+      y = (Math.max(b1.minY, b2.minY) + Math.min(b1.maxY, b2.maxY)) / 2;
+    } else if (Math.abs(b1.maxY - b2.minY) < 1e-3) {
+      x = (Math.max(b1.minX, b2.minX) + Math.min(b1.maxX, b2.maxX)) / 2;
+      y = b1.maxY;
+    } else {
+      x = (Math.max(b1.minX, b2.minX) + Math.min(b1.maxX, b2.maxX)) / 2;
+      y = b1.minY;
+    }
+    const port = {
+      portId: id,
+      region1,
+      region2,
+      d: { x, y }
+    };
+    region1.ports.push(port);
+    region2.ports.push(port);
+    return port;
+  };
+  const createMultiplePorts = (idPrefix, region1, region2, count) => {
+    if (count <= 0) return [];
+    if (count === 1) {
+      return [createPort(idPrefix, region1, region2)];
+    }
+    const b1 = region1.d.bounds;
+    const b2 = region2.d.bounds;
+    const result = [];
+    let isVerticalBoundary;
+    let boundaryCoord;
+    let sharedMin;
+    let sharedMax;
+    if (Math.abs(b1.maxX - b2.minX) < 1e-3) {
+      isVerticalBoundary = true;
+      boundaryCoord = b1.maxX;
+      sharedMin = Math.max(b1.minY, b2.minY);
+      sharedMax = Math.min(b1.maxY, b2.maxY);
+    } else if (Math.abs(b1.minX - b2.maxX) < 1e-3) {
+      isVerticalBoundary = true;
+      boundaryCoord = b1.minX;
+      sharedMin = Math.max(b1.minY, b2.minY);
+      sharedMax = Math.min(b1.maxY, b2.maxY);
+    } else if (Math.abs(b1.maxY - b2.minY) < 1e-3) {
+      isVerticalBoundary = false;
+      boundaryCoord = b1.maxY;
+      sharedMin = Math.max(b1.minX, b2.minX);
+      sharedMax = Math.min(b1.maxX, b2.maxX);
+    } else {
+      isVerticalBoundary = false;
+      boundaryCoord = b1.minY;
+      sharedMin = Math.max(b1.minX, b2.minX);
+      sharedMax = Math.min(b1.maxX, b2.maxX);
+    }
+    for (let i = 0; i < count; i++) {
+      const t = (i + 0.5) / count;
+      const coord = sharedMin + t * (sharedMax - sharedMin);
+      const x = isVerticalBoundary ? boundaryCoord : coord;
+      const y = isVerticalBoundary ? coord : boundaryCoord;
+      const port = {
+        portId: `${idPrefix}:${i}`,
+        region1,
+        region2,
+        d: { x, y }
+      };
+      region1.ports.push(port);
+      region2.ports.push(port);
+      result.push(port);
+    }
+    return result;
+  };
+  for (let row = 0; row < rows; row++) {
+    cells[row] = [];
+    for (let col = 0; col < cols; col++) {
+      const idPrefix = `cell_${row}_${col}`;
+      const centerX = col * horizontalSpacing;
+      const centerY = -row * verticalSpacing;
+      const p1CenterX = centerX + leftPadCenterX;
+      const p1CenterY = centerY + row1CenterY;
+      const p2CenterX = centerX + leftPadCenterX;
+      const p2CenterY = centerY + row2CenterY;
+      const p3CenterX = centerX + leftPadCenterX;
+      const p3CenterY = centerY + row3CenterY;
+      const p4CenterX = centerX + leftPadCenterX;
+      const p4CenterY = centerY + row4CenterY;
+      const p5CenterX = centerX + rightPadCenterX;
+      const p5CenterY = centerY + row4CenterY;
+      const p6CenterX = centerX + rightPadCenterX;
+      const p6CenterY = centerY + row3CenterY;
+      const p7CenterX = centerX + rightPadCenterX;
+      const p7CenterY = centerY + row2CenterY;
+      const p8CenterX = centerX + rightPadCenterX;
+      const p8CenterY = centerY + row1CenterY;
+      const createPadBounds = (padCenterX, padCenterY) => ({
+        minX: padCenterX - padHalfWidth,
+        maxX: padCenterX + padHalfWidth,
+        minY: padCenterY - padHalfHeight,
+        maxY: padCenterY + padHalfHeight
+      });
+      const pad1Bounds = createPadBounds(p1CenterX, p1CenterY);
+      const pad2Bounds = createPadBounds(p2CenterX, p2CenterY);
+      const pad3Bounds = createPadBounds(p3CenterX, p3CenterY);
+      const pad4Bounds = createPadBounds(p4CenterX, p4CenterY);
+      const pad5Bounds = createPadBounds(p5CenterX, p5CenterY);
+      const pad6Bounds = createPadBounds(p6CenterX, p6CenterY);
+      const pad7Bounds = createPadBounds(p7CenterX, p7CenterY);
+      const pad8Bounds = createPadBounds(p8CenterX, p8CenterY);
+      const underjumperBounds = {
+        minX: pad1Bounds.maxX,
+        maxX: pad8Bounds.minX,
+        minY: pad4Bounds.minY,
+        maxY: pad1Bounds.maxY
+      };
+      const throughjumperHeight = 0.3;
+      const throughjumper1Bounds = {
+        minX: p1CenterX,
+        maxX: p8CenterX,
+        minY: p1CenterY - throughjumperHeight / 2,
+        maxY: p1CenterY + throughjumperHeight / 2
+      };
+      const throughjumper2Bounds = {
+        minX: p2CenterX,
+        maxX: p7CenterX,
+        minY: p2CenterY - throughjumperHeight / 2,
+        maxY: p2CenterY + throughjumperHeight / 2
+      };
+      const throughjumper3Bounds = {
+        minX: p3CenterX,
+        maxX: p6CenterX,
+        minY: p3CenterY - throughjumperHeight / 2,
+        maxY: p3CenterY + throughjumperHeight / 2
+      };
+      const throughjumper4Bounds = {
+        minX: p4CenterX,
+        maxX: p5CenterX,
+        minY: p4CenterY - throughjumperHeight / 2,
+        maxY: p4CenterY + throughjumperHeight / 2
+      };
+      const mainMinX = pad1Bounds.minX;
+      const mainMaxX = pad8Bounds.maxX;
+      const mainMinY = pad4Bounds.minY;
+      const mainMaxY = pad1Bounds.maxY;
+      const pad1 = createRegion(`${idPrefix}:pad1`, pad1Bounds, true);
+      const pad2 = createRegion(`${idPrefix}:pad2`, pad2Bounds, true);
+      const pad3 = createRegion(`${idPrefix}:pad3`, pad3Bounds, true);
+      const pad4 = createRegion(`${idPrefix}:pad4`, pad4Bounds, true);
+      const pad5 = createRegion(`${idPrefix}:pad5`, pad5Bounds, true);
+      const pad6 = createRegion(`${idPrefix}:pad6`, pad6Bounds, true);
+      const pad7 = createRegion(`${idPrefix}:pad7`, pad7Bounds, true);
+      const pad8 = createRegion(`${idPrefix}:pad8`, pad8Bounds, true);
+      const underjumper = createRegion(
+        `${idPrefix}:underjumper`,
+        underjumperBounds,
+        false
+      );
+      const throughjumper1 = createRegion(
+        `${idPrefix}:throughjumper1`,
+        throughjumper1Bounds,
+        false,
+        true
+      );
+      const throughjumper2 = createRegion(
+        `${idPrefix}:throughjumper2`,
+        throughjumper2Bounds,
+        false,
+        true
+      );
+      const throughjumper3 = createRegion(
+        `${idPrefix}:throughjumper3`,
+        throughjumper3Bounds,
+        false,
+        true
+      );
+      const throughjumper4 = createRegion(
+        `${idPrefix}:throughjumper4`,
+        throughjumper4Bounds,
+        false,
+        true
+      );
+      regions.push(
+        pad1,
+        pad2,
+        pad3,
+        pad4,
+        pad5,
+        pad6,
+        pad7,
+        pad8,
+        underjumper,
+        throughjumper1,
+        throughjumper2,
+        throughjumper3,
+        throughjumper4
+      );
+      let leftBP12 = null;
+      let leftBP23 = null;
+      let leftBP34 = null;
+      let rightBP87 = null;
+      let rightBP76 = null;
+      let rightBP65 = null;
+      if (regionsBetweenPads) {
+        leftBP12 = createRegion(
+          `${idPrefix}:L-BP12`,
+          {
+            minX: pad1Bounds.minX,
+            maxX: pad1Bounds.maxX,
+            minY: pad2Bounds.maxY,
+            maxY: pad1Bounds.minY
+          },
+          false
+        );
+        leftBP23 = createRegion(
+          `${idPrefix}:L-BP23`,
+          {
+            minX: pad2Bounds.minX,
+            maxX: pad2Bounds.maxX,
+            minY: pad3Bounds.maxY,
+            maxY: pad2Bounds.minY
+          },
+          false
+        );
+        leftBP34 = createRegion(
+          `${idPrefix}:L-BP34`,
+          {
+            minX: pad3Bounds.minX,
+            maxX: pad3Bounds.maxX,
+            minY: pad4Bounds.maxY,
+            maxY: pad3Bounds.minY
+          },
+          false
+        );
+        rightBP87 = createRegion(
+          `${idPrefix}:R-BP87`,
+          {
+            minX: pad8Bounds.minX,
+            maxX: pad8Bounds.maxX,
+            minY: pad7Bounds.maxY,
+            maxY: pad8Bounds.minY
+          },
+          false
+        );
+        rightBP76 = createRegion(
+          `${idPrefix}:R-BP76`,
+          {
+            minX: pad7Bounds.minX,
+            maxX: pad7Bounds.maxX,
+            minY: pad6Bounds.maxY,
+            maxY: pad7Bounds.minY
+          },
+          false
+        );
+        rightBP65 = createRegion(
+          `${idPrefix}:R-BP65`,
+          {
+            minX: pad6Bounds.minX,
+            maxX: pad6Bounds.maxX,
+            minY: pad5Bounds.maxY,
+            maxY: pad6Bounds.minY
+          },
+          false
+        );
+        regions.push(
+          leftBP12,
+          leftBP23,
+          leftBP34,
+          rightBP87,
+          rightBP76,
+          rightBP65
+        );
+      }
+      const isFirstRow = row === 0;
+      const isFirstCol = col === 0;
+      const isLastRow = row === rows - 1;
+      const isLastCol = col === cols - 1;
+      let frameRightEdge;
+      if (isLastCol) {
+        frameRightEdge = mainMaxX + outerPaddingX;
+      } else {
+        const nextCenterX = (col + 1) * horizontalSpacing;
+        const nextP1CenterX = nextCenterX + leftPadCenterX;
+        frameRightEdge = nextP1CenterX - padHalfWidth;
+      }
+      let top = null;
+      if (isFirstRow) {
+        top = createRegion(
+          `${idPrefix}:T`,
+          {
+            minX: isFirstCol ? mainMinX - outerPaddingX : mainMinX,
+            maxX: frameRightEdge,
+            minY: mainMaxY,
+            maxY: mainMaxY + outerPaddingY
+          },
+          false
+        );
+        regions.push(top);
+      }
+      let bottom = null;
+      const bottomHeight = isLastRow ? outerPaddingY : marginY;
+      bottom = createRegion(
+        `${idPrefix}:B`,
+        {
+          minX: isFirstCol ? mainMinX - outerPaddingX : mainMinX,
+          maxX: frameRightEdge,
+          minY: mainMinY - bottomHeight,
+          maxY: mainMinY
+        },
+        false
+      );
+      regions.push(bottom);
+      let left = null;
+      if (isFirstCol) {
+        left = createRegion(
+          `${idPrefix}:L`,
+          {
+            minX: mainMinX - outerPaddingX,
+            maxX: mainMinX,
+            minY: mainMinY,
+            maxY: mainMaxY
+          },
+          false
+        );
+        regions.push(left);
+      }
+      const right = createRegion(
+        `${idPrefix}:R`,
+        {
+          minX: mainMaxX,
+          maxX: frameRightEdge,
+          minY: mainMinY,
+          maxY: mainMaxY
+        },
+        false
+      );
+      regions.push(right);
+      cells[row][col] = {
+        pad1,
+        pad2,
+        pad3,
+        pad4,
+        pad5,
+        pad6,
+        pad7,
+        pad8,
+        underjumper,
+        throughjumper1,
+        throughjumper2,
+        throughjumper3,
+        throughjumper4,
+        top,
+        bottom,
+        left,
+        right,
+        leftBP12,
+        leftBP23,
+        leftBP34,
+        rightBP87,
+        rightBP76,
+        rightBP65
+      };
+      if (top) {
+        if (left) {
+          ports.push(
+            ...createMultiplePorts(
+              `${idPrefix}:T-L`,
+              top,
+              left,
+              effectiveOuterChannelXPoints
+            )
+          );
+        }
+        ports.push(
+          ...createMultiplePorts(
+            `${idPrefix}:T-R`,
+            top,
+            right,
+            isLastCol ? effectiveOuterChannelXPoints : innerColChannelPointCount
+          )
+        );
+        ports.push(createPort(`${idPrefix}:T-P1`, top, pad1));
+        ports.push(createPort(`${idPrefix}:T-P8`, top, pad8));
+        if (regionsBetweenPads) {
+          const ujBounds = underjumper.d.bounds;
+          const ujWidth = ujBounds.maxX - ujBounds.minX;
+          const portSpacing = ujWidth / 5;
+          for (let i = 1; i <= 4; i++) {
+            const portX = ujBounds.minX + portSpacing * i;
+            const topUJPort = {
+              portId: `${idPrefix}:T-UJ${i}`,
+              region1: top,
+              region2: underjumper,
+              d: { x: portX, y: ujBounds.maxY }
+            };
+            top.ports.push(topUJPort);
+            underjumper.ports.push(topUJPort);
+            ports.push(topUJPort);
+          }
+        } else {
+          ports.push(createPort(`${idPrefix}:T-UJ`, top, underjumper));
+        }
+      }
+      if (bottom) {
+        if (left) {
+          ports.push(
+            ...createMultiplePorts(
+              `${idPrefix}:B-L`,
+              bottom,
+              left,
+              effectiveOuterChannelXPoints
+            )
+          );
+        }
+        ports.push(
+          ...createMultiplePorts(
+            `${idPrefix}:B-R`,
+            bottom,
+            right,
+            isLastCol ? effectiveOuterChannelXPoints : innerColChannelPointCount
+          )
+        );
+        ports.push(createPort(`${idPrefix}:B-P4`, bottom, pad4));
+        ports.push(createPort(`${idPrefix}:B-P5`, bottom, pad5));
+        if (regionsBetweenPads) {
+          const ujBounds = underjumper.d.bounds;
+          const ujWidth = ujBounds.maxX - ujBounds.minX;
+          const portSpacing = ujWidth / 5;
+          for (let i = 1; i <= 4; i++) {
+            const portX = ujBounds.minX + portSpacing * i;
+            const bottomUJPort = {
+              portId: `${idPrefix}:B-UJ${i}`,
+              region1: bottom,
+              region2: underjumper,
+              d: { x: portX, y: ujBounds.minY }
+            };
+            bottom.ports.push(bottomUJPort);
+            underjumper.ports.push(bottomUJPort);
+            ports.push(bottomUJPort);
+          }
+        } else {
+          ports.push(createPort(`${idPrefix}:B-UJ`, bottom, underjumper));
+        }
+      }
+      if (left) {
+        ports.push(createPort(`${idPrefix}:L-P1`, left, pad1));
+        ports.push(createPort(`${idPrefix}:L-P2`, left, pad2));
+        ports.push(createPort(`${idPrefix}:L-P3`, left, pad3));
+        ports.push(createPort(`${idPrefix}:L-P4`, left, pad4));
+      }
+      ports.push(createPort(`${idPrefix}:R-P5`, right, pad5));
+      ports.push(createPort(`${idPrefix}:R-P6`, right, pad6));
+      ports.push(createPort(`${idPrefix}:R-P7`, right, pad7));
+      ports.push(createPort(`${idPrefix}:R-P8`, right, pad8));
+      if (regionsBetweenPads) {
+        if (left) {
+          ports.push(createPort(`${idPrefix}:L-BP12`, left, leftBP12));
+          ports.push(createPort(`${idPrefix}:L-BP23`, left, leftBP23));
+          ports.push(createPort(`${idPrefix}:L-BP34`, left, leftBP34));
+        }
+        ports.push(createPort(`${idPrefix}:UJ-LBP12`, leftBP12, underjumper));
+        ports.push(createPort(`${idPrefix}:UJ-LBP23`, leftBP23, underjumper));
+        ports.push(createPort(`${idPrefix}:UJ-LBP34`, leftBP34, underjumper));
+        ports.push(createPort(`${idPrefix}:R-BP87`, right, rightBP87));
+        ports.push(createPort(`${idPrefix}:R-BP76`, right, rightBP76));
+        ports.push(createPort(`${idPrefix}:R-BP65`, right, rightBP65));
+        ports.push(createPort(`${idPrefix}:UJ-RBP87`, rightBP87, underjumper));
+        ports.push(createPort(`${idPrefix}:UJ-RBP76`, rightBP76, underjumper));
+        ports.push(createPort(`${idPrefix}:UJ-RBP65`, rightBP65, underjumper));
+      }
+      const tj1LeftPort = {
+        portId: `${idPrefix}:TJ1-P1`,
+        region1: throughjumper1,
+        region2: pad1,
+        d: { x: p1CenterX, y: p1CenterY }
+      };
+      throughjumper1.ports.push(tj1LeftPort);
+      pad1.ports.push(tj1LeftPort);
+      ports.push(tj1LeftPort);
+      const tj1RightPort = {
+        portId: `${idPrefix}:TJ1-P8`,
+        region1: throughjumper1,
+        region2: pad8,
+        d: { x: p8CenterX, y: p8CenterY }
+      };
+      throughjumper1.ports.push(tj1RightPort);
+      pad8.ports.push(tj1RightPort);
+      ports.push(tj1RightPort);
+      const tj2LeftPort = {
+        portId: `${idPrefix}:TJ2-P2`,
+        region1: throughjumper2,
+        region2: pad2,
+        d: { x: p2CenterX, y: p2CenterY }
+      };
+      throughjumper2.ports.push(tj2LeftPort);
+      pad2.ports.push(tj2LeftPort);
+      ports.push(tj2LeftPort);
+      const tj2RightPort = {
+        portId: `${idPrefix}:TJ2-P7`,
+        region1: throughjumper2,
+        region2: pad7,
+        d: { x: p7CenterX, y: p7CenterY }
+      };
+      throughjumper2.ports.push(tj2RightPort);
+      pad7.ports.push(tj2RightPort);
+      ports.push(tj2RightPort);
+      const tj3LeftPort = {
+        portId: `${idPrefix}:TJ3-P3`,
+        region1: throughjumper3,
+        region2: pad3,
+        d: { x: p3CenterX, y: p3CenterY }
+      };
+      throughjumper3.ports.push(tj3LeftPort);
+      pad3.ports.push(tj3LeftPort);
+      ports.push(tj3LeftPort);
+      const tj3RightPort = {
+        portId: `${idPrefix}:TJ3-P6`,
+        region1: throughjumper3,
+        region2: pad6,
+        d: { x: p6CenterX, y: p6CenterY }
+      };
+      throughjumper3.ports.push(tj3RightPort);
+      pad6.ports.push(tj3RightPort);
+      ports.push(tj3RightPort);
+      const tj4LeftPort = {
+        portId: `${idPrefix}:TJ4-P4`,
+        region1: throughjumper4,
+        region2: pad4,
+        d: { x: p4CenterX, y: p4CenterY }
+      };
+      throughjumper4.ports.push(tj4LeftPort);
+      pad4.ports.push(tj4LeftPort);
+      ports.push(tj4LeftPort);
+      const tj4RightPort = {
+        portId: `${idPrefix}:TJ4-P5`,
+        region1: throughjumper4,
+        region2: pad5,
+        d: { x: p5CenterX, y: p5CenterY }
+      };
+      throughjumper4.ports.push(tj4RightPort);
+      pad5.ports.push(tj4RightPort);
+      ports.push(tj4RightPort);
+      if (col > 0) {
+        const prevCell = cells[row][col - 1];
+        ports.push(
+          createPort(
+            `cell_${row}_${col - 1}->cell_${row}_${col}:R-P1`,
+            prevCell.right,
+            pad1
+          )
+        );
+        ports.push(
+          createPort(
+            `cell_${row}_${col - 1}->cell_${row}_${col}:R-P2`,
+            prevCell.right,
+            pad2
+          )
+        );
+        ports.push(
+          createPort(
+            `cell_${row}_${col - 1}->cell_${row}_${col}:R-P3`,
+            prevCell.right,
+            pad3
+          )
+        );
+        ports.push(
+          createPort(
+            `cell_${row}_${col - 1}->cell_${row}_${col}:R-P4`,
+            prevCell.right,
+            pad4
+          )
+        );
+        if (regionsBetweenPads) {
+          ports.push(
+            createPort(
+              `cell_${row}_${col - 1}->cell_${row}_${col}:R-LBP12`,
+              prevCell.right,
+              leftBP12
+            )
+          );
+          ports.push(
+            createPort(
+              `cell_${row}_${col - 1}->cell_${row}_${col}:R-LBP23`,
+              prevCell.right,
+              leftBP23
+            )
+          );
+          ports.push(
+            createPort(
+              `cell_${row}_${col - 1}->cell_${row}_${col}:R-LBP34`,
+              prevCell.right,
+              leftBP34
+            )
+          );
+        }
+        if (top && prevCell.top) {
+          ports.push(
+            ...createMultiplePorts(
+              `cell_${row}_${col - 1}->cell_${row}_${col}:T-T`,
+              prevCell.top,
+              top,
+              innerRowChannelPointCount
+            )
+          );
+        }
+        if (bottom && prevCell.bottom) {
+          ports.push(
+            ...createMultiplePorts(
+              `cell_${row}_${col - 1}->cell_${row}_${col}:B-B`,
+              prevCell.bottom,
+              bottom,
+              innerRowChannelPointCount
+            )
+          );
+        }
+      }
+      if (row > 0) {
+        const aboveCell = cells[row - 1][col];
+        if (left) {
+          ports.push(
+            ...createMultiplePorts(
+              `cell_${row - 1}_${col}->cell_${row}_${col}:B-L`,
+              aboveCell.bottom,
+              left,
+              effectiveOuterChannelXPoints
+            )
+          );
+        }
+        ports.push(
+          createPort(
+            `cell_${row - 1}_${col}->cell_${row}_${col}:B-P1`,
+            aboveCell.bottom,
+            pad1
+          )
+        );
+        if (regionsBetweenPads) {
+          const ujBounds = underjumper.d.bounds;
+          const ujWidth = ujBounds.maxX - ujBounds.minX;
+          const portSpacing = ujWidth / 5;
+          for (let i = 1; i <= 4; i++) {
+            const portX = ujBounds.minX + portSpacing * i;
+            const aboveUJPort = {
+              portId: `cell_${row - 1}_${col}->cell_${row}_${col}:B-UJ${i}`,
+              region1: aboveCell.bottom,
+              region2: underjumper,
+              d: { x: portX, y: ujBounds.maxY }
+            };
+            aboveCell.bottom.ports.push(aboveUJPort);
+            underjumper.ports.push(aboveUJPort);
+            ports.push(aboveUJPort);
+          }
+        } else {
+          ports.push(
+            createPort(
+              `cell_${row - 1}_${col}->cell_${row}_${col}:B-UJ`,
+              aboveCell.bottom,
+              underjumper
+            )
+          );
+        }
+        ports.push(
+          createPort(
+            `cell_${row - 1}_${col}->cell_${row}_${col}:B-P8`,
+            aboveCell.bottom,
+            pad8
+          )
+        );
+        ports.push(
+          ...createMultiplePorts(
+            `cell_${row - 1}_${col}->cell_${row}_${col}:B-R`,
+            aboveCell.bottom,
+            right,
+            isLastCol ? effectiveOuterChannelXPoints : innerColChannelPointCount
+          )
+        );
+      }
+    }
+  }
+  let graph = { regions, ports };
+  const needsRotation = orientation2 === "horizontal";
+  const needsCentering = center !== void 0;
+  if (needsRotation || needsCentering) {
+    const currentBounds = calculateGraphBounds(graph.regions);
+    const currentCenter = computeBoundsCenter(currentBounds);
+    const matrices = [];
+    matrices.push(translate(-currentCenter.x, -currentCenter.y));
+    if (needsRotation) {
+      matrices.push(rotate(-Math.PI / 2));
+    }
+    const targetCenter = center ?? currentCenter;
+    matrices.push(translate(targetCenter.x, targetCenter.y));
+    const matrix = compose(...matrices);
+    graph = applyTransformToGraph(graph, matrix);
+  }
+  return graph;
+};
+
+// lib/JumperGraphSolver/jumper-graph-generator/generateSingleJumperRegions.ts
+var dims0603 = {
+  padToPad: 1.65,
+  padLength: 0.8,
+  padWidth: 0.95
+};
+
+// lib/JumperGraphSolver/jumper-graph-generator/generateJumperGrid.ts
+var generateJumperGrid = ({
+  cols,
+  rows,
+  marginX,
+  marginY,
+  innerColChannelPointCount = 1,
+  innerRowChannelPointCount = 1,
+  outerPaddingX = 0.5,
+  outerPaddingY = 0.5,
+  outerChannelXPoints,
+  outerChannelYPoints
+}) => {
+  const effectiveOuterChannelXPoints = outerChannelXPoints ?? Math.max(1, Math.floor(outerPaddingX / 0.4));
+  const effectiveOuterChannelYPoints = outerChannelYPoints ?? Math.max(1, Math.floor(outerPaddingY / 0.4));
+  const regions = [];
+  const ports = [];
+  const { padToPad, padLength, padWidth } = dims0603;
+  const padHalfLength = padLength / 2;
+  const padHalfWidth = padWidth / 2;
+  const horizontalSpacing = padToPad + padLength + marginX;
+  const verticalSpacing = padWidth + marginY;
+  const cells = [];
+  const createRegion = (id, bounds, isPad, isThroughJumper) => ({
+    regionId: id,
+    ports: [],
+    d: { bounds, center: computeBoundsCenter(bounds), isPad, isThroughJumper }
+  });
+  const createPort = (id, region1, region2) => {
+    const b1 = region1.d.bounds;
+    const b2 = region2.d.bounds;
+    let x;
+    let y;
+    if (Math.abs(b1.maxX - b2.minX) < 1e-3) {
+      x = b1.maxX;
+      y = (Math.max(b1.minY, b2.minY) + Math.min(b1.maxY, b2.maxY)) / 2;
+    } else if (Math.abs(b1.minX - b2.maxX) < 1e-3) {
+      x = b1.minX;
+      y = (Math.max(b1.minY, b2.minY) + Math.min(b1.maxY, b2.maxY)) / 2;
+    } else if (Math.abs(b1.maxY - b2.minY) < 1e-3) {
+      x = (Math.max(b1.minX, b2.minX) + Math.min(b1.maxX, b2.maxX)) / 2;
+      y = b1.maxY;
+    } else {
+      x = (Math.max(b1.minX, b2.minX) + Math.min(b1.maxX, b2.maxX)) / 2;
+      y = b1.minY;
+    }
+    const port = {
+      portId: id,
+      region1,
+      region2,
+      d: { x, y }
+    };
+    region1.ports.push(port);
+    region2.ports.push(port);
+    return port;
+  };
+  const createMultiplePorts = (idPrefix, region1, region2, count) => {
+    if (count <= 0) return [];
+    if (count === 1) {
+      return [createPort(idPrefix, region1, region2)];
+    }
+    const b1 = region1.d.bounds;
+    const b2 = region2.d.bounds;
+    const result = [];
+    let isVerticalBoundary;
+    let boundaryCoord;
+    let sharedMin;
+    let sharedMax;
+    if (Math.abs(b1.maxX - b2.minX) < 1e-3) {
+      isVerticalBoundary = true;
+      boundaryCoord = b1.maxX;
+      sharedMin = Math.max(b1.minY, b2.minY);
+      sharedMax = Math.min(b1.maxY, b2.maxY);
+    } else if (Math.abs(b1.minX - b2.maxX) < 1e-3) {
+      isVerticalBoundary = true;
+      boundaryCoord = b1.minX;
+      sharedMin = Math.max(b1.minY, b2.minY);
+      sharedMax = Math.min(b1.maxY, b2.maxY);
+    } else if (Math.abs(b1.maxY - b2.minY) < 1e-3) {
+      isVerticalBoundary = false;
+      boundaryCoord = b1.maxY;
+      sharedMin = Math.max(b1.minX, b2.minX);
+      sharedMax = Math.min(b1.maxX, b2.maxX);
+    } else {
+      isVerticalBoundary = false;
+      boundaryCoord = b1.minY;
+      sharedMin = Math.max(b1.minX, b2.minX);
+      sharedMax = Math.min(b1.maxX, b2.maxX);
+    }
+    for (let i = 0; i < count; i++) {
+      const t = (i + 0.5) / count;
+      const coord = sharedMin + t * (sharedMax - sharedMin);
+      const x = isVerticalBoundary ? boundaryCoord : coord;
+      const y = isVerticalBoundary ? coord : boundaryCoord;
+      const port = {
+        portId: `${idPrefix}:${i}`,
+        region1,
+        region2,
+        d: { x, y }
+      };
+      region1.ports.push(port);
+      region2.ports.push(port);
+      result.push(port);
+    }
+    return result;
+  };
+  for (let row = 0; row < rows; row++) {
+    cells[row] = [];
+    for (let col = 0; col < cols; col++) {
+      const idPrefix = `cell_${row}_${col}`;
+      const centerX = col * horizontalSpacing;
+      const centerY = -row * verticalSpacing;
+      const leftPadCenterX = centerX - padToPad / 2;
+      const rightPadCenterX = centerX + padToPad / 2;
+      const leftPadBounds = {
+        minX: leftPadCenterX - padHalfLength,
+        maxX: leftPadCenterX + padHalfLength,
+        minY: centerY - padHalfWidth,
+        maxY: centerY + padHalfWidth
+      };
+      const rightPadBounds = {
+        minX: rightPadCenterX - padHalfLength,
+        maxX: rightPadCenterX + padHalfLength,
+        minY: centerY - padHalfWidth,
+        maxY: centerY + padHalfWidth
+      };
+      const underjumperBounds = {
+        minX: leftPadBounds.maxX,
+        maxX: rightPadBounds.minX,
+        minY: centerY - padHalfWidth,
+        maxY: centerY + padHalfWidth
+      };
+      const throughjumperHeight = 0.3;
+      const throughjumperBounds = {
+        minX: leftPadCenterX,
+        maxX: rightPadCenterX,
+        minY: centerY - throughjumperHeight / 2,
+        maxY: centerY + throughjumperHeight / 2
+      };
+      const mainMinX = leftPadBounds.minX;
+      const mainMaxX = rightPadBounds.maxX;
+      const mainMinY = leftPadBounds.minY;
+      const mainMaxY = leftPadBounds.maxY;
+      const leftPad = createRegion(`${idPrefix}:leftPad`, leftPadBounds, true);
+      const rightPad = createRegion(
+        `${idPrefix}:rightPad`,
+        rightPadBounds,
+        true
+      );
+      const underjumper = createRegion(
+        `${idPrefix}:underjumper`,
+        underjumperBounds,
+        false
+      );
+      const throughjumper = createRegion(
+        `${idPrefix}:throughjumper`,
+        throughjumperBounds,
+        false,
+        true
+      );
+      regions.push(leftPad, rightPad, underjumper, throughjumper);
+      const isFirstRow = row === 0;
+      const isFirstCol = col === 0;
+      const isLastRow = row === rows - 1;
+      const isLastCol = col === cols - 1;
+      let frameRightEdge;
+      if (isLastCol) {
+        frameRightEdge = mainMaxX + outerPaddingX;
+      } else {
+        const nextCenterX = (col + 1) * horizontalSpacing;
+        const nextLeftPadCenterX = nextCenterX - padToPad / 2;
+        frameRightEdge = nextLeftPadCenterX - padHalfLength;
+      }
+      let top = null;
+      if (isFirstRow) {
+        top = createRegion(
+          `${idPrefix}:T`,
+          {
+            minX: isFirstCol ? mainMinX - outerPaddingX : mainMinX,
+            maxX: frameRightEdge,
+            minY: mainMaxY,
+            maxY: mainMaxY + outerPaddingY
+          },
+          false
+        );
+        regions.push(top);
+      }
+      let bottom = null;
+      const bottomHeight = isLastRow ? outerPaddingY : marginY;
+      bottom = createRegion(
+        `${idPrefix}:B`,
+        {
+          minX: isFirstCol ? mainMinX - outerPaddingX : mainMinX,
+          maxX: frameRightEdge,
+          minY: mainMinY - bottomHeight,
+          maxY: mainMinY
+        },
+        false
+      );
+      regions.push(bottom);
+      let left = null;
+      if (isFirstCol) {
+        left = createRegion(
+          `${idPrefix}:L`,
+          {
+            minX: mainMinX - outerPaddingX,
+            maxX: mainMinX,
+            minY: mainMinY,
+            maxY: mainMaxY
+          },
+          false
+        );
+        regions.push(left);
+      }
+      const right = createRegion(
+        `${idPrefix}:R`,
+        {
+          minX: mainMaxX,
+          maxX: frameRightEdge,
+          minY: mainMinY,
+          maxY: mainMaxY
+        },
+        false
+      );
+      regions.push(right);
+      cells[row][col] = {
+        leftPad,
+        rightPad,
+        underjumper,
+        throughjumper,
+        top,
+        bottom,
+        left,
+        right
+      };
+      if (top) {
+        if (left) {
+          ports.push(
+            ...createMultiplePorts(
+              `${idPrefix}:T-L`,
+              top,
+              left,
+              effectiveOuterChannelXPoints
+            )
+          );
+        }
+        ports.push(
+          ...createMultiplePorts(
+            `${idPrefix}:T-R`,
+            top,
+            right,
+            effectiveOuterChannelXPoints
+          )
+        );
+        ports.push(createPort(`${idPrefix}:T-LP`, top, leftPad));
+        ports.push(createPort(`${idPrefix}:T-RP`, top, rightPad));
+        ports.push(createPort(`${idPrefix}:T-UJ`, top, underjumper));
+      }
+      if (bottom) {
+        if (left) {
+          ports.push(
+            ...createMultiplePorts(
+              `${idPrefix}:B-L`,
+              bottom,
+              left,
+              effectiveOuterChannelXPoints
+            )
+          );
+        }
+        ports.push(
+          ...createMultiplePorts(
+            `${idPrefix}:B-R`,
+            bottom,
+            right,
+            effectiveOuterChannelXPoints
+          )
+        );
+        ports.push(createPort(`${idPrefix}:B-LP`, bottom, leftPad));
+        ports.push(createPort(`${idPrefix}:B-RP`, bottom, rightPad));
+        ports.push(createPort(`${idPrefix}:B-UJ`, bottom, underjumper));
+      }
+      if (left) {
+        ports.push(createPort(`${idPrefix}:L-LP`, left, leftPad));
+      }
+      ports.push(createPort(`${idPrefix}:R-RP`, right, rightPad));
+      const leftThroughPort = {
+        portId: `${idPrefix}:TJ-LP`,
+        region1: throughjumper,
+        region2: leftPad,
+        d: { x: leftPadCenterX, y: centerY }
+      };
+      throughjumper.ports.push(leftThroughPort);
+      leftPad.ports.push(leftThroughPort);
+      ports.push(leftThroughPort);
+      const rightThroughPort = {
+        portId: `${idPrefix}:TJ-RP`,
+        region1: throughjumper,
+        region2: rightPad,
+        d: { x: rightPadCenterX, y: centerY }
+      };
+      throughjumper.ports.push(rightThroughPort);
+      rightPad.ports.push(rightThroughPort);
+      ports.push(rightThroughPort);
+      if (col > 0) {
+        const prevCell = cells[row][col - 1];
+        ports.push(
+          createPort(
+            `cell_${row}_${col - 1}->cell_${row}_${col}:R-LP`,
+            prevCell.right,
+            leftPad
+          )
+        );
+        if (top && prevCell.top) {
+          ports.push(
+            ...createMultiplePorts(
+              `cell_${row}_${col - 1}->cell_${row}_${col}:T-T`,
+              prevCell.top,
+              top,
+              innerRowChannelPointCount
+            )
+          );
+        }
+        if (bottom && prevCell.bottom) {
+          ports.push(
+            ...createMultiplePorts(
+              `cell_${row}_${col - 1}->cell_${row}_${col}:B-B`,
+              prevCell.bottom,
+              bottom,
+              innerRowChannelPointCount
+            )
+          );
+        }
+      }
+      if (row > 0) {
+        const aboveCell = cells[row - 1][col];
+        if (left) {
+          ports.push(
+            ...createMultiplePorts(
+              `cell_${row - 1}_${col}->cell_${row}_${col}:B-L`,
+              aboveCell.bottom,
+              left,
+              effectiveOuterChannelXPoints
+            )
+          );
+        }
+        ports.push(
+          createPort(
+            `cell_${row - 1}_${col}->cell_${row}_${col}:B-LP`,
+            aboveCell.bottom,
+            leftPad
+          )
+        );
+        ports.push(
+          createPort(
+            `cell_${row - 1}_${col}->cell_${row}_${col}:B-UJ`,
+            aboveCell.bottom,
+            underjumper
+          )
+        );
+        ports.push(
+          createPort(
+            `cell_${row - 1}_${col}->cell_${row}_${col}:B-RP`,
+            aboveCell.bottom,
+            rightPad
+          )
+        );
+        ports.push(
+          ...createMultiplePorts(
+            `cell_${row - 1}_${col}->cell_${row}_${col}:B-R`,
+            aboveCell.bottom,
+            right,
+            effectiveOuterChannelXPoints
+          )
+        );
+      }
+    }
+  }
+  return {
+    regions,
+    ports
+  };
+};
+
+// lib/JumperGraphSolver/jumper-graph-generator/createConnectionPort.ts
+var createConnectionPort = (portId, connectionRegion, boundaryRegion, portPosition) => {
+  const port = {
+    portId,
+    region1: connectionRegion,
+    region2: boundaryRegion,
+    d: { x: portPosition.x, y: portPosition.y }
+  };
+  connectionRegion.ports.push(port);
+  boundaryRegion.ports.push(port);
+  return port;
+};
+
+// lib/JumperGraphSolver/jumper-graph-generator/createConnectionRegion.ts
+var CONNECTION_REGION_SIZE = 0.4;
+var createConnectionRegion = (regionId, x, y) => {
+  const halfSize = CONNECTION_REGION_SIZE / 2;
+  return {
+    regionId,
+    ports: [],
+    d: {
+      bounds: {
+        minX: x - halfSize,
+        maxX: x + halfSize,
+        minY: y - halfSize,
+        maxY: y + halfSize
+      },
+      center: { x, y },
+      isPad: false,
+      isConnectionRegion: true
+    }
+  };
+};
+
+// lib/JumperGraphSolver/jumper-graph-generator/findBoundaryRegion.ts
+var findBoundaryRegion = (x, y, regions, graphBounds) => {
+  for (const region of regions) {
+    if (region.d.isPad || region.d.isThroughJumper) continue;
+    const bounds = region.d.bounds;
+    if (Math.abs(x - bounds.minX) < 0.01 && y >= bounds.minY && y <= bounds.maxY) {
+      return { region, portPosition: { x: bounds.minX, y } };
+    }
+    if (Math.abs(x - bounds.maxX) < 0.01 && y >= bounds.minY && y <= bounds.maxY) {
+      return { region, portPosition: { x: bounds.maxX, y } };
+    }
+    if (Math.abs(y - bounds.minY) < 0.01 && x >= bounds.minX && x <= bounds.maxX) {
+      return { region, portPosition: { x, y: bounds.minY } };
+    }
+    if (Math.abs(y - bounds.maxY) < 0.01 && x >= bounds.minX && x <= bounds.maxX) {
+      return { region, portPosition: { x, y: bounds.maxY } };
+    }
+  }
+  let closestRegion = null;
+  let closestDistance = Number.POSITIVE_INFINITY;
+  let closestPortPosition = { x, y };
+  for (const region of regions) {
+    if (region.d.isPad || region.d.isThroughJumper) continue;
+    const bounds = region.d.bounds;
+    const isOuterRegion = Math.abs(bounds.minX - graphBounds.minX) < 0.01 || Math.abs(bounds.maxX - graphBounds.maxX) < 0.01 || Math.abs(bounds.minY - graphBounds.minY) < 0.01 || Math.abs(bounds.maxY - graphBounds.maxY) < 0.01;
+    if (!isOuterRegion) continue;
+    const clampedX = Math.max(bounds.minX, Math.min(bounds.maxX, x));
+    const clampedY = Math.max(bounds.minY, Math.min(bounds.maxY, y));
+    const dist = Math.sqrt((x - clampedX) ** 2 + (y - clampedY) ** 2);
+    if (dist < closestDistance) {
+      closestDistance = dist;
+      closestRegion = region;
+      if (x < bounds.minX) {
+        closestPortPosition = { x: bounds.minX, y: clampedY };
+      } else if (x > bounds.maxX) {
+        closestPortPosition = { x: bounds.maxX, y: clampedY };
+      } else if (y < bounds.minY) {
+        closestPortPosition = { x: clampedX, y: bounds.minY };
+      } else if (y > bounds.maxY) {
+        closestPortPosition = { x: clampedX, y: bounds.maxY };
+      } else {
+        closestPortPosition = { x: clampedX, y: clampedY };
+      }
+    }
+  }
+  if (closestRegion) {
+    return { region: closestRegion, portPosition: closestPortPosition };
+  }
+  return null;
+};
+
+// lib/JumperGraphSolver/jumper-graph-generator/createGraphWithConnectionsFromBaseGraph.ts
+var createGraphWithConnectionsFromBaseGraph = (baseGraph, xyConnections) => {
+  const regions = [...baseGraph.regions];
+  const ports = [...baseGraph.ports];
+  const connections = [];
+  const graphBounds = calculateGraphBounds(baseGraph.regions);
+  for (const xyConn of xyConnections) {
+    const { start, end, connectionId } = xyConn;
+    const startRegion = createConnectionRegion(
+      `conn:${connectionId}:start`,
+      start.x,
+      start.y
+    );
+    regions.push(startRegion);
+    const endRegion = createConnectionRegion(
+      `conn:${connectionId}:end`,
+      end.x,
+      end.y
+    );
+    regions.push(endRegion);
+    const startBoundary = findBoundaryRegion(
+      start.x,
+      start.y,
+      baseGraph.regions,
+      graphBounds
+    );
+    if (startBoundary) {
+      const startPort = createConnectionPort(
+        `conn:${connectionId}:start-port`,
+        startRegion,
+        startBoundary.region,
+        startBoundary.portPosition
+      );
+      ports.push(startPort);
+    }
+    const endBoundary = findBoundaryRegion(
+      end.x,
+      end.y,
+      baseGraph.regions,
+      graphBounds
+    );
+    if (endBoundary) {
+      const endPort = createConnectionPort(
+        `conn:${connectionId}:end-port`,
+        endRegion,
+        endBoundary.region,
+        endBoundary.portPosition
+      );
+      ports.push(endPort);
+    }
+    const connection = {
+      connectionId,
+      mutuallyConnectedNetworkId: connectionId,
+      startRegion,
+      endRegion
+    };
+    connections.push(connection);
+  }
+  return {
+    regions,
+    ports,
+    connections
+  };
+};
+
+// lib/HyperGraphSolver.ts
+import { BaseSolver } from "@tscircuit/solver-utils";
+
+// lib/convertSerializedHyperGraphToHyperGraph.ts
+var convertSerializedHyperGraphToHyperGraph = (inputGraph) => {
+  if (inputGraph.ports.length > 0 && "region1" in inputGraph.ports[0] && typeof inputGraph.ports[0].region1 === "object") {
+    return inputGraph;
+  }
+  const portMap = /* @__PURE__ */ new Map();
+  const regionMap = /* @__PURE__ */ new Map();
+  for (const region of inputGraph.regions) {
+    const { assignments: _, ...regionWithoutAssignments } = region;
+    regionMap.set(region.regionId, {
+      ...regionWithoutAssignments,
+      ports: [],
+      assignments: void 0
+    });
+  }
+  for (const port of inputGraph.ports) {
+    const region1 = regionMap.get(port.region1Id ?? port.region1?.regionId);
+    const region2 = regionMap.get(port.region2Id ?? port.region2?.regionId);
+    const hydratedPort = {
+      portId: port.portId,
+      region1,
+      region2,
+      d: port.d
+    };
+    portMap.set(port.portId, hydratedPort);
+    region1.ports.push(hydratedPort);
+    region2.ports.push(hydratedPort);
+  }
+  return {
+    ports: Array.from(portMap.values()),
+    regions: Array.from(regionMap.values())
+  };
+};
+
+// lib/convertSerializedConnectionsToConnections.ts
+var convertSerializedConnectionsToConnections = (inputConnections, graph) => {
+  const connections = [];
+  for (const inputConn of inputConnections) {
+    if ("startRegionId" in inputConn) {
+      connections.push({
+        connectionId: inputConn.connectionId,
+        mutuallyConnectedNetworkId: inputConn.connectionId,
+        startRegion: graph.regions.find(
+          (region) => region.regionId === inputConn.startRegionId
+        ),
+        endRegion: graph.regions.find(
+          (region) => region.regionId === inputConn.endRegionId
+        )
+      });
+    } else {
+      connections.push(inputConn);
+    }
+  }
+  return connections;
+};
+
+// lib/PriorityQueue.ts
+var PriorityQueue = class {
+  // Store the heap as an array. Index 0 is the root (highest priority/smallest 'f').
+  heap = [];
+  maxSize;
+  /**
+   * Creates a new Priority Queue.
+   * @param nodes An optional initial array of nodes to populate the queue.
+   * @param maxSize The maximum number of elements the queue can hold. Defaults to 10,000.
+   */
+  constructor(nodes = [], maxSize = 1e4) {
+    this.maxSize = maxSize;
+    if (nodes.length > 0) {
+      this.heap = [...nodes].sort((a, b) => a.f - b.f).slice(0, this.maxSize);
+      for (let i = Math.floor(this.heap.length / 2) - 1; i >= 0; i--) {
+        this._siftDown(i);
+      }
+    }
+  }
+  /**
+   * Returns the number of elements currently in the queue.
+   */
+  get size() {
+    return this.heap.length;
+  }
+  /**
+   * Checks if the queue is empty.
+   */
+  isEmpty() {
+    return this.heap.length === 0;
+  }
+  /**
+   * Returns the node with the highest priority (smallest 'f') without removing it.
+   * Returns null if the queue is empty.
+   * @returns The highest priority node or null.
+   */
+  peek() {
+    if (this.isEmpty()) {
+      return null;
+    }
+    return this.heap[0] ?? null;
+  }
+  /**
+   * Returns up to N nodes with the highest priority (smallest 'f') without removing them.
+   * Nodes are returned sorted by priority (smallest 'f' first).
+   * @param count Maximum number of nodes to return.
+   * @returns Array of nodes sorted by priority.
+   */
+  peekMany(count) {
+    return [...this.heap].sort((a, b) => a.f - b.f).slice(0, count);
+  }
+  /**
+   * Removes and returns the node with the highest priority (smallest 'f').
+   * Returns null if the queue is empty.
+   * Maintains the heap property.
+   * @returns The highest priority node or null.
+   */
+  dequeue() {
+    if (this.isEmpty()) {
+      return null;
+    }
+    const minNode = this.heap[0];
+    const lastNode = this.heap.pop();
+    if (this.heap.length === 0 && lastNode !== void 0) {
+      return minNode;
+    }
+    if (lastNode !== void 0) {
+      this.heap[0] = lastNode;
+      this._siftDown(0);
+    }
+    return minNode;
+  }
+  /**
+   * Adds a new node to the queue.
+   * Maintains the heap property.
+   * If the queue is full (at maxSize), the node is not added.
+   * @param node The node to add.
+   */
+  enqueue(node) {
+    if (this.heap.length >= this.maxSize) {
+      return;
+    }
+    this.heap.push(node);
+    this._siftUp(this.heap.length - 1);
+  }
+  // --- Private Helper Methods ---
+  /**
+   * Moves the node at the given index up the heap to maintain the heap property.
+   * @param index The index of the node to sift up.
+   */
+  _siftUp(index) {
+    let currentIndex = index;
+    while (currentIndex > 0) {
+      const parentIndex = this._parentIndex(currentIndex);
+      if (this.heap[parentIndex].f <= this.heap[currentIndex].f) {
+        break;
+      }
+      this._swap(currentIndex, parentIndex);
+      currentIndex = parentIndex;
+    }
+  }
+  /**
+   * Moves the node at the given index down the heap to maintain the heap property.
+   * @param index The index of the node to sift down.
+   */
+  _siftDown(index) {
+    let currentIndex = index;
+    const heapSize = this.heap.length;
+    while (true) {
+      const leftChildIndex = this._leftChildIndex(currentIndex);
+      const rightChildIndex = this._rightChildIndex(currentIndex);
+      let smallestIndex = currentIndex;
+      if (leftChildIndex < heapSize && this.heap[leftChildIndex].f < this.heap[smallestIndex].f) {
+        smallestIndex = leftChildIndex;
+      }
+      if (rightChildIndex < heapSize && this.heap[rightChildIndex].f < this.heap[smallestIndex].f) {
+        smallestIndex = rightChildIndex;
+      }
+      if (smallestIndex !== currentIndex) {
+        this._swap(currentIndex, smallestIndex);
+        currentIndex = smallestIndex;
+      } else {
+        break;
+      }
+    }
+  }
+  /**
+   * Swaps two elements in the heap array.
+   * @param i Index of the first element.
+   * @param j Index of the second element.
+   */
+  _swap(i, j) {
+    ;
+    [this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]];
+  }
+  /** Calculates the parent index of a node. */
+  _parentIndex(index) {
+    return Math.floor((index - 1) / 2);
+  }
+  /** Calculates the left child index of a node. */
+  _leftChildIndex(index) {
+    return 2 * index + 1;
+  }
+  /** Calculates the right child index of a node. */
+  _rightChildIndex(index) {
+    return 2 * index + 2;
+  }
+};
+
+// lib/HyperGraphSolver.ts
+var HyperGraphSolver = class extends BaseSolver {
+  constructor(input) {
+    super();
+    this.input = input;
+    this.graph = convertSerializedHyperGraphToHyperGraph(input.inputGraph);
+    for (const region of this.graph.regions) {
+      region.assignments = [];
+    }
+    this.connections = convertSerializedConnectionsToConnections(
+      input.inputConnections,
+      this.graph
+    );
+    if (input.greedyMultiplier !== void 0)
+      this.greedyMultiplier = input.greedyMultiplier;
+    if (input.rippingEnabled !== void 0)
+      this.rippingEnabled = input.rippingEnabled;
+    if (input.ripCost !== void 0) this.ripCost = input.ripCost;
+    this.unprocessedConnections = [...this.connections];
+    this.candidateQueue = new PriorityQueue();
+    this.beginNewConnection();
+  }
+  graph;
+  connections;
+  candidateQueue;
+  unprocessedConnections;
+  solvedRoutes = [];
+  currentConnection = null;
+  currentEndRegion = null;
+  greedyMultiplier = 1;
+  rippingEnabled = false;
+  ripCost = 0;
+  lastCandidate = null;
+  visitedPointsForCurrentConnection = /* @__PURE__ */ new Map();
+  computeH(candidate) {
+    return this.estimateCostToEnd(candidate.port);
+  }
+  /**
+   * OVERRIDE THIS
+   *
+   * Return the estimated remaining cost to the end of the route. You must
+   * first understand the UNIT of your costs. If it's distance, then this could
+   * be something like distance(port, this.currentEndRegion.d.center)
+   */
+  estimateCostToEnd(port) {
+    return 0;
+  }
+  /**
+   * OPTIONALLY OVERRIDE THIS
+   *
+   * This is a penalty for using a port that is not relative to a connection,
+   * e.g. maybe this port is in a special area of congestion. Use this to
+   * penalize ports that are e.g. likely to block off connections, you may want
+   * to use port.ripCount to help determine this penalty, or you can use port
+   * position, region volume etc.
+   */
+  getPortUsagePenalty(port) {
+    return 0;
+  }
+  /**
+   * OVERRIDE THIS
+   *
+   * Return the cost of using two ports in the region, make sure to consider
+   * existing assignments. You may use this to penalize intersections
+   */
+  computeIncreasedRegionCostIfPortsAreUsed(region, port1, port2) {
+    return 0;
+  }
+  /**
+   * OPTIONALLY OVERRIDE THIS
+   *
+   * Return the assignments that would need to be ripped if the given ports
+   * are used together in the region. This is used to determine if adopting
+   * a route would require ripping other routes due to problematic crossings.
+   */
+  getRipsRequiredForPortUsage(_region, _port1, _port2) {
+    return [];
+  }
+  computeG(candidate) {
+    return candidate.parent.g + this.computeIncreasedRegionCostIfPortsAreUsed(
+      candidate.lastRegion,
+      candidate.lastPort,
+      candidate.port
+    ) + (candidate.ripRequired ? this.ripCost : 0) + this.getPortUsagePenalty(candidate.port);
+  }
+  /**
+   * Return a subset of the candidates for entering a region. These candidates
+   * are all possible ways to enter the region- you can e.g. return the middle
+   * port to make it so that you're not queueing candidates that are likely
+   * redundant.
+   */
+  selectCandidatesForEnteringRegion(candidates) {
+    return candidates;
+  }
+  getNextCandidates(currentCandidate) {
+    const currentRegion = currentCandidate.nextRegion;
+    const currentPort = currentCandidate.port;
+    const nextCandidatesByRegion = {};
+    for (const port of currentRegion.ports) {
+      if (port === currentCandidate.port) continue;
+      const ripRequired = port.assignment && port.assignment.connection.mutuallyConnectedNetworkId !== this.currentConnection.mutuallyConnectedNetworkId;
+      const newCandidate = {
+        port,
+        hops: currentCandidate.hops + 1,
+        parent: currentCandidate,
+        lastRegion: currentRegion,
+        nextRegion: port.region1 === currentRegion ? port.region2 : port.region1,
+        lastPort: currentPort,
+        ripRequired
+      };
+      if (!this.rippingEnabled && newCandidate.ripRequired) {
+        continue;
+      }
+      nextCandidatesByRegion[newCandidate.nextRegion.regionId] ??= [];
+      nextCandidatesByRegion[newCandidate.nextRegion.regionId].push(
+        newCandidate
+      );
+    }
+    const nextCandidates = [];
+    for (const regionId in nextCandidatesByRegion) {
+      const nextCandidatesInRegion = nextCandidatesByRegion[regionId];
+      nextCandidates.push(
+        ...this.selectCandidatesForEnteringRegion(nextCandidatesInRegion)
+      );
+    }
+    for (const nextCandidate of nextCandidates) {
+      nextCandidate.g = this.computeG(nextCandidate);
+      nextCandidate.h = this.computeH(nextCandidate);
+      nextCandidate.f = nextCandidate.g + nextCandidate.h * this.greedyMultiplier;
+    }
+    return nextCandidates;
+  }
+  processSolvedRoute(finalCandidate) {
+    const solvedRoute = {
+      path: [],
+      connection: this.currentConnection,
+      requiredRip: false
+    };
+    let cursorCandidate = finalCandidate;
+    let anyRipsRequired = false;
+    while (cursorCandidate) {
+      anyRipsRequired ||= !!cursorCandidate.ripRequired;
+      solvedRoute.path.unshift(cursorCandidate);
+      cursorCandidate = cursorCandidate.parent;
+    }
+    const routesToRip = /* @__PURE__ */ new Set();
+    if (anyRipsRequired) {
+      solvedRoute.requiredRip = true;
+      for (const candidate of solvedRoute.path) {
+        if (candidate.port.assignment && candidate.port.assignment.connection.mutuallyConnectedNetworkId !== this.currentConnection.mutuallyConnectedNetworkId) {
+          routesToRip.add(candidate.port.assignment.solvedRoute);
+        }
+      }
+    }
+    for (const candidate of solvedRoute.path) {
+      if (!candidate.lastPort || !candidate.lastRegion) continue;
+      const ripsRequired = this.getRipsRequiredForPortUsage(
+        candidate.lastRegion,
+        candidate.lastPort,
+        candidate.port
+      );
+      for (const assignment of ripsRequired) {
+        routesToRip.add(assignment.solvedRoute);
+      }
+    }
+    if (routesToRip.size > 0) {
+      solvedRoute.requiredRip = true;
+      for (const route of routesToRip) {
+        this.ripSolvedRoute(route);
+      }
+    }
+    for (const candidate of solvedRoute.path) {
+      candidate.port.assignment = {
+        solvedRoute,
+        connection: this.currentConnection
+      };
+      if (!candidate.lastPort) continue;
+      const regionPortAssignment = {
+        regionPort1: candidate.lastPort,
+        regionPort2: candidate.port,
+        region: candidate.lastRegion,
+        connection: this.currentConnection,
+        solvedRoute
+      };
+      candidate.lastRegion.assignments?.push(regionPortAssignment);
+    }
+    this.solvedRoutes.push(solvedRoute);
+    this.routeSolvedHook(solvedRoute);
+  }
+  /**
+   * OPTIONALLY OVERRIDE THIS
+   *
+   * You can override this to perform actions after a route is solved, e.g.
+   * you may want to detect if a solvedRoute.requiredRip is true, in which
+   * case you might want to execute a "random rip" to avoid loops or check
+   * if we've exceeded a maximum number of rips.
+   *
+   * You can also use this to shuffle unprocessed routes if a rip occurred, this
+   * can also help avoid loops
+   */
+  routeSolvedHook(solvedRoute) {
+  }
+  ripSolvedRoute(solvedRoute) {
+    for (const port of solvedRoute.path.map((candidate) => candidate.port)) {
+      port.ripCount = (port.ripCount ?? 0) + 1;
+      port.region1.assignments = port.region1.assignments?.filter(
+        (a) => a.regionPort1 !== port && a.regionPort2 !== port
+      );
+      port.region2.assignments = port.region2.assignments?.filter(
+        (a) => a.regionPort1 !== port && a.regionPort2 !== port
+      );
+      port.assignment = void 0;
+    }
+    this.solvedRoutes = this.solvedRoutes.filter((r) => r !== solvedRoute);
+    this.unprocessedConnections.push(solvedRoute.connection);
+  }
+  beginNewConnection() {
+    this.currentConnection = this.unprocessedConnections.shift();
+    this.currentEndRegion = this.currentConnection.endRegion;
+    this.candidateQueue = new PriorityQueue();
+    this.visitedPointsForCurrentConnection.clear();
+    for (const port of this.currentConnection.startRegion.ports) {
+      this.candidateQueue.enqueue({
+        port,
+        g: 0,
+        h: 0,
+        f: 0,
+        hops: 0,
+        ripRequired: false,
+        nextRegion: port.region1 === this.currentConnection.startRegion ? port.region2 : port.region1
+      });
+    }
+  }
+  _step() {
+    let currentCandidate = this.candidateQueue.dequeue();
+    if (!currentCandidate) {
+      this.failed = true;
+      this.error = "Ran out of candidates";
+      return;
+    }
+    let visitedPointGScore = this.visitedPointsForCurrentConnection.get(currentCandidate.port.portId);
+    while (true) {
+      if (!currentCandidate) break;
+      if (visitedPointGScore === void 0) break;
+      if (currentCandidate.g < visitedPointGScore) break;
+      currentCandidate = this.candidateQueue.dequeue();
+      if (!currentCandidate) break;
+      visitedPointGScore = this.visitedPointsForCurrentConnection.get(
+        currentCandidate.port.portId
+      );
+    }
+    if (!currentCandidate) {
+      this.failed = true;
+      this.error = "Ran out of candidates";
+      return;
+    }
+    this.lastCandidate = currentCandidate;
+    this.visitedPointsForCurrentConnection.set(
+      currentCandidate.port.portId,
+      currentCandidate.g
+    );
+    if (currentCandidate.nextRegion === this.currentEndRegion) {
+      this.processSolvedRoute(currentCandidate);
+      if (this.unprocessedConnections.length === 0) {
+        this.solved = true;
+        return;
+      }
+      this.beginNewConnection();
+      return;
+    }
+    const nextCandidates = this.getNextCandidates(currentCandidate);
+    for (const nextCandidate of nextCandidates) {
+      this.candidateQueue.enqueue(nextCandidate);
+    }
+  }
+};
+
+// lib/JumperGraphSolver/visualizeJumperGraph.ts
+var visualizeJumperGraph = (graph, options) => {
+  const graphics = {
+    arrows: [],
+    circles: [],
+    title: "Jumper Graph",
+    lines: [],
+    points: [],
+    rects: [],
+    texts: [],
+    coordinateSystem: "cartesian"
+  };
+  for (const region of graph.regions) {
+    const { bounds, isPad, isThroughJumper, isConnectionRegion } = region.d;
+    const centerX = (bounds.minX + bounds.maxX) / 2;
+    const centerY = (bounds.minY + bounds.maxY) / 2;
+    const width = bounds.maxX - bounds.minX;
+    const height = bounds.maxY - bounds.minY;
+    let fill;
+    if (isConnectionRegion) {
+      fill = "rgba(255, 100, 255, 0.6)";
+    } else if (isThroughJumper) {
+      fill = "rgba(100, 200, 100, 0.5)";
+    } else if (isPad) {
+      fill = "rgba(255, 200, 100, 0.5)";
+    } else {
+      fill = "rgba(200, 200, 255, 0.1)";
+    }
+    graphics.rects.push({
+      center: { x: centerX, y: centerY },
+      width: width - 0.1,
+      height: height - 0.1,
+      fill
+    });
+  }
+  if (!options?.hidePortPoints) {
+    for (const port of graph.ports) {
+      const r1Name = port.region1.regionId.split(":").pop() ?? port.region1.regionId;
+      const r2Name = port.region2.regionId.split(":").pop() ?? port.region2.regionId;
+      graphics.circles.push({
+        center: { x: port.d.x, y: port.d.y },
+        radius: 0.05,
+        fill: "rgba(128, 128, 128, 0.5)",
+        label: `${r1Name}-${r2Name}`
+      });
+    }
+  }
+  if (!options?.hideRegionPortLines) {
+    for (const port of graph.ports) {
+      const r1Center = {
+        x: (port.region1.d.bounds.minX + port.region1.d.bounds.maxX) / 2,
+        y: (port.region1.d.bounds.minY + port.region1.d.bounds.maxY) / 2
+      };
+      const r2Center = {
+        x: (port.region2.d.bounds.minX + port.region2.d.bounds.maxX) / 2,
+        y: (port.region2.d.bounds.minY + port.region2.d.bounds.maxY) / 2
+      };
+      graphics.lines.push({
+        points: [r1Center, { x: port.d.x, y: port.d.y }, r2Center],
+        strokeColor: "rgba(100, 100, 100, 0.3)"
+      });
+    }
+  }
+  if (options?.connections && !options?.hideConnectionLines) {
+    for (const connection of options.connections) {
+      const startRegion = connection.startRegion;
+      const endRegion = connection.endRegion;
+      const startCenter = {
+        x: (startRegion.d.bounds.minX + startRegion.d.bounds.maxX) / 2,
+        y: (startRegion.d.bounds.minY + startRegion.d.bounds.maxY) / 2
+      };
+      const endCenter = {
+        x: (endRegion.d.bounds.minX + endRegion.d.bounds.maxX) / 2,
+        y: (endRegion.d.bounds.minY + endRegion.d.bounds.maxY) / 2
+      };
+      const midX = (startCenter.x + endCenter.x) / 2;
+      const midY = (startCenter.y + endCenter.y) / 2;
+      graphics.lines.push({
+        points: [startCenter, endCenter],
+        strokeColor: "rgba(255, 50, 150, 0.8)",
+        strokeDash: "3 3"
+      });
+      graphics.points.push({
+        x: midX,
+        y: midY,
+        color: "rgba(200, 0, 100, 1)",
+        label: connection.connectionId
+      });
+    }
+  }
+  return graphics;
+};
+
+// lib/JumperGraphSolver/visualizeJumperGraphSolver.ts
+var getConnectionColor = (connectionId, alpha = 0.8) => {
+  let hash = 0;
+  for (let i = 0; i < connectionId.length; i++) {
+    hash = connectionId.charCodeAt(i) * 17777 + ((hash << 5) - hash);
+  }
+  const hue = Math.abs(hash) % 360;
+  return `hsla(${hue}, 70%, 50%, ${alpha})`;
+};
+var visualizeJumperGraphSolver = (solver) => {
+  const jumperGraph = {
+    regions: solver.graph.regions,
+    ports: solver.graph.ports
+  };
+  const graphics = visualizeJumperGraph(jumperGraph, {
+    connections: solver.connections,
+    ...solver.iterations > 0 ? {
+      hideRegionPortLines: true,
+      hideConnectionLines: true,
+      hidePortPoints: true
+    } : {}
+  });
+  if (solver.currentConnection && !solver.solved) {
+    const connectionColor = getConnectionColor(
+      solver.currentConnection.connectionId
+    );
+    const startRegion = solver.currentConnection.startRegion;
+    const endRegion = solver.currentConnection.endRegion;
+    const startCenter = {
+      x: (startRegion.d.bounds.minX + startRegion.d.bounds.maxX) / 2,
+      y: (startRegion.d.bounds.minY + startRegion.d.bounds.maxY) / 2
+    };
+    const endCenter = {
+      x: (endRegion.d.bounds.minX + endRegion.d.bounds.maxX) / 2,
+      y: (endRegion.d.bounds.minY + endRegion.d.bounds.maxY) / 2
+    };
+    graphics.lines.push({
+      points: [startCenter, endCenter],
+      strokeColor: connectionColor,
+      strokeDash: "10 5"
+    });
+    graphics.points.push({
+      x: startCenter.x - 0.1,
+      y: startCenter.y + 0.1,
+      color: connectionColor,
+      label: [solver.currentConnection.connectionId, "start"].join("\n")
+    });
+    graphics.points.push({
+      x: endCenter.x - 0.1,
+      y: endCenter.y + 0.1,
+      color: connectionColor,
+      label: [solver.currentConnection.connectionId, "end"].join("\n")
+    });
+  }
+  for (const solvedRoute of solver.solvedRoutes) {
+    const connectionColor = getConnectionColor(
+      solvedRoute.connection.connectionId
+    );
+    const pathPoints = [];
+    for (const candidate of solvedRoute.path) {
+      const port = candidate.port;
+      pathPoints.push({ x: port.d.x, y: port.d.y });
+    }
+    if (pathPoints.length > 0) {
+      graphics.lines.push({
+        points: pathPoints,
+        strokeColor: connectionColor
+      });
+    }
+  }
+  const candidates = solver.candidateQueue.peekMany(10);
+  for (let candidateIndex = 0; candidateIndex < candidates.length; candidateIndex++) {
+    const candidate = candidates[candidateIndex];
+    const port = candidate.port;
+    const isNext = candidateIndex === 0;
+    graphics.points.push({
+      x: port.d.x,
+      y: port.d.y,
+      color: isNext ? "green" : "rgba(128, 128, 128, 0.25)",
+      label: [
+        candidate.port.portId,
+        `g: ${candidate.g.toFixed(2)}`,
+        `h: ${candidate.h.toFixed(2)}`,
+        `f: ${candidate.f.toFixed(2)}`
+      ].join("\n")
+    });
+  }
+  const nextCandidate = candidates[0];
+  if (!solver.solved && nextCandidate && solver.currentConnection) {
+    const connectionColor = getConnectionColor(
+      solver.currentConnection.connectionId
+    );
+    const activePath = [];
+    let cursor = nextCandidate;
+    while (cursor) {
+      const port = cursor.port;
+      activePath.unshift({ x: port.d.x, y: port.d.y });
+      cursor = cursor.parent;
+    }
+    if (activePath.length > 1) {
+      graphics.lines.push({
+        points: activePath,
+        strokeColor: connectionColor
+      });
+    }
+  }
+  return graphics;
+};
+
+// node_modules/@tscircuit/math-utils/dist/chunk-EFLPMB4J.js
+function distance(p1, p2) {
+  const dx = p1.x - p2.x;
+  const dy = p1.y - p2.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
+// lib/JumperGraphSolver/perimeterChordUtils.ts
+function perimeterT(p, xmin, xmax, ymin, ymax) {
+  const W = xmax - xmin;
+  const H = ymax - ymin;
+  const eps = 1e-6;
+  if (Math.abs(p.y - ymax) < eps) {
+    return p.x - xmin;
+  }
+  if (Math.abs(p.x - xmax) < eps) {
+    return W + (ymax - p.y);
+  }
+  if (Math.abs(p.y - ymin) < eps) {
+    return W + H + (xmax - p.x);
+  }
+  if (Math.abs(p.x - xmin) < eps) {
+    return 2 * W + H + (p.y - ymin);
+  }
+  const distTop = Math.abs(p.y - ymax);
+  const distRight = Math.abs(p.x - xmax);
+  const distBottom = Math.abs(p.y - ymin);
+  const distLeft = Math.abs(p.x - xmin);
+  const minDist = Math.min(distTop, distRight, distBottom, distLeft);
+  if (minDist === distTop) {
+    return Math.max(0, Math.min(W, p.x - xmin));
+  }
+  if (minDist === distRight) {
+    return W + Math.max(0, Math.min(H, ymax - p.y));
+  }
+  if (minDist === distBottom) {
+    return W + H + Math.max(0, Math.min(W, xmax - p.x));
+  }
+  return 2 * W + H + Math.max(0, Math.min(H, p.y - ymin));
+}
+function areCoincident(t1, t2, eps = 1e-6) {
+  return Math.abs(t1 - t2) < eps;
+}
+function chordsCross(chord1, chord2) {
+  const [a, b] = chord1[0] < chord1[1] ? chord1 : [chord1[1], chord1[0]];
+  const [c, d] = chord2[0] < chord2[1] ? chord2 : [chord2[1], chord2[0]];
+  if (areCoincident(a, c) || areCoincident(a, d) || areCoincident(b, c) || areCoincident(b, d)) {
+    return false;
+  }
+  return a < c && c < b && b < d || c < a && a < d && d < b;
+}
+
+// lib/JumperGraphSolver/computeDifferentNetCrossings.ts
+function computeDifferentNetCrossings(region, port1, port2) {
+  const { minX: xmin, maxX: xmax, minY: ymin, maxY: ymax } = region.d.bounds;
+  const t1 = perimeterT(port1.d, xmin, xmax, ymin, ymax);
+  const t2 = perimeterT(port2.d, xmin, xmax, ymin, ymax);
+  const newChord = [t1, t2];
+  let crossings = 0;
+  const assignments = region.assignments ?? [];
+  for (const assignment of assignments) {
+    const existingT1 = perimeterT(
+      assignment.regionPort1.d,
+      xmin,
+      xmax,
+      ymin,
+      ymax
+    );
+    const existingT2 = perimeterT(
+      assignment.regionPort2.d,
+      xmin,
+      xmax,
+      ymin,
+      ymax
+    );
+    const existingChord = [existingT1, existingT2];
+    if (chordsCross(newChord, existingChord)) {
+      crossings++;
+    }
+  }
+  return crossings;
+}
+
+// lib/JumperGraphSolver/computeCrossingAssignments.ts
+function computeCrossingAssignments(region, port1, port2) {
+  const { minX: xmin, maxX: xmax, minY: ymin, maxY: ymax } = region.d.bounds;
+  const t1 = perimeterT(port1.d, xmin, xmax, ymin, ymax);
+  const t2 = perimeterT(port2.d, xmin, xmax, ymin, ymax);
+  const newChord = [t1, t2];
+  const crossingAssignments = [];
+  const assignments = region.assignments ?? [];
+  for (const assignment of assignments) {
+    const existingT1 = perimeterT(
+      assignment.regionPort1.d,
+      xmin,
+      xmax,
+      ymin,
+      ymax
+    );
+    const existingT2 = perimeterT(
+      assignment.regionPort2.d,
+      xmin,
+      xmax,
+      ymin,
+      ymax
+    );
+    const existingChord = [existingT1, existingT2];
+    if (chordsCross(newChord, existingChord)) {
+      crossingAssignments.push(assignment);
+    }
+  }
+  return crossingAssignments;
+}
+
+// lib/JumperGraphSolver/JumperGraphSolver.ts
+var JumperGraphSolver = class extends HyperGraphSolver {
+  UNIT_OF_COST = "distance";
+  constructor(input) {
+    super({
+      ...input,
+      greedyMultiplier: 1.2,
+      rippingEnabled: true,
+      ripCost: 40
+    });
+    this.MAX_ITERATIONS = 400 + input.inputConnections.length * 200;
+  }
+  estimateCostToEnd(port) {
+    return distance(port.d, this.currentEndRegion.d.center);
+  }
+  getPortUsagePenalty(port) {
+    return port.ripCount ?? 0;
+  }
+  computeIncreasedRegionCostIfPortsAreUsed(region, port1, port2) {
+    return computeDifferentNetCrossings(region, port1, port2) * 6;
+  }
+  getRipsRequiredForPortUsage(region, port1, port2) {
+    const crossingAssignments = computeCrossingAssignments(region, port1, port2);
+    return crossingAssignments.filter(
+      (a) => a.connection.mutuallyConnectedNetworkId !== this.currentConnection.mutuallyConnectedNetworkId
+    );
+  }
+  routeSolvedHook(solvedRoute) {
+  }
+  visualize() {
+    return visualizeJumperGraphSolver(this);
+  }
+};
+export {
+  HyperGraphSolver,
+  JumperGraphSolver,
+  applyTransformToGraph,
+  createGraphWithConnectionsFromBaseGraph,
+  generateJumperGrid,
+  generateJumperX4Grid,
+  rotateGraph90Degrees
+};