@tscircuit/hypergraph 0.0.65 → 0.0.67

package/dist/index.d.ts

@@ -84,6 +84,25 @@ type SerializedHyperGraph = {
     ports: SerializedGraphPort[];
     regions: SerializedGraphRegion[];
 };
+type SerializedCandidate = {
+    portId: PortId;
+    g: number;
+    h: number;
+    f: number;
+    hops: number;
+    ripRequired: boolean;
+    lastPortId?: PortId;
+    lastRegionId?: RegionId;
+    nextRegionId?: RegionId;
+};
+type SerializedSolvedRoute = {
+    path: SerializedCandidate[];
+    connection: SerializedConnection;
+    requiredRip: boolean;
+};
+type SerializedHyperGraphWithSolvedRoutes = SerializedHyperGraph & {
+    solvedRoutes: SerializedSolvedRoute[];
+};
 type Connection = {
     connectionId: ConnectionId;
     mutuallyConnectedNetworkId: NetworkId;
@@ -94,12 +113,19 @@ type SerializedConnection = {
     connectionId: ConnectionId;
     startRegionId: RegionId;
     endRegionId: RegionId;
+    mutuallyConnectedNetworkId?: NetworkId;
 };
 
 declare const convertConnectionsToSerializedConnections: (connections: Connection[]) => SerializedConnection[];
 
 declare const convertHyperGraphToSerializedHyperGraph: (graph: HyperGraph) => SerializedHyperGraph;
 
+declare const extractSectionOfHyperGraph: (input: {
+    graph: SerializedHyperGraphWithSolvedRoutes;
+    centralRegionId: RegionId;
+    expansionHopsFromCentralRegion: number;
+}) => SerializedHyperGraphWithSolvedRoutes;
+
 type Node = {
     f: number;
     [key: string]: any;
@@ -1286,4 +1312,4 @@ declare function generateConvexViaTopologyRegions(opts: {
     };
 };
 
-export { type Bounds$1 as Bounds, type BuildOpts, type Candidate, ConnectBuilder, type ConnectOpts, type Connection, type ConnectionId, type ConvexViaGraphFromXYConnectionsResult, type CreateHyperGraphSolver, type CreateHyperGraphSolverInput, type GScore, type GraphEdgeId, type HyperGraph, type HyperGraphSection, HyperGraphSectionOptimizer, HyperGraphSolver, type JPort, type JRegion, JUMPER_GRAPH_SOLVER_DEFAULTS, type JumperGraph, JumperGraphSolver, type JumperGraphWithConnections, type NetworkId, type PortAssignment, PortBuilder, type PortData, type PortId, type PortSpread, type Region, RegionBuilder, type RegionData, type RegionId, type RegionPort, type RegionPortAssignment, type RegionRef, type RouteSegment, type SectionRoute, type SerializedConnection, type SerializedGraphPort, type SerializedGraphRegion, type SerializedHyperGraph, type SerializedRegionPortAssignment, type SharedBoundary, type SolvedRoute, Topology, TopologyError, VIA_GRAPH_SOLVER_DEFAULTS, type ValidateOpts, type ViaByNet, type ViaData, ViaGraphSolver, type ViaGraphWithConnections, type ViaTile, type ViaTileRecommendation, type ViaTileRecommendationCandidate, type ViaTileRecommendationProblemInput, type XYConnection, applyTransformToGraph, calculateGraphBounds, convertConnectionsToSerializedConnections, convertHyperGraphToSerializedHyperGraph, createConvexViaGraphFromXYConnections, createGraphWithConnectionsFromBaseGraph, createViaGraphWithConnections, generateConvexViaTopologyRegions, generateDefaultViaTopologyRegions, generateJumperGrid, generateJumperX4Grid, generateViaTopologyRegions, recommendViaTileFromGraphInput, rotateGraph90Degrees, viaTile4Regions as viaTile };
+export { type Bounds$1 as Bounds, type BuildOpts, type Candidate, ConnectBuilder, type ConnectOpts, type Connection, type ConnectionId, type ConvexViaGraphFromXYConnectionsResult, type CreateHyperGraphSolver, type CreateHyperGraphSolverInput, type GScore, type GraphEdgeId, type HyperGraph, type HyperGraphSection, HyperGraphSectionOptimizer, HyperGraphSolver, type JPort, type JRegion, JUMPER_GRAPH_SOLVER_DEFAULTS, type JumperGraph, JumperGraphSolver, type JumperGraphWithConnections, type NetworkId, type PortAssignment, PortBuilder, type PortData, type PortId, type PortSpread, type Region, RegionBuilder, type RegionData, type RegionId, type RegionPort, type RegionPortAssignment, type RegionRef, type RouteSegment, type SectionRoute, type SerializedCandidate, type SerializedConnection, type SerializedGraphPort, type SerializedGraphRegion, type SerializedHyperGraph, type SerializedHyperGraphWithSolvedRoutes, type SerializedRegionPortAssignment, type SerializedSolvedRoute, type SharedBoundary, type SolvedRoute, Topology, TopologyError, VIA_GRAPH_SOLVER_DEFAULTS, type ValidateOpts, type ViaByNet, type ViaData, ViaGraphSolver, type ViaGraphWithConnections, type ViaTile, type ViaTileRecommendation, type ViaTileRecommendationCandidate, type ViaTileRecommendationProblemInput, type XYConnection, applyTransformToGraph, calculateGraphBounds, convertConnectionsToSerializedConnections, convertHyperGraphToSerializedHyperGraph, createConvexViaGraphFromXYConnections, createGraphWithConnectionsFromBaseGraph, createViaGraphWithConnections, extractSectionOfHyperGraph, generateConvexViaTopologyRegions, generateDefaultViaTopologyRegions, generateJumperGrid, generateJumperX4Grid, generateViaTopologyRegions, recommendViaTileFromGraphInput, rotateGraph90Degrees, viaTile4Regions as viaTile };

package/dist/index.js

@@ -1471,7 +1471,8 @@ var convertConnectionsToSerializedConnections = (connections) => {
   return connections.map((conn) => ({
     connectionId: conn.connectionId,
     startRegionId: conn.startRegion.regionId,
-    endRegionId: conn.endRegion.regionId
+    endRegionId: conn.endRegion.regionId,
+    mutuallyConnectedNetworkId: conn.mutuallyConnectedNetworkId
   }));
 };
 
@@ -1496,267 +1497,679 @@ var convertHyperGraphToSerializedHyperGraph = (graph) => {
   };
 };
 
-// lib/HyperGraphSolver.ts
-import { BaseSolver } from "@tscircuit/solver-utils";
-
-// 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);
-    }
+// 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,
+        ...port.d,
+        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 connections;
+  return boundaryRegion;
 };
 
