@tscircuit/hypergraph 0.0.60 → 0.0.62

package/dist/index.js

@@ -1532,6 +1532,7 @@ var convertSerializedHyperGraphToHyperGraph = (inputGraph) => {
     const { assignments: _, ...regionWithoutAssignments } = region;
     regionMap.set(region.regionId, {
       ...regionWithoutAssignments,
+      d: regionWithoutAssignments.d ? structuredClone(regionWithoutAssignments.d) : regionWithoutAssignments.d,
       ports: [],
       assignments: void 0
     });
@@ -1704,28 +1705,124 @@ var PriorityQueue = class {
   }
 };
 
+// lib/solvedRoutes.ts
+var clearAssignmentsFromGraph = (graph) => {
+  for (const region of graph.regions) {
+    region.assignments = [];
+  }
+  for (const port of graph.ports) {
+    port.assignment = void 0;
+  }
+};
+var commitSolvedRoutes = ({
+  graph,
+  connections,
+  solvedRoutes
+}) => {
+  const portMap = new Map(graph.ports.map((port) => [port.portId, port]));
+  const regionMap = new Map(
+    graph.regions.map((region) => [region.regionId, region])
+  );
+  const connectionMap = new Map(
+    connections.map((connection) => [connection.connectionId, connection])
+  );
+  const committedSolvedRoutes = solvedRoutes.map((solvedRoute) => {
+    const path = [];
+    for (const originalCandidate of solvedRoute.path) {
+      const candidate = {
+        port: portMap.get(originalCandidate.port.portId),
+        g: originalCandidate.g,
+        h: originalCandidate.h,
+        f: originalCandidate.f,
+        hops: originalCandidate.hops,
+        ripRequired: originalCandidate.ripRequired
+      };
+      if (originalCandidate.lastPort) {
+        candidate.lastPort = portMap.get(originalCandidate.lastPort.portId);
+      }
+      if (originalCandidate.lastRegion) {
+        candidate.lastRegion = regionMap.get(
+          originalCandidate.lastRegion.regionId
+        );
+      }
+      if (originalCandidate.nextRegion) {
+        candidate.nextRegion = regionMap.get(
+          originalCandidate.nextRegion.regionId
+        );
+      }
+      const parent = path[path.length - 1];
+      if (parent) candidate.parent = parent;
+      path.push(candidate);
+    }
+    return {
+      path,
+      connection: connectionMap.get(solvedRoute.connection.connectionId),
+      requiredRip: solvedRoute.requiredRip
+    };
+  });
+  clearAssignmentsFromGraph(graph);
+  graph.solvedRoutes = committedSolvedRoutes;
+  for (const solvedRoute of committedSolvedRoutes) {
+    for (const candidate of solvedRoute.path) {
+      candidate.port.assignment = {
+        solvedRoute,
+        connection: solvedRoute.connection
+      };
+      if (!candidate.lastPort || !candidate.lastRegion) continue;
+      const regionPortAssignment = {
+        regionPort1: candidate.lastPort,
+        regionPort2: candidate.port,
+        region: candidate.lastRegion,
+        connection: solvedRoute.connection,
+        solvedRoute
+      };
+      candidate.lastRegion.assignments ??= [];
+      candidate.lastRegion.assignments.push(regionPortAssignment);
+    }
+  }
+  return committedSolvedRoutes;
+};
+
 // lib/HyperGraphSolver.ts
 var HyperGraphSolver = class extends BaseSolver {
   constructor(input) {
     super();
     this.input = input;
     this.graph = convertSerializedHyperGraphToHyperGraph(input.inputGraph);
-    this.graph.solvedRoutes = this.solvedRoutes;
-    for (const region of this.graph.regions) {
-      region.assignments = [];
-    }
+    clearAssignmentsFromGraph(this.graph);
     this.connections = convertSerializedConnectionsToConnections(
       input.inputConnections,
       this.graph
     );
+    if (input.inputSolvedRoutes) {
+      this.solvedRoutes = commitSolvedRoutes({
+        graph: this.graph,
+        connections: this.connections,
+        solvedRoutes: input.inputSolvedRoutes
+      });
+    } else {
+      ;
+      this.graph.solvedRoutes = this.solvedRoutes;
+    }
     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];
+    const preSolvedConnectionIds = new Set(
+      this.solvedRoutes.map(
+        (solvedRoute) => solvedRoute.connection.connectionId
+      )
+    );
+    this.unprocessedConnections = this.connections.filter(
+      (connection) => !preSolvedConnectionIds.has(connection.connectionId)
+    );
     this.candidateQueue = new PriorityQueue();
-    this.beginNewConnection();
+    if (this.unprocessedConnections.length === 0) {
+      this.solved = true;
+    } else {
+      this.beginNewConnection();
+    }
   }
   getSolverName() {
     return "HyperGraphSolver";
@@ -1750,9 +1847,13 @@ var HyperGraphSolver = class extends BaseSolver {
       ),
       greedyMultiplier: this.greedyMultiplier,
       rippingEnabled: this.rippingEnabled,
-      ripCost: this.ripCost
+      ripCost: this.ripCost,
+      inputSolvedRoutes: this.solvedRoutes
     };
   }
+  getOutput() {
+    return this.solvedRoutes;
+  }
   computeH(candidate) {
     return this.estimateCostToEnd(candidate.port);
   }
@@ -2064,197 +2165,8 @@ var HyperGraphSolver = class extends BaseSolver {
   }
 };
 