-// 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,
-      d: regionWithoutAssignments.d ? structuredClone(regionWithoutAssignments.d) : regionWithoutAssignments.d,
-      ports: [],
-      assignments: void 0
+// 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
     });
-  }
-  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);
+    currentRegion = nextRegion;
   }
   return {
-    ports: Array.from(portMap.values()),
-    regions: Array.from(regionMap.values())
+    connection: sectionRoute.sectionConnection,
+    path,
+    requiredRip: sectionRoute.globalRoute.requiredRip
   };
 };
 
-// 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;
+// 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;
   }
-  /**
-   * 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;
+  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 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);
+  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: []
+    });
   }
-  /**
-   * 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);
+  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;
     }
-    return minNode;
+    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);
   }
-  /**
-   * 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;
+  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);
       }
-      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;
+    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);
   }
-  /**
-   * 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);
+  return {
+    centralRegionId: centralRegion.regionId,
+    sectionRegionIds,
+    graph: sectionGraph,
+    connections: sectionConnections,
+    sectionRoutes
+  };
+};
+
+// lib/convertSerializedHyperGraphToHyperGraph.ts
+var convertSerializedHyperGraphToHyperGraph = (inputGraph) => {
+  if (inputGraph.ports.length > 0 && "region1" in inputGraph.ports[0] && typeof inputGraph.ports[0].region1 === "object") {
+    return inputGraph;
   }
-  /** Calculates the left child index of a node. */
-  _leftChildIndex(index) {
-    return 2 * index + 1;
+  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,
+      d: regionWithoutAssignments.d ? structuredClone(regionWithoutAssignments.d) : regionWithoutAssignments.d,
+      ports: [],
+      assignments: void 0
+    });
   }