-// node_modules/transformation-matrix/src/applyToPoint.js
-function applyToPoint(matrix2, point2) {
-  return Array.isArray(point2) ? [
-    matrix2.a * point2[0] + matrix2.c * point2[1] + matrix2.e,
-    matrix2.b * point2[0] + matrix2.d * point2[1] + matrix2.f
-  ] : {
-    x: matrix2.a * point2.x + matrix2.c * point2.y + matrix2.e,
-    y: matrix2.b * point2.x + matrix2.d * point2.y + matrix2.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/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 };
-};
-
-// lib/JumperGraphSolver/geometry/getBoundsCenter.ts
-var computeBoundsCenter = (bounds) => {
-  return {
-    x: (bounds.minX + bounds.maxX) / 2,
-    y: (bounds.minY + bounds.maxY) / 2
-  };
-};
-
-// lib/JumperGraphSolver/geometry/applyTransformToGraph.ts
-var applyTransformToGraph = (graph, matrix2) => {
-  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(matrix2, 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(matrix2, 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(matrix2, 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;
-  });
-  const transformedJumperLocations = graph.jumperLocations?.map((loc) => {
-    const newCenter = applyToPoint(matrix2, loc.center);
-    const newPadRegions = loc.padRegions.map(
-      (region) => regionMap.get(region)
-    );
-    const unitX = applyToPoint(matrix2, { x: 1, y: 0 });
-    const origin = applyToPoint(matrix2, { x: 0, y: 0 });
-    const dx = unitX.x - origin.x;
-    const dy = unitX.y - origin.y;
-    const isRotated90 = Math.abs(dy) > Math.abs(dx);
-    const newOrientation = isRotated90 ? loc.orientation === "horizontal" ? "vertical" : "horizontal" : loc.orientation;
-    return {
-      center: newCenter,
-      orientation: newOrientation,
-      padRegions: newPadRegions
-    };
-  });
-  return {
-    regions: transformedRegions,
-    ports: transformedPorts,
-    ...transformedJumperLocations && {
-      jumperLocations: transformedJumperLocations
-    }
-  };
-};
-var rotateGraph90Degrees = (graph) => {
-  const bounds = calculateGraphBounds(graph.regions);
-  const center = computeBoundsCenter(bounds);
-  const matrix2 = compose(
-    translate(center.x, center.y),
-    rotate(-Math.PI / 2),
-    // -90 degrees (clockwise)
-    translate(-center.x, -center.y)
-  );
-  return applyTransformToGraph(graph, matrix2);
-};
+// lib/HyperGraphSectionOptimizer/HyperGraphSectionOptimizer.ts
+import { BaseSolver as BaseSolver2 } from "@tscircuit/solver-utils";
 
 // lib/JumperGraphSolver/perimeterChordUtils.ts
 function clamp2(value, min, max) {
@@ -2415,24 +2327,1119 @@ function chordsCross(chord1, chord2, perimeter) {
   return a < c && c < b && b < d || c < a && a < d && d < b;
 }
 
-// lib/JumperGraphSolver/computeCrossingAssignments.ts
-function computeCrossingAssignments(region, port1, port2) {
-  const perimeter = getRegionPerimeter(region);
-  const t1 = getPortPerimeterTInRegion(port1, region);
-  const t2 = getPortPerimeterTInRegion(port2, region);
-  const newChord = [t1, t2];
-  const crossingAssignments = [];
-  const assignments = region.assignments ?? [];
-  for (const assignment of assignments) {
-    const existingT1 = getPortPerimeterTInRegion(
-      assignment.regionPort1,
-      region
-    );
-    const existingT2 = getPortPerimeterTInRegion(
-      assignment.regionPort2,
-      region
-    );
-    const existingChord = [existingT1, existingT2];
+// 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 };
+};
+
+// 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 EPS = 0.01;
+var clamp3 = (value, min, max) => {
+  return Math.max(min, Math.min(max, value));
+};
+var getBoundarySidesForPoint = (x, y, graphBounds) => {
+  const sides = [];
+  if (Math.abs(x - graphBounds.minX) < EPS) sides.push("left");
+  if (Math.abs(x - graphBounds.maxX) < EPS) sides.push("right");
+  if (Math.abs(y - graphBounds.maxY) < EPS) sides.push("top");
+  if (Math.abs(y - graphBounds.minY) < EPS) sides.push("bottom");
+  return sides;
+};
+var isPointOnSide = (p, side, b) => {
+  if (side === "left") return Math.abs(p.x - b.minX) < EPS;
+  if (side === "right") return Math.abs(p.x - b.maxX) < EPS;
+  if (side === "top") return Math.abs(p.y - b.maxY) < EPS;
+  return Math.abs(p.y - b.minY) < EPS;
+};
+var projectToSegment2 = (x, y, a, b) => {
+  const abx = b.x - a.x;
+  const aby = b.y - a.y;
+  const apx = x - a.x;
+  const apy = y - a.y;
+  const ab2 = abx * abx + aby * aby;
+  const t = ab2 > 0 ? clamp3((apx * abx + apy * aby) / ab2, 0, 1) : 0;
+  const px = a.x + t * abx;
+  const py = a.y + t * aby;
+  const dx = x - px;
+  const dy = y - py;
+  return {
+    x: px,
+    y: py,
+    d2: dx * dx + dy * dy
+  };
+};
+var getRegionBoundaryProjection = (x, y, region, graphBounds, preferredSides) => {
+  const polygon2 = region.d.polygon;
+  if (polygon2 && polygon2.length >= 3) {
+    const sideSet = new Set(preferredSides);
+    let best2 = null;
+    for (let i = 0; i < polygon2.length; i++) {
+      const a = polygon2[i];
+      const b = polygon2[(i + 1) % polygon2.length];
+      if (preferredSides.length > 0) {
+        const edgeOnPreferredSide = preferredSides.some(
+          (side) => isPointOnSide(a, side, graphBounds) && isPointOnSide(b, side, graphBounds) && sideSet.has(side)
+        );
+        if (!edgeOnPreferredSide) continue;
+      }
+      const p = projectToSegment2(x, y, a, b);
+      if (!best2 || p.d2 < best2.d2) {
+        best2 = p;
+      }
+    }
+    if (best2) return best2;
+  }
+  const bounds = region.d.bounds;
+  const sideCandidates = [];
+  if (preferredSides.length > 0) {
+    for (const side of preferredSides) {
+      if (side === "left") {
+        sideCandidates.push({
+          side,
+          x: bounds.minX,
+          y: clamp3(y, bounds.minY, bounds.maxY)
+        });
+      } else if (side === "right") {
+        sideCandidates.push({
+          side,
+          x: bounds.maxX,
+          y: clamp3(y, bounds.minY, bounds.maxY)
+        });
+      } else if (side === "top") {
+        sideCandidates.push({
+          side,
+          x: clamp3(x, bounds.minX, bounds.maxX),
+          y: bounds.maxY
+        });
+      } else {
+        sideCandidates.push({
+          side,
+          x: clamp3(x, bounds.minX, bounds.maxX),
+          y: bounds.minY
+        });
+      }
+    }
+  }
+  if (sideCandidates.length === 0) {
+    sideCandidates.push(
+      { side: "left", x: bounds.minX, y: clamp3(y, bounds.minY, bounds.maxY) },
+      {
+        side: "right",
+        x: bounds.maxX,
+        y: clamp3(y, bounds.minY, bounds.maxY)
+      },
+      { side: "top", x: clamp3(x, bounds.minX, bounds.maxX), y: bounds.maxY },
+      {
+        side: "bottom",
+        x: clamp3(x, bounds.minX, bounds.maxX),
+        y: bounds.minY
+      }
+    );
+  }
+  let best = null;
+  for (const c of sideCandidates) {
+    if (preferredSides.length > 0 && !preferredSides.includes(c.side)) continue;
+    const dx = x - c.x;
+    const dy = y - c.y;
+    const d2 = dx * dx + dy * dy;
+    if (!best || d2 < best.d2) {
+      best = { x: c.x, y: c.y, d2 };
+    }
+  }
+  return best;
+};
+var findBoundaryRegion = (x, y, regions, graphBounds) => {
+  const preferredSides = getBoundarySidesForPoint(x, y, graphBounds);
+  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 projection = getRegionBoundaryProjection(
+      x,
+      y,
+      region,
+      graphBounds,
+      preferredSides
+    );
+    if (!projection) continue;
+    const dist = Math.sqrt(projection.d2);
+    if (dist < closestDistance) {
+      closestDistance = dist;
+      closestRegion = region;
+      closestPortPosition = { x: projection.x, y: projection.y };
+    }
+  }
+  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/JumperGraphSolver/jumper-graph-generator/createProblemFromBaseGraph.ts
+var createSeededRandom = (seed) => {
+  let state = seed;
+  return () => {
+    state = state * 1664525 + 1013904223 >>> 0;
+    return state / 4294967295;
+  };
+};
+
+// lib/HyperGraphSectionOptimizer/routes/previewSectionReplacement.ts
+var previewSectionReplacement = (input) => {
+  const { solvedRoutes, section, replacementSolvedRoutes } = input;
+  const replacementByConnectionId = new Map(
+    replacementSolvedRoutes.map((route) => [
+      route.connection.connectionId,
+      route
+    ])
+  );
+  return solvedRoutes.map((solvedRoute) => {
+    const sectionRoute = section.sectionRoutes.find(
+      (route) => route.globalConnection.connectionId === solvedRoute.connection.connectionId
+    );
+    if (!sectionRoute) return solvedRoute;
+    const replacementSolvedRoute = replacementByConnectionId.get(
+      solvedRoute.connection.connectionId
+    );
+    if (!replacementSolvedRoute) return solvedRoute;
+    const path = [
+      ...solvedRoute.path.slice(0, sectionRoute.sectionStartIndex),
+      ...replacementSolvedRoute.path,
+      ...solvedRoute.path.slice(sectionRoute.sectionEndIndex + 1)
+    ];
+    const copiedPath = path.map((candidate) => ({
+      port: candidate.port,
+      g: candidate.g,
+      h: candidate.h,
+      f: candidate.f,
+      hops: candidate.hops,
+      ripRequired: candidate.ripRequired,
+      lastPort: candidate.lastPort,
+      lastRegion: candidate.lastRegion,
+      nextRegion: candidate.nextRegion
+    }));
+    for (let i = 0; i < copiedPath.length; i++) {
+      copiedPath[i].parent = i > 0 ? copiedPath[i - 1] : void 0;
+    }
+    return {
+      connection: solvedRoute.connection,
+      path: copiedPath,
+      requiredRip: solvedRoute.requiredRip || replacementSolvedRoute.requiredRip
+    };
+  });
+};
+
+// lib/HyperGraphSectionOptimizer/getOrCreateBoundaryRegion.ts
+var getOrCreateBoundaryRegion = ({
+  port,
+  boundaryRegionMap
+}) => {
+  let boundaryRegion = boundaryRegionMap.get(port.portId);
+  if (!boundaryRegion) {
+    const x = typeof port.d?.x === "number" ? port.d.x : 0;
+    const y = typeof port.d?.y === "number" ? port.d.y : 0;
+    boundaryRegion = {
+      regionId: `__section_boundary__${port.portId}`,
+      ports: [],
+      d: {
+        isBoundaryRegion: true,
+        boundaryPortId: port.portId,
+        isPad: false,
+        isThroughJumper: false,
+        isConnectionRegion: true,
+        center: { x, y },
+        bounds: {
+          minX: x - 0.05,
+          maxX: x + 0.05,
+          minY: y - 0.05,
+          maxY: y + 0.05
+        }
+      },
+      assignments: []
+    };
+    boundaryRegionMap.set(port.portId, boundaryRegion);
+  }
+  return boundaryRegion;
+};
+
+// lib/HyperGraphSectionOptimizer/routes/sliceSolvedRouteIntoLocalSection.ts
+var sliceSolvedRouteIntoLocalSection = (input) => {
+  const { sectionRoute, graph } = input;
+  const localPortIds = new Set(graph.ports.map((port) => port.portId));
+  const originalLocalPath = sectionRoute.globalRoute.path.slice(sectionRoute.sectionStartIndex, sectionRoute.sectionEndIndex + 1).filter((candidate) => localPortIds.has(candidate.port.portId));
+  const path = [];
+  let currentRegion = sectionRoute.sectionConnection.startRegion;
+  for (let index = 0; index < originalLocalPath.length; index++) {
+    const originalCandidate = originalLocalPath[index];
+    const port = graph.ports.find(
+      (candidatePort) => candidatePort.portId === originalCandidate.port.portId
+    );
+    const nextRegion = port.region1 === currentRegion ? port.region2 : port.region1;
+    path.push({
+      port,
+      g: originalCandidate.g,
+      h: originalCandidate.h,
+      f: originalCandidate.f,
+      hops: index,
+      ripRequired: originalCandidate.ripRequired,
+      parent: index > 0 ? path[index - 1] : void 0,
+      lastPort: index > 0 ? path[index - 1].port : void 0,
+      lastRegion: index > 0 ? currentRegion : void 0,
+      nextRegion
+    });
+    currentRegion = nextRegion;
+  }
+  return {
+    connection: sectionRoute.sectionConnection,
+    path,
+    requiredRip: sectionRoute.globalRoute.requiredRip
+  };
+};
+
+// lib/HyperGraphSectionOptimizer/sections/getRouteSectionSpan.ts
+var getRouteSectionSpan = (route, sectionRegionIds) => {
+  let startIndex = -1;
+  let endIndex = -1;
+  for (let i = 0; i < route.path.length; i++) {
+    const candidate = route.path[i];
+    const touchesSection = candidate.lastRegion && sectionRegionIds.has(candidate.lastRegion.regionId) || candidate.nextRegion && sectionRegionIds.has(candidate.nextRegion.regionId);
+    if (!touchesSection) continue;
+    if (startIndex === -1) startIndex = i;
+    endIndex = i;
+  }
+  if (startIndex === -1) return null;
+  return { startIndex, endIndex };
+};
+
+// lib/HyperGraphSectionOptimizer/sections/getSectionRegionIds.ts
+var getSectionRegionIds = ({
+  centralRegion,
+  expansionHopsFromCentralRegion
+}) => {
+  const sectionRegionIds = /* @__PURE__ */ new Set([centralRegion.regionId]);
+  const queue = [
+    { region: centralRegion, hops: 0 }
+  ];
+  while (queue.length > 0) {
+    const { region, hops } = queue.shift();
+    if (hops >= expansionHopsFromCentralRegion + 1) continue;
+    for (const port of region.ports) {
+      const nextRegion = port.region1 === region ? port.region2 : port.region1;
+      if (sectionRegionIds.has(nextRegion.regionId)) continue;
+      sectionRegionIds.add(nextRegion.regionId);
+      queue.push({ region: nextRegion, hops: hops + 1 });
+    }
+  }
+  return sectionRegionIds;
+};
+
+// lib/HyperGraphSectionOptimizer/sections/getSectionOfHyperGraphAsHyperGraph.ts
+var getSectionOfHyperGraphAsHyperGraph = (input) => {
+  const { graph, solvedRoutes, centralRegion, expansionHopsFromCentralRegion } = input;
+  const sectionRegionIds = getSectionRegionIds({
+    graph,
+    centralRegion,
+    expansionHopsFromCentralRegion
+  });
+  const clonedRegionMap = /* @__PURE__ */ new Map();
+  const boundaryRegionMap = /* @__PURE__ */ new Map();
+  const clonedPorts = [];
+  for (const region of graph.regions) {
+    if (!sectionRegionIds.has(region.regionId)) continue;
+    clonedRegionMap.set(region.regionId, {
+      regionId: region.regionId,
+      ports: [],
+      d: region.d ? structuredClone(region.d) : region.d,
+      assignments: []
+    });
+  }
+  for (const port of graph.ports) {
+    const region1InSection = sectionRegionIds.has(port.region1.regionId);
+    const region2InSection = sectionRegionIds.has(port.region2.regionId);
+    if (!region1InSection && !region2InSection) continue;
+    if (region1InSection && region2InSection) {
+      const clonedPort2 = {
+        portId: port.portId,
+        region1: clonedRegionMap.get(port.region1.regionId),
+        region2: clonedRegionMap.get(port.region2.regionId),
+        d: port.d
+      };
+      clonedPort2.region1.ports.push(clonedPort2);
+      clonedPort2.region2.ports.push(clonedPort2);
+      clonedPorts.push(clonedPort2);
+      continue;
+    }
+    const insideRegion = region1InSection ? port.region1 : port.region2;
+    const boundaryRegion = getOrCreateBoundaryRegion({
+      port,
+      boundaryRegionMap
+    });
+    const clonedPort = {
+      portId: port.portId,
+      region1: clonedRegionMap.get(insideRegion.regionId),
+      region2: boundaryRegion,
+      d: port.d
+    };
+    clonedPort.region1.ports.push(clonedPort);
+    clonedPort.region2.ports.push(clonedPort);
+    clonedPorts.push(clonedPort);
+  }
+  const sectionGraph = {
+    regions: [...clonedRegionMap.values(), ...boundaryRegionMap.values()],
+    ports: clonedPorts
+  };
+  const sectionRoutes = [];
+  const sectionConnections = [];
+  const sectionRegionMap = new Map(
+    sectionGraph.regions.map((region) => [region.regionId, region])
+  );
+  for (const solvedRoute of solvedRoutes) {
+    const span = getRouteSectionSpan(solvedRoute, sectionRegionIds);
+    if (!span) continue;
+    const startCandidate = solvedRoute.path[span.startIndex];
+    const endCandidate = solvedRoute.path[span.endIndex];
+    let startRegionId;
+    let startRegion;
+    if (sectionRegionIds.has(solvedRoute.connection.startRegion.regionId)) {
+      startRegionId = solvedRoute.connection.startRegion.regionId;
+      startRegion = sectionRegionMap.get(startRegionId);
+    } else {
+      const boundaryRegion = getOrCreateBoundaryRegion({
+        port: startCandidate.port,
+        boundaryRegionMap
+      });
+      startRegionId = boundaryRegion.regionId;
+      startRegion = boundaryRegion;
+      if (!sectionRegionMap.has(startRegionId)) {
+        sectionRegionMap.set(startRegionId, boundaryRegion);
+      }
+    }
+    let endRegionId;
+    let endRegion;
+    if (sectionRegionIds.has(solvedRoute.connection.endRegion.regionId)) {
+      endRegionId = solvedRoute.connection.endRegion.regionId;
+      endRegion = sectionRegionMap.get(endRegionId);
+    } else {
+      const boundaryRegion = getOrCreateBoundaryRegion({
+        port: endCandidate.port,
+        boundaryRegionMap
+      });
+      endRegionId = boundaryRegion.regionId;
+      endRegion = boundaryRegion;
+      if (!sectionRegionMap.has(endRegionId)) {
+        sectionRegionMap.set(endRegionId, boundaryRegion);
+      }
+    }
+    if (!startRegion) {
+      console.error(
+        `[getSectionOfHyperGraphAsHyperGraph] CRITICAL ERROR: startRegion not found!`
+      );
+      console.error(`  Looking for: ${startRegionId}`);
+      console.error(
+        `  Route connection: ${solvedRoute.connection.connectionId}`
+      );
+      console.error(
+        `  Original startRegion: ${solvedRoute.connection.startRegion.regionId}`
+      );
+      console.error(`  startCandidate port: ${startCandidate.port.portId}`);
+      console.error(
+        `  Available regions in sectionRegionMap:`,
+        Array.from(sectionRegionMap.keys())
+      );
+      throw new Error(
+        `startRegion ${startRegionId} not found in sectionRegionMap`
+      );
+    }
+    if (!endRegion) {
+      console.error(
+        `[getSectionOfHyperGraphAsHyperGraph] CRITICAL ERROR: endRegion not found!`
+      );
+      console.error(`  Looking for: ${endRegionId}`);
+      console.error(
+        `  Route connection: ${solvedRoute.connection.connectionId}`
+      );
+      console.error(
+        `  Original endRegion: ${solvedRoute.connection.endRegion.regionId}`
+      );
+      console.error(`  endCandidate port: ${endCandidate.port.portId}`);
+      console.error(
+        `  Available regions in sectionRegionMap:`,
+        Array.from(sectionRegionMap.keys())
+      );
+      throw new Error(`endRegion ${endRegionId} not found in sectionRegionMap`);
+    }
+    const sectionConnection = {
+      connectionId: solvedRoute.connection.connectionId,
+      mutuallyConnectedNetworkId: solvedRoute.connection.mutuallyConnectedNetworkId,
+      startRegion,
+      endRegion
+    };
+    const rawPath = solvedRoute.path.slice(span.startIndex, span.endIndex + 1);
+    const sectionRouteBase = {
+      globalRoute: solvedRoute,
+      globalConnection: solvedRoute.connection,
+      sectionConnection,
+      sectionStartIndex: span.startIndex,
+      sectionEndIndex: span.endIndex
+    };
+    sectionRoutes.push({
+      ...sectionRouteBase,
+      canRemainFixedInSectionSolve: rawPath.every(
+        (candidate) => sectionGraph.ports.some(
+          (port) => port.portId === candidate.port.portId
+        )
+      ),
+      sectionRoute: sliceSolvedRouteIntoLocalSection({
+        sectionRoute: sectionRouteBase,
+        graph: sectionGraph
+      })
+    });
+    sectionConnections.push(sectionConnection);
+  }
+  return {
+    centralRegionId: centralRegion.regionId,
+    sectionRegionIds,
+    graph: sectionGraph,
+    connections: sectionConnections,
+    sectionRoutes
+  };
+};
+
+// lib/HyperGraphSectionOptimizer/HyperGraphSectionOptimizer.ts
+var HyperGraphSectionOptimizer = class extends BaseSolver2 {
+  constructor(input) {
+    super();
+    this.input = input;
+    this.graph = input.hyperGraphSolver.graph;
+    const initialSolvedRoutes = input.inputSolvedRoutes;
+    const inputConnections = input.hyperGraphSolver.connections;
+    this.connections = inputConnections;
+    this.solvedRoutes = commitSolvedRoutes({
+      graph: this.graph,
+      connections: this.connections,
+      solvedRoutes: initialSolvedRoutes
+    });
+    this.maxAttemptsPerRegion = input.MAX_ATTEMPTS_PER_REGION;
+    this.maxSectionAttempts = input.MAX_ATTEMPTS_PER_SECTION ?? 500;
+    this.iterations += this.iterations * (input.effort ?? 1);
+    this.fractionToReplace = input.FRACTION_TO_REPLACE ?? 0.2;
+    this.alwaysRipConflicts = input.alwaysRipConflicts ?? true;
+  }
+  graph;
+  connections;
+  solvedRoutes;
+  activeSection = null;
+  baselineSectionCost = Infinity;
+  baselineGlobalCost = Infinity;
+  regionAttemptCounts = /* @__PURE__ */ new Map();
+  sectionAttempts = 0;
+  maxAttemptsPerRegion;
+  maxSectionAttempts;
+  fractionToReplace;
+  alwaysRipConflicts;
+  random = createSeededRandom(31337);
+  getSolverName() {
+    return "HyperGraphSectionOptimizer";
+  }
+  getConstructorParams() {
+    return {
+      inputGraph: convertHyperGraphToSerializedHyperGraph(this.graph),
+      inputConnections: convertConnectionsToSerializedConnections(
+        this.connections
+      ),
+      inputSolvedRoutes: this.solvedRoutes,
+      expansionHopsFromCentralRegion: this.input.expansionHopsFromCentralRegion,
+      maxAttemptsPerRegion: this.maxAttemptsPerRegion,
+      maxSectionAttempts: this.maxSectionAttempts,
+      effort: this.input.effort,
+      fractionToReplace: this.fractionToReplace,
+      alwaysRipConflicts: this.alwaysRipConflicts,
+      ACCEPTABLE_COST: this.input.ACCEPTABLE_REGION_COST
+    };
+  }
+  getOutput() {
+    return this.solvedRoutes;
+  }
+  _setup() {
+    this.beginSectionSolve();
+  }
+  visualize() {
+    if (this.activeSubSolver) {
+      return this.activeSubSolver.visualize();
+    }
+    return {
+      title: "HyperGraphSectionOptimizer",
+      points: [],
+      lines: [],
+      rects: [],
+      circles: [],
+      texts: [],
+      polygons: [],
+      arrows: []
+    };
+  }
+  getCostOfRegionWithAttempts(region) {
+    const attempts = this.regionAttemptCounts.get(region.regionId) ?? 0;
+    return this.input.regionCost(region) + attempts * 1e4;
+  }
+  computeCostOfSection({
+    section,
+    solvedRoutes
+  }) {
+    if (this.input.computeSolvedGraphCost) {
+      return this.input.computeSolvedGraphCost(solvedRoutes);
+    }
+    const solver = this.input.createHyperGraphSolver({
+      inputGraph: section.graph,
+      inputConnections: section.connections,
+      inputSolvedRoutes: solvedRoutes
+    });
+    let totalCost = 0;
+    for (const region of solver.graph.regions) {
+      totalCost += this.input.regionCost(region);
+    }
+    return totalCost;
+  }
+  computeSolvedGraphCost(solvedRoutes) {
+    if (this.input.computeSolvedGraphCost) {
+      return this.input.computeSolvedGraphCost(solvedRoutes);
+    }
+    const solver = this.input.createHyperGraphSolver({
+      inputGraph: this.graph,
+      inputConnections: this.connections,
+      inputSolvedRoutes: solvedRoutes
+    });
+    let totalCost = 0;
+    for (const region of solver.graph.regions) {
+      totalCost += this.input.regionCost(region);
+    }
+    return totalCost;
+  }
+  /**
+   * TODO default behavior should be to rip entire section
+   */
+  determineConnectionsToRip(section, evaluationSolver) {
+    const allConnectionIds = section.sectionRoutes.map(
+      (route) => route.globalConnection.connectionId
+    );
+    if (this.fractionToReplace >= 1) {
+      return new Set(allConnectionIds);
+    }
+    const shuffledConnectionIds = [...allConnectionIds];
+    for (let index = shuffledConnectionIds.length - 1; index > 0; index--) {
+      const swapIndex = Math.floor(this.random() * (index + 1));
+      [shuffledConnectionIds[index], shuffledConnectionIds[swapIndex]] = [
+        shuffledConnectionIds[swapIndex],
+        shuffledConnectionIds[index]
+      ];
+    }
+    const ripCount = Math.max(
+      1,
+      Math.ceil(shuffledConnectionIds.length * this.fractionToReplace)
+    );
+    const connectionsToReroute = new Set(
+      shuffledConnectionIds.slice(0, ripCount)
+    );
+    if (!this.alwaysRipConflicts) {
+      return connectionsToReroute;
+    }
+    const localRegionMap = new Map(
+      section.graph.regions.map((region) => [region.regionId, region])
+    );
+    for (const route of section.sectionRoutes) {
+      for (const candidate of route.sectionRoute.path) {
+        if (!candidate.lastPort || !candidate.lastRegion) continue;
+        const sectionRegion = localRegionMap.get(candidate.lastRegion.regionId);
+        if (!sectionRegion) continue;
+        evaluationSolver.currentConnection = route.globalConnection;
+        const conflictingAssignments = evaluationSolver.getRipsRequiredForPortUsage(
+          sectionRegion,
+          candidate.lastPort,
+          candidate.port
+        );
+        for (const conflict of conflictingAssignments) {
+          const firstId = route.globalConnection.connectionId;
+          const secondId = conflict.connection.connectionId;
+          if (connectionsToReroute.has(firstId) || connectionsToReroute.has(secondId)) {
+            continue;
+          }
+          connectionsToReroute.add(this.random() < 0.5 ? firstId : secondId);
+        }
+      }
+    }
+    return connectionsToReroute;
+  }
+  getNextCentralRegion() {
+    let bestRegion = null;
+    let bestCost = Infinity;
+    for (const region of this.graph.regions) {
+      if ((region.assignments?.length ?? 0) === 0) continue;
+      if ((this.regionAttemptCounts.get(region.regionId) ?? 0) >= this.maxAttemptsPerRegion) {
+        continue;
+      }
+      const regionCost = this.input.regionCost(region);
+      if (regionCost < this.input.ACCEPTABLE_REGION_COST) continue;
+      const cost = this.getCostOfRegionWithAttempts(region);
+      if (cost >= bestCost) continue;
+      bestCost = cost;
+      bestRegion = region;
+    }
+    return bestRegion;
+  }
+  beginSectionSolve() {
+    if (this.sectionAttempts >= this.maxSectionAttempts) {
+      console.log(
+        `Reached max section attempts (${this.maxSectionAttempts}), stopping optimization`
+      );
+      this.solved = true;
+      return;
+    }
+    const centralRegion = this.getNextCentralRegion();
+    if (!centralRegion) {
+      this.solved = true;
+      return;
+    }
+    this.sectionAttempts++;
+    this.activeSection = getSectionOfHyperGraphAsHyperGraph({
+      graph: this.graph,
+      solvedRoutes: this.solvedRoutes,
+      centralRegion,
+      expansionHopsFromCentralRegion: this.input.expansionHopsFromCentralRegion
+    });
+    if (!this.activeSection) {
+      return;
+    }
+    if (this.activeSection.connections.length === 0) {
+      this.regionAttemptCounts.set(
+        centralRegion.regionId,
+        (this.regionAttemptCounts.get(centralRegion.regionId) ?? 0) + 1
+      );
+      this.activeSection = null;
+      return;
+    }
+    const fixedSectionRoutes = this.activeSection.sectionRoutes.filter(
+      (route) => route.canRemainFixedInSectionSolve
+    );
+    const baselineSolver = this.input.createHyperGraphSolver({
+      inputGraph: this.activeSection.graph,
+      inputConnections: this.activeSection.connections,
+      inputSolvedRoutes: fixedSectionRoutes.map((route) => route.sectionRoute)
+    });
+    const connectionsToReroute = this.determineConnectionsToRip(
+      this.activeSection,
+      baselineSolver
+    );
+    for (const route of this.activeSection.sectionRoutes) {
+      if (!route.canRemainFixedInSectionSolve) {
+        connectionsToReroute.add(route.globalConnection.connectionId);
+      }
+    }
+    const remainingSectionRoutes = this.activeSection.sectionRoutes.filter(
+      (route) => route.canRemainFixedInSectionSolve && !connectionsToReroute.has(route.globalConnection.connectionId)
+    );
+    const fixedSectionSolvedRoutes = remainingSectionRoutes.map(
+      (route) => route.sectionRoute
+    );
+    const baselineSectionSolvedRoutes = [
+      ...fixedSectionSolvedRoutes,
+      ...this.activeSection.sectionRoutes.filter(
+        (route) => connectionsToReroute.has(route.globalConnection.connectionId)
+      ).map((route) => route.sectionRoute)
+    ];
+    this.baselineSectionCost = this.computeCostOfSection({
+      section: this.activeSection,
+      solvedRoutes: baselineSectionSolvedRoutes
+    });
+    this.baselineGlobalCost = this.computeSolvedGraphCost(this.solvedRoutes);
+    this.activeSubSolver = this.input.createHyperGraphSolver({
+      inputGraph: this.activeSection.graph,
+      inputConnections: this.activeSection.connections,
+      inputSolvedRoutes: fixedSectionSolvedRoutes
+    });
+    for (const conn of this.activeSubSolver.connections) {
+      if (!conn.startRegion || !conn.endRegion) {
+        console.error({
+          startRegion: conn.startRegion?.regionId,
+          endRegion: conn.endRegion?.regionId
+        });
+      }
+    }
+  }
+  _step() {
+    if (!this.activeSubSolver) {
+      this.beginSectionSolve();
+      return;
+    }
+    this.activeSubSolver.step();
+    if (!this.activeSection) {
+      return;
+    }
+    if (this.activeSubSolver.failed) {
+      this.failedSubSolvers ??= [];
+      this.failedSubSolvers.push(this.activeSubSolver);
+      const attempts = this.regionAttemptCounts.get(this.activeSection.centralRegionId) ?? 0;
+      this.regionAttemptCounts.set(
+        this.activeSection.centralRegionId,
+        attempts + 1
+      );
+      this.activeSubSolver = null;
+      this.activeSection = null;
+      this.baselineSectionCost = Infinity;
+      this.baselineGlobalCost = Infinity;
+      return;
+    }
+    if (!this.activeSubSolver.solved) return;
+    const candidateSectionSolvedRoutes = this.activeSubSolver.solvedRoutes;
+    const candidateCost = this.computeCostOfSection({
+      section: this.activeSection,
+      solvedRoutes: candidateSectionSolvedRoutes
+    });
+    const replacementAppliedSolvedRoutes = previewSectionReplacement({
+      solvedRoutes: this.solvedRoutes,
+      section: this.activeSection,
+      replacementSolvedRoutes: candidateSectionSolvedRoutes
+    });
+    const candidateGlobalCost = this.computeSolvedGraphCost(
+      replacementAppliedSolvedRoutes
+    );
+    const sectionNotWorse = candidateCost <= this.baselineSectionCost;
+    const globalImproved = candidateGlobalCost < this.baselineGlobalCost;
+    if (sectionNotWorse && globalImproved) {
+      this.solvedRoutes = replacementAppliedSolvedRoutes;
+      const sourceSolver = this.input.hyperGraphSolver;
+      if (!sourceSolver) return;
+      sourceSolver.solvedRoutes = commitSolvedRoutes({
+        graph: sourceSolver.graph,
+        connections: sourceSolver.connections,
+        solvedRoutes: this.solvedRoutes
+      });
+      for (const regionId of this.activeSection.sectionRegionIds) {
+        this.regionAttemptCounts.set(regionId, 0);
+      }
+      this.baselineSectionCost = candidateCost;
+      this.baselineGlobalCost = candidateGlobalCost;
+    } else {
+      const attempts = this.regionAttemptCounts.get(this.activeSection.centralRegionId) ?? 0;
+      this.regionAttemptCounts.set(
+        this.activeSection.centralRegionId,
+        attempts + 1
+      );
+    }
+    this.activeSubSolver = null;
+    this.activeSection = null;
+    this.baselineSectionCost = Infinity;
+    this.baselineGlobalCost = Infinity;
+  }
+};
+
+// node_modules/transformation-matrix/src/applyToPoint.js
+function applyToPoint(matrix2, point2) {
+  return Array.isArray(point2) ? [
+    matrix2.a * point2[0] + matrix2.c * point2[1] + matrix2.e,
+    matrix2.b * point2[0] + matrix2.d * point2[1] + matrix2.f
+  ] : {
+    x: matrix2.a * point2.x + matrix2.c * point2.y + matrix2.e,
+    y: matrix2.b * point2.x + matrix2.d * point2.y + matrix2.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/getBoundsCenter.ts
+var computeBoundsCenter = (bounds) => {
+  return {
+    x: (bounds.minX + bounds.maxX) / 2,
+    y: (bounds.minY + bounds.maxY) / 2
+  };
+};
+
+// lib/JumperGraphSolver/geometry/applyTransformToGraph.ts
+var applyTransformToGraph = (graph, matrix2) => {
+  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(matrix2, 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(matrix2, 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(matrix2, 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;
+  });
+  const transformedJumperLocations = graph.jumperLocations?.map((loc) => {
+    const newCenter = applyToPoint(matrix2, loc.center);
+    const newPadRegions = loc.padRegions.map(
+      (region) => regionMap.get(region)
+    );
+    const unitX = applyToPoint(matrix2, { x: 1, y: 0 });
+    const origin = applyToPoint(matrix2, { x: 0, y: 0 });
+    const dx = unitX.x - origin.x;
+    const dy = unitX.y - origin.y;
+    const isRotated90 = Math.abs(dy) > Math.abs(dx);
+    const newOrientation = isRotated90 ? loc.orientation === "horizontal" ? "vertical" : "horizontal" : loc.orientation;
+    return {
+      center: newCenter,
+      orientation: newOrientation,
+      padRegions: newPadRegions
+    };
+  });
+  return {
+    regions: transformedRegions,
+    ports: transformedPorts,
+    ...transformedJumperLocations && {
+      jumperLocations: transformedJumperLocations
+    }
+  };
+};
+var rotateGraph90Degrees = (graph) => {
+  const bounds = calculateGraphBounds(graph.regions);
+  const center = computeBoundsCenter(bounds);
+  const matrix2 = compose(
+    translate(center.x, center.y),
+    rotate(-Math.PI / 2),
+    // -90 degrees (clockwise)
+    translate(-center.x, -center.y)
+  );
+  return applyTransformToGraph(graph, matrix2);
+};
+
+// lib/JumperGraphSolver/computeCrossingAssignments.ts
+function computeCrossingAssignments(region, port1, port2) {
+  const perimeter = getRegionPerimeter(region);
+  const t1 = getPortPerimeterTInRegion(port1, region);
+  const t2 = getPortPerimeterTInRegion(port2, region);
+  const newChord = [t1, t2];
+  const crossingAssignments = [];
+  const assignments = region.assignments ?? [];
+  for (const assignment of assignments) {
+    const existingT1 = getPortPerimeterTInRegion(
+      assignment.regionPort1,
+      region
+    );
+    const existingT2 = getPortPerimeterTInRegion(
+      assignment.regionPort2,
+      region
+    );
+    const existingChord = [existingT1, existingT2];
     if (chordsCross(newChord, existingChord, perimeter)) {
       crossingAssignments.push(assignment);
     }
@@ -2638,31 +3645,74 @@ var getConnectionColor = (connectionId, alpha = 0.8) => {
   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 ? {
+var visualizeJumperGraphWithSolvedRoutes = (input) => {
+  const graphics = visualizeJumperGraph(input.graph, {
+    connections: input.connections,
+    ...input.hideInitialGeometry ? {
       hideRegionPortLines: true,
       hideConnectionLines: true,
       hidePortPoints: true
     } : {}
   });
-  if (solver.iterations === 0) {
+  if (!input.hideInitialGeometry) {
     for (const polygon2 of graphics.polygons) {
       polygon2.stroke = "rgba(128, 128, 128, 0.5)";
       polygon2.strokeWidth = 0.03;
     }
   }
+  if (input.title) {
+    graphics.title = input.title;
+  }
+  for (const solvedRoute of input.priorSolvedRoutes ?? []) {
+    const pathPoints = solvedRoute.path.map((candidate) => {
+      const port = candidate.port;
+      return { x: port.d.x, y: port.d.y };
+    });
+    if (pathPoints.length === 0) continue;
+    graphics.lines.push({
+      points: pathPoints,
+      strokeColor: "rgba(80, 80, 80, 0.45)",
+      strokeDash: "4 4"
+    });
+  }
+  for (const solvedRoute of input.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
+      });
+    }
+  }
+  return graphics;
+};
+var visualizeJumperGraphSolver = (solver) => {
+  const jumperGraph = {
+    regions: solver.graph.regions,
+    ports: solver.graph.ports
+  };
+  const graphics = visualizeJumperGraphWithSolvedRoutes({
+    graph: jumperGraph,
+    connections: solver.connections,
+    solvedRoutes: solver.solvedRoutes,
+    hideInitialGeometry: solver.iterations > 0
+  });
   if (solver.currentConnection && !solver.solved) {
     const connectionColor = getConnectionColor(
       solver.currentConnection.connectionId
     );
     const startRegion = solver.currentConnection.startRegion;
     const endRegion = solver.currentConnection.endRegion;
+    if (!startRegion?.d || !endRegion?.d) {
+      return graphics;
+    }
     const startCenter = {
       x: (startRegion.d.bounds.minX + startRegion.d.bounds.maxX) / 2,
       y: (startRegion.d.bounds.minY + startRegion.d.bounds.maxY) / 2
@@ -2678,32 +3728,16 @@ var visualizeJumperGraphSolver = (solver) => {
     });
     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
-      });
-    }
+      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")
+    });
   }
   const candidates = solver.candidateQueue.peekMany(10);
   for (let candidateIndex = 0; candidateIndex < candidates.length; candidateIndex++) {
@@ -2882,252 +3916,6 @@ var JumperGraphSolver = class extends HyperGraphSolver {
   }
 };
 
-// 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 EPS = 0.01;
-var clamp3 = (value, min, max) => {
-  return Math.max(min, Math.min(max, value));
-};
-var getBoundarySidesForPoint = (x, y, graphBounds) => {
-  const sides = [];
-  if (Math.abs(x - graphBounds.minX) < EPS) sides.push("left");
-  if (Math.abs(x - graphBounds.maxX) < EPS) sides.push("right");
-  if (Math.abs(y - graphBounds.maxY) < EPS) sides.push("top");
-  if (Math.abs(y - graphBounds.minY) < EPS) sides.push("bottom");
-  return sides;
-};
-var isPointOnSide = (p, side, b) => {
-  if (side === "left") return Math.abs(p.x - b.minX) < EPS;
-  if (side === "right") return Math.abs(p.x - b.maxX) < EPS;
-  if (side === "top") return Math.abs(p.y - b.maxY) < EPS;
-  return Math.abs(p.y - b.minY) < EPS;
-};
-var projectToSegment2 = (x, y, a, b) => {
-  const abx = b.x - a.x;
-  const aby = b.y - a.y;
-  const apx = x - a.x;
-  const apy = y - a.y;
-  const ab2 = abx * abx + aby * aby;
-  const t = ab2 > 0 ? clamp3((apx * abx + apy * aby) / ab2, 0, 1) : 0;
-  const px = a.x + t * abx;
-  const py = a.y + t * aby;
-  const dx = x - px;
-  const dy = y - py;
-  return {
-    x: px,
-    y: py,
-    d2: dx * dx + dy * dy
-  };
-};
-var getRegionBoundaryProjection = (x, y, region, graphBounds, preferredSides) => {
-  const polygon2 = region.d.polygon;
-  if (polygon2 && polygon2.length >= 3) {
-    const sideSet = new Set(preferredSides);
-    let best2 = null;
-    for (let i = 0; i < polygon2.length; i++) {
-      const a = polygon2[i];
-      const b = polygon2[(i + 1) % polygon2.length];
-      if (preferredSides.length > 0) {
-        const edgeOnPreferredSide = preferredSides.some(
-          (side) => isPointOnSide(a, side, graphBounds) && isPointOnSide(b, side, graphBounds) && sideSet.has(side)
-        );
-        if (!edgeOnPreferredSide) continue;
-      }
-      const p = projectToSegment2(x, y, a, b);
-      if (!best2 || p.d2 < best2.d2) {
-        best2 = p;
-      }
-    }
-    if (best2) return best2;
-  }
-  const bounds = region.d.bounds;
-  const sideCandidates = [];
-  if (preferredSides.length > 0) {
-    for (const side of preferredSides) {
-      if (side === "left") {
-        sideCandidates.push({
-          side,
-          x: bounds.minX,
-          y: clamp3(y, bounds.minY, bounds.maxY)
-        });
-      } else if (side === "right") {
-        sideCandidates.push({
-          side,
-          x: bounds.maxX,
-          y: clamp3(y, bounds.minY, bounds.maxY)
-        });
-      } else if (side === "top") {
-        sideCandidates.push({
-          side,
-          x: clamp3(x, bounds.minX, bounds.maxX),
-          y: bounds.maxY
-        });
-      } else {
-        sideCandidates.push({
-          side,
-          x: clamp3(x, bounds.minX, bounds.maxX),
-          y: bounds.minY
-        });
-      }
-    }
-  }
-  if (sideCandidates.length === 0) {
-    sideCandidates.push(
-      { side: "left", x: bounds.minX, y: clamp3(y, bounds.minY, bounds.maxY) },
-      {
-        side: "right",
-        x: bounds.maxX,
-        y: clamp3(y, bounds.minY, bounds.maxY)
-      },
-      { side: "top", x: clamp3(x, bounds.minX, bounds.maxX), y: bounds.maxY },
-      {
-        side: "bottom",
-        x: clamp3(x, bounds.minX, bounds.maxX),
-        y: bounds.minY
-      }
-    );
-  }
-  let best = null;
-  for (const c of sideCandidates) {
-    if (preferredSides.length > 0 && !preferredSides.includes(c.side)) continue;
-    const dx = x - c.x;
-    const dy = y - c.y;
-    const d2 = dx * dx + dy * dy;
-    if (!best || d2 < best.d2) {
-      best = { x: c.x, y: c.y, d2 };
-    }
-  }
-  return best;
-};
-var findBoundaryRegion = (x, y, regions, graphBounds) => {
-  const preferredSides = getBoundarySidesForPoint(x, y, graphBounds);
-  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 projection = getRegionBoundaryProjection(
-      x,
-      y,
-      region,
-      graphBounds,
-      preferredSides
-    );
-    if (!projection) continue;
-    const dist = Math.sqrt(projection.d2);
-    if (dist < closestDistance) {
-      closestDistance = dist;
-      closestRegion = region;
-      closestPortPosition = { x: projection.x, y: projection.y };
-    }
-  }
-  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/JumperGraphSolver/jumper-graph-generator/generateSingleJumperRegions.ts
 var dims0603 = {
   padToPad: 1.65,
@@ -14383,7 +15171,7 @@ function setStepOfAllObjects(graphics, step) {
   }
   return graphics;
 }
-var BaseSolver2 = class {
+var BaseSolver3 = class {
   MAX_ITERATIONS = 1e5;
   solved = false;
   failed = false;
@@ -14490,7 +15278,7 @@ function definePipelineStep(solverName, solverClass, getConstructorParams, opts
     onSolved: opts.onSolved
   };
 }
-var BasePipelineSolver = class extends BaseSolver2 {
+var BasePipelineSolver = class extends BaseSolver3 {
   startTimeOfStage = {};
   endTimeOfStage = {};
   timeSpentOnStage = {};
@@ -14705,7 +15493,7 @@ var clampPointToBounds = (point4, bounds) => ({
   x: Math.min(bounds.maxX, Math.max(bounds.minX, point4.x)),
   y: Math.min(bounds.maxY, Math.max(bounds.minY, point4.y))
 });
-var BuildRegionsSolver = class extends BaseSolver2 {
+var BuildRegionsSolver = class extends BaseSolver3 {
   input;
   output = null;
   constructor(input) {
@@ -15126,7 +15914,7 @@ var generateBoundaryPointsWithEdges = (params) => {
     hadCrossings: resolved.hadCrossings
   };
 };
-var GeneratePointsSolver = class extends BaseSolver2 {
+var GeneratePointsSolver = class extends BaseSolver3 {
   input;
   output = null;
   constructor(input) {
@@ -15581,7 +16369,7 @@ var mergeCellsPolyanya = (params) => {
   const depths = liveCells.map(() => 0);
   return { cells: liveCells, depths };
 };
-var MergeCellsSolver = class extends BaseSolver2 {
+var MergeCellsSolver = class extends BaseSolver3 {
   input;
   output = null;
   constructor(input) {
@@ -15839,7 +16627,7 @@ var filterTris = (params) => {
     return true;
   });
 };
-var TriangulateSolver = class extends BaseSolver2 {
+var TriangulateSolver = class extends BaseSolver3 {
   input;
   output = null;
   constructor(input) {
@@ -23796,6 +24584,7 @@ function createConvexViaGraphFromXYConnections(xyConnections, viaTileOrProblem,
 }
 export {
   ConnectBuilder,
+  HyperGraphSectionOptimizer,
   HyperGraphSolver,
   JUMPER_GRAPH_SOLVER_DEFAULTS,
   JumperGraphSolver,