-  /** Calculates the right child index of a node. */
-  _rightChildIndex(index) {
-    return 2 * index + 2;
+  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 deserializedPort = {
+      portId: port.portId,
+      region1,
+      region2,
+      d: port.d
+    };
+    portMap.set(port.portId, deserializedPort);
+    region1.ports.push(deserializedPort);
+    region2.ports.push(deserializedPort);
   }
+  return {
+    ports: Array.from(portMap.values()),
+    regions: Array.from(regionMap.values())
+  };
 };
 
-// lib/solvedRoutes.ts
-var clearAssignmentsFromGraph = (graph) => {
-  for (const region of graph.regions) {
-    region.assignments = [];
-  }
-  for (const port of graph.ports) {
-    port.assignment = void 0;
+// 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.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;
 };
-var commitSolvedRoutes = ({
-  graph,
-  connections,
-  solvedRoutes
-}) => {
+
+// lib/convertSerializedSolvedRoutesToSolvedRoutes.ts
+var convertSerializedSolvedRoutesToSolvedRoutes = (inputSolvedRoutes, graph) => {
   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])
+    convertSerializedConnectionsToConnections(
+      inputSolvedRoutes.map((route) => route.connection),
+      graph
+    ).map((connection) => [connection.connectionId, connection])
   );
-  const committedSolvedRoutes = solvedRoutes.map((solvedRoute) => {
+  return inputSolvedRoutes.map((inputSolvedRoute) => {
     const path = [];
-    for (const originalCandidate of solvedRoute.path) {
+    for (const originalCandidate of inputSolvedRoute.path) {
+      const port = portMap.get(originalCandidate.portId);
+      if (!port) {
+        throw new Error(
+          `Port ${originalCandidate.portId} not found while deserializing solved route ${inputSolvedRoute.connection.connectionId}`
+        );
+      }
       const candidate = {
-        port: portMap.get(originalCandidate.port.portId),
+        port,
         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.lastPortId) {
+        candidate.lastPort = getRequiredPort(
+          portMap,
+          originalCandidate.lastPortId,
+          inputSolvedRoute.connection.connectionId
+        );
       }
-      if (originalCandidate.lastRegion) {
-        candidate.lastRegion = regionMap.get(
-          originalCandidate.lastRegion.regionId
+      if (originalCandidate.lastRegionId) {
+        candidate.lastRegion = getRequiredRegion(
+          regionMap,
+          originalCandidate.lastRegionId,
+          inputSolvedRoute.connection.connectionId
         );
       }
-      if (originalCandidate.nextRegion) {
-        candidate.nextRegion = regionMap.get(
-          originalCandidate.nextRegion.regionId
+      if (originalCandidate.nextRegionId) {
+        candidate.nextRegion = getRequiredRegion(
+          regionMap,
+          originalCandidate.nextRegionId,
+          inputSolvedRoute.connection.connectionId
         );
       }
       const parent = path[path.length - 1];
       if (parent) candidate.parent = parent;
       path.push(candidate);
     }
+    const connection = connectionMap.get(
+      inputSolvedRoute.connection.connectionId
+    );
+    if (!connection) {
+      throw new Error(
+        `Connection ${inputSolvedRoute.connection.connectionId} not found while deserializing solved route`
+      );
+    }
     return {
       path,
-      connection: connectionMap.get(solvedRoute.connection.connectionId),
+      connection,
+      requiredRip: inputSolvedRoute.requiredRip
+    };
+  });
+};
+var getRequiredPort = (portMap, portId, connectionId) => {
+  const port = portMap.get(portId);
+  if (!port) {
+    throw new Error(
+      `Port ${portId} not found while deserializing solved route ${connectionId}`
+    );
+  }
+  return port;
+};
+var getRequiredRegion = (regionMap, regionId, connectionId) => {
+  const region = regionMap.get(regionId);
+  if (!region) {
+    throw new Error(
+      `Region ${regionId} not found while deserializing solved route ${connectionId}`
+    );
+  }
+  return region;
+};
+
+// lib/convertSolvedRoutesToSerializedSolvedRoutes.ts
+var convertSolvedRoutesToSerializedSolvedRoutes = (solvedRoutes) => {
+  return solvedRoutes.map((solvedRoute) => ({
+    path: solvedRoute.path.map((candidate) => ({
+      portId: candidate.port.portId,
+      g: candidate.g,
+      h: candidate.h,
+      f: candidate.f,
+      hops: candidate.hops,
+      ripRequired: candidate.ripRequired,
+      lastPortId: candidate.lastPort?.portId,
+      lastRegionId: candidate.lastRegion?.regionId,
+      nextRegionId: candidate.nextRegion?.regionId
+    })),
+    connection: convertConnectionsToSerializedConnections([
+      solvedRoute.connection
+    ])[0],
+    requiredRip: solvedRoute.requiredRip
+  }));
+};
+
+// lib/extractSectionOfHyperGraph.ts
+var extractSectionOfHyperGraph = (input) => {
+  const deserializedGraph = convertSerializedHyperGraphToHyperGraph(input.graph);
+  const centralRegion = deserializedGraph.regions.find(
+    (region) => region.regionId === input.centralRegionId
+  );
+  if (!centralRegion) {
+    throw new Error(
+      `Central region ${input.centralRegionId} not found in hypergraph`
+    );
+  }
+  const solvedRoutes = convertSerializedSolvedRoutesToSolvedRoutes(
+    input.graph.solvedRoutes,
+    deserializedGraph
+  );
+  const section = getSectionOfHyperGraphAsHyperGraph({
+    graph: deserializedGraph,
+    solvedRoutes,
+    centralRegion,
+    expansionHopsFromCentralRegion: input.expansionHopsFromCentralRegion
+  });
+  return {
+    ...convertHyperGraphToSerializedHyperGraph(section.graph),
+    solvedRoutes: convertSolvedRoutesToSerializedSolvedRoutes(
+      section.sectionRoutes.map((route) => route.sectionRoute)
+    )
+  };
+};
+
+// lib/HyperGraphSolver.ts
+import { BaseSolver } from "@tscircuit/solver-utils";
+
+// 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/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
     };
   });
@@ -2640,280 +3053,6 @@ var previewSectionReplacement = (input) => {
   });
 };
 
-// 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,
-        ...port.d,
-        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) {
@@ -24596,6 +24735,7 @@ export {
   createConvexViaGraphFromXYConnections,
   createGraphWithConnectionsFromBaseGraph,
   createViaGraphWithConnections,
+  extractSectionOfHyperGraph,
   generateConvexViaTopologyRegions,
   generateDefaultViaTopologyRegions,
   generateJumperGrid,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/hypergraph",
   "main": "dist/index.js",
-  "version": "0.0.65",
+  "version": "0.0.67",
   "type": "module",
   "scripts": {
     "start": "cosmos",
@@ -26,6 +26,7 @@
     "high-density-dataset-z04": "git+https://github.com/tscircuit/high-density-dataset-z04.git#b9128ed52f5a50102b6526319be1d4ec33dca2c2",
     "react-cosmos": "^7.1.0",
     "react-cosmos-plugin-vite": "^7.1.0",
+    "stack-svgs": "^0.0.1",
     "transformation-matrix": "^3.1.0",
     "tsup": "^8.5.1"
   },