@tscircuit/hypergraph 0.0.68 → 0.0.70

package/dist/index.d.ts

@@ -83,6 +83,10 @@ type SerializedRegionPortAssignment = {
 type SerializedHyperGraph = {
     ports: SerializedGraphPort[];
     regions: SerializedGraphRegion[];
+    solvedRoutes?: SerializedSolvedRoute[];
+    connections?: SerializedConnection[];
+    _sectionRouteBindings?: SerializedSectionRouteBinding[];
+    _sectionCentralRegionId?: RegionId;
 };
 type SerializedCandidate = {
     portId: PortId;
@@ -100,8 +104,10 @@ type SerializedSolvedRoute = {
     connection: SerializedConnection;
     requiredRip: boolean;
 };
-type SerializedHyperGraphWithSolvedRoutes = SerializedHyperGraph & {
-    solvedRoutes: SerializedSolvedRoute[];
+type SerializedSectionRouteBinding = {
+    connectionId: ConnectionId;
+    solvedPathStartIndex: number;
+    solvedPathEndIndex: number;
 };
 type Connection = {
     connectionId: ConnectionId;
@@ -120,11 +126,13 @@ declare const convertConnectionsToSerializedConnections: (connections: Connectio
 
 declare const convertHyperGraphToSerializedHyperGraph: (graph: HyperGraph) => SerializedHyperGraph;
 
+declare const createBlankHyperGraph: (inputGraph: SerializedHyperGraph) => SerializedHyperGraph;
+
 declare const extractSectionOfHyperGraph: (input: {
-    graph: SerializedHyperGraphWithSolvedRoutes;
+    graph: SerializedHyperGraph;
     centralRegionId: RegionId;
     expansionHopsFromCentralRegion: number;
-}) => SerializedHyperGraphWithSolvedRoutes;
+}) => SerializedHyperGraph;
 
 type Node = {
     f: number;
@@ -335,6 +343,13 @@ declare class HyperGraphSolver<RegionType extends Region = Region, RegionPortTyp
     _step(): void;
 }
 
+declare const reattachSectionToGraph: (input: {
+    fullGraph: SerializedHyperGraph;
+    solvedSectionGraph: SerializedHyperGraph;
+}) => SerializedHyperGraph;
+
+declare const pruneDeadEndPorts: (graph: HyperGraph, retainedPortIds?: Iterable<PortId>) => HyperGraph;
+
 type CreateHyperGraphSolverInput = {
     inputGraph: HyperGraph | SerializedHyperGraph;
     inputConnections: (Connection | SerializedConnection)[];
@@ -431,6 +446,88 @@ declare class HyperGraphSectionOptimizer extends BaseSolver {
     _step(): void;
 }
 
+type CreateSectionSolverInput = {
+    inputGraph: SerializedHyperGraph;
+    inputConnections: SerializedConnection[];
+    inputSolvedRoutes: SerializedSolvedRoute[];
+};
+type HyperGraphSectionOptimizer2Input = {
+    inputGraph: SerializedHyperGraph;
+    inputConnections?: SerializedConnection[];
+    inputSolvedRoutes?: SerializedSolvedRoute[];
+    sectionExpansionHops?: number;
+    maxTargetRegionAttempts?: number;
+    maxSectionAttempts?: number;
+    minCentralRegionCost?: number;
+    effort?: number;
+    expansionHopsFromCentralRegion?: number;
+    MAX_ATTEMPTS_PER_REGION?: number;
+    MAX_ATTEMPTS_PER_SECTION?: number;
+    ACCEPTABLE_CENTRAL_REGION_COST?: number;
+};
+type NormalizedHyperGraphSectionOptimizer2Input = {
+    inputGraph: SerializedHyperGraph;
+    inputConnections: SerializedConnection[];
+    inputSolvedRoutes: SerializedSolvedRoute[];
+    sectionExpansionHops: number;
+    maxTargetRegionAttempts: number;
+    maxSectionAttempts: number;
+    minCentralRegionCost: number;
+    effort: number;
+};
+type SectionSolveAttempt = {
+    targetRegionId: RegionId;
+    sectionRegionIds: Set<RegionId>;
+    fullGraphSnapshot: SerializedHyperGraph;
+    blankSectionProblem: SerializedHyperGraph;
+    currentSectionCost: number;
+};
+declare class HyperGraphSectionOptimizer2 extends BaseSolver {
+    readonly config: NormalizedHyperGraphSectionOptimizer2Input;
+    readonly rootSolver: HyperGraphSolver<Region, RegionPort>;
+    graph: HyperGraph;
+    connections: Connection[];
+    solvedRoutes: SolvedRoute[];
+    activeAttempt: SectionSolveAttempt | null;
+    targetRegionAttemptCounts: Map<string, number>;
+    attemptedSectionCount: number;
+    activeSubSolver: HyperGraphSolver<Region, RegionPort> | null;
+    constructor(input: HyperGraphSectionOptimizer2Input);
+    getSolverName(): string;
+    getConstructorParams(): {
+        inputGraph: SerializedHyperGraph;
+        inputConnections: SerializedConnection[];
+        inputSolvedRoutes: SerializedSolvedRoute[];
+        sectionExpansionHops: number;
+        maxTargetRegionAttempts: number;
+        maxSectionAttempts: number;
+        minCentralRegionCost: number;
+        effort: number;
+    };
+    getOutput(): SolvedRoute[];
+    _setup(): void;
+    visualize(): GraphicsObject;
+    protected createHyperGraphSolver(input: CreateSectionSolverInput): HyperGraphSolver<Region, RegionPort>;
+    getCostOfCentralRegion(region: Region): number;
+    getSectionCost(input: {
+        solvedGraph: SerializedHyperGraph;
+        sectionRegionIds: Set<RegionId>;
+    }): number;
+    _step(): void;
+    private startNextSectionAttempt;
+    private selectTargetRegion;
+    private createSectionSolveAttempt;
+    private acceptMergedGraph;
+    private rejectActiveAttempt;
+    private clearActiveAttempt;
+    private bumpTargetRegionAttemptCount;
+    private serializeSolvedGraph;
+    private deserializeSolvedRoutes;
+    private getSectionRegionIds;
+    private pruneSectionForBlanking;
+    private getRegionSolutionCost;
+}
+
 type Bounds$1 = {
     minX: number;
     minY: number;
@@ -1312,4 +1409,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 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 };
+export { type Bounds$1 as Bounds, type BuildOpts, type Candidate, ConnectBuilder, type ConnectOpts, type Connection, type ConnectionId, type ConvexViaGraphFromXYConnectionsResult, type CreateHyperGraphSolver, type CreateHyperGraphSolverInput, type CreateSectionSolverInput, type GScore, type GraphEdgeId, type HyperGraph, type HyperGraphSection, HyperGraphSectionOptimizer, HyperGraphSectionOptimizer2, type HyperGraphSectionOptimizer2Input, 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 SerializedRegionPortAssignment, type SerializedSectionRouteBinding, 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, createBlankHyperGraph, createConvexViaGraphFromXYConnections, createGraphWithConnectionsFromBaseGraph, createViaGraphWithConnections, extractSectionOfHyperGraph, generateConvexViaTopologyRegions, generateDefaultViaTopologyRegions, generateJumperGrid, generateJumperX4Grid, generateViaTopologyRegions, pruneDeadEndPorts, reattachSectionToGraph, recommendViaTileFromGraphInput, rotateGraph90Degrees, viaTile4Regions as viaTile };

package/dist/index.js

@@ -1497,6 +1497,320 @@ var convertHyperGraphToSerializedHyperGraph = (graph) => {
   };
 };
 
+// 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
+    });
+  }
+  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/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;
+};
+
+// 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(
+    convertSerializedConnectionsToConnections(
+      inputSolvedRoutes.map((route) => route.connection),
+      graph
+    ).map((connection) => [connection.connectionId, connection])
+  );
+  return inputSolvedRoutes.map((inputSolvedRoute) => {
+    const 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,
+        g: originalCandidate.g,
+        h: originalCandidate.h,
+        f: originalCandidate.f,
+        hops: originalCandidate.hops,
+        ripRequired: originalCandidate.ripRequired
+      };
+      if (originalCandidate.lastPortId) {
+        candidate.lastPort = getRequiredPort(
+          portMap,
+          originalCandidate.lastPortId,
+          inputSolvedRoute.connection.connectionId
+        );
+      }
+      if (originalCandidate.lastRegionId) {
+        candidate.lastRegion = getRequiredRegion(
+          regionMap,
+          originalCandidate.lastRegionId,
+          inputSolvedRoute.connection.connectionId
+        );
+      }
+      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,
+      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/createBlankHyperGraph.ts
+var createBlankHyperGraph = (inputGraph) => {
+  const deserializedGraph = convertSerializedHyperGraphToHyperGraph(inputGraph);
+  if (!inputGraph.solvedRoutes) {
+    throw new Error(
+      "createBlankHyperGraph requires graph.solvedRoutes to be present"
+    );
+  }
+  const solvedRoutes = convertSerializedSolvedRoutesToSolvedRoutes(
+    inputGraph.solvedRoutes,
+    deserializedGraph
+  );
+  const removableLeafRegionIds = getRemovableLeafRegionIds(deserializedGraph);
+  const replacedEndpointRegionIds = getReplacedEndpointRegionIds(solvedRoutes);
+  const blankGraph = cloneGraphExcludingRegions(
+    deserializedGraph,
+    removableLeafRegionIds
+  );
+  const connections = [];
+  for (const solvedRoute of solvedRoutes) {
+    const startRegion = getBlankConnectionEndpointRegion({
+      solvedRoute,
+      blankGraph,
+      replacedEndpointRegionIds,
+      endpoint: "start"
+    });
+    const endRegion = getBlankConnectionEndpointRegion({
+      solvedRoute,
+      blankGraph,
+      replacedEndpointRegionIds,
+      endpoint: "end"
+    });
+    connections.push({
+      connectionId: solvedRoute.connection.connectionId,
+      mutuallyConnectedNetworkId: solvedRoute.connection.mutuallyConnectedNetworkId,
+      startRegion,
+      endRegion
+    });
+  }
+  return {
+    ...convertHyperGraphToSerializedHyperGraph(blankGraph),
+    connections: convertConnectionsToSerializedConnections(connections),
+    _sectionCentralRegionId: inputGraph._sectionCentralRegionId,
+    _sectionRouteBindings: inputGraph._sectionRouteBindings ? structuredClone(inputGraph._sectionRouteBindings) : void 0
+  };
+};
+var getRemovableLeafRegionIds = (graph) => {
+  return new Set(
+    graph.regions.filter((region) => region.ports.length === 1).map((region) => region.regionId)
+  );
+};
+var getReplacedEndpointRegionIds = (solvedRoutes) => {
+  const replacedEndpointRegionIds = /* @__PURE__ */ new Set();
+  for (const solvedRoute of solvedRoutes) {
+    const startCandidate = solvedRoute.path[0];
+    if (startCandidate && shouldReplaceEndpointRegion(
+      solvedRoute.connection.startRegion,
+      startCandidate
+    )) {
+      replacedEndpointRegionIds.add(solvedRoute.connection.startRegion.regionId);
+    }
+    const endCandidate = solvedRoute.path[solvedRoute.path.length - 1];
+    if (endCandidate && shouldReplaceEndpointRegion(
+      solvedRoute.connection.endRegion,
+      endCandidate
+    )) {
+      replacedEndpointRegionIds.add(solvedRoute.connection.endRegion.regionId);
+    }
+  }
+  return replacedEndpointRegionIds;
+};
+var shouldReplaceEndpointRegion = (endpointRegion, endpointCandidate) => {
+  return endpointRegion.ports.length === 1 && endpointRegion.ports[0]?.portId === endpointCandidate.port.portId;
+};
+var cloneGraphExcludingRegions = (graph, excludedRegionIds) => {
+  const clonedRegionMap = /* @__PURE__ */ new Map();
+  const clonedPorts = [];
+  for (const region of graph.regions) {
+    if (excludedRegionIds.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) {
+    if (excludedRegionIds.has(port.region1.regionId) || excludedRegionIds.has(port.region2.regionId)) {
+      continue;
+    }
+    const clonedPort = {
+      portId: port.portId,
+      region1: clonedRegionMap.get(port.region1.regionId),
+      region2: clonedRegionMap.get(port.region2.regionId),
+      d: port.d ? structuredClone(port.d) : port.d
+    };
+    clonedPort.region1.ports.push(clonedPort);
+    clonedPort.region2.ports.push(clonedPort);
+    clonedPorts.push(clonedPort);
+  }
+  return {
+    regions: Array.from(clonedRegionMap.values()),
+    ports: clonedPorts
+  };
+};
+var getBlankConnectionEndpointRegion = (input) => {
+  const { solvedRoute, blankGraph, replacedEndpointRegionIds, endpoint } = input;
+  const originalRegion = endpoint === "start" ? solvedRoute.connection.startRegion : solvedRoute.connection.endRegion;
+  const existingRegion = blankGraph.regions.find(
+    (region) => region.regionId === originalRegion.regionId
+  );
+  if (existingRegion) return existingRegion;
+  if (!replacedEndpointRegionIds.has(originalRegion.regionId)) {
+    throw new Error(
+      `Connection endpoint region ${originalRegion.regionId} is missing from blank graph`
+    );
+  }
+  const endpointCandidate = endpoint === "start" ? solvedRoute.path[0] : solvedRoute.path[solvedRoute.path.length - 1];
+  if (!endpointCandidate) {
+    throw new Error(
+      `Solved route ${solvedRoute.connection.connectionId} has no path candidates`
+    );
+  }
+  const attachedRegionId = getAttachedRegionId({
+    port: endpointCandidate.port,
+    originalRegionId: originalRegion.regionId,
+    preferredRegionId: endpoint === "start" ? endpointCandidate.nextRegion?.regionId : endpointCandidate.lastRegion?.regionId
+  });
+  if (!attachedRegionId) {
+    throw new Error(
+      `Could not determine ${endpoint} region for connection ${solvedRoute.connection.connectionId}`
+    );
+  }
+  const attachedRegion = blankGraph.regions.find(
+    (region) => region.regionId === attachedRegionId
+  );
+  if (!attachedRegion) {
+    throw new Error(
+      `Region ${attachedRegionId} not found in blank graph for connection ${solvedRoute.connection.connectionId}`
+    );
+  }
+  const connectionRegion = {
+    regionId: `connection:${solvedRoute.connection.connectionId}:${endpoint}`,
+    ports: [],
+    d: originalRegion.d ? structuredClone(originalRegion.d) : originalRegion.d,
+    assignments: []
+  };
+  blankGraph.regions.push(connectionRegion);
+  const connectionPort = {
+    portId: `connection:${solvedRoute.connection.connectionId}:${endpoint}-port`,
+    region1: connectionRegion,
+    region2: attachedRegion,
+    d: endpointCandidate.port.d ? structuredClone(endpointCandidate.port.d) : endpointCandidate.port.d
+  };
+  connectionRegion.ports.push(connectionPort);
+  attachedRegion.ports.push(connectionPort);
+  blankGraph.ports.push(connectionPort);
+  return connectionRegion;
+};
+var getAttachedRegionId = (input) => {
+  const { port, originalRegionId, preferredRegionId } = input;
+  if (preferredRegionId && preferredRegionId !== originalRegionId) {
+    return preferredRegionId;
+  }
+  if (port.region1.regionId !== originalRegionId) return port.region1.regionId;
+  if (port.region2.regionId !== originalRegionId) return port.region2.regionId;
+  return void 0;
+};
+
 // lib/HyperGraphSectionOptimizer/getOrCreateBoundaryRegion.ts
 var getOrCreateBoundaryRegion = ({
   port,
@@ -1656,14 +1970,30 @@ var getSectionOfHyperGraphAsHyperGraph = (input) => {
   };
   const sectionRoutes = [];
   const sectionConnections = [];
+  const sectionRouteSegments = [];
+  for (const solvedRoute of solvedRoutes) {
+    const routePathSegment = getRouteSectionSpan(solvedRoute, sectionRegionIds);
+    if (!routePathSegment) continue;
+    const startCandidate = solvedRoute.path[routePathSegment.startIndex];
+    const endCandidate = solvedRoute.path[routePathSegment.endIndex];
+    sectionRouteSegments.push({
+      solvedRoute,
+      solvedPathStartIndex: routePathSegment.startIndex,
+      solvedPathEndIndex: routePathSegment.endIndex,
+      startCandidate,
+      endCandidate
+    });
+  }
   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];
+  for (const {
+    solvedRoute,
+    solvedPathStartIndex,
+    solvedPathEndIndex,
+    startCandidate,
+    endCandidate
+  } of sectionRouteSegments) {
     let startRegionId;
     let startRegion;
     if (sectionRegionIds.has(solvedRoute.connection.startRegion.regionId)) {
@@ -1707,213 +2037,71 @@ var getSectionOfHyperGraphAsHyperGraph = (input) => {
       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/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
-    });
-  }
-  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/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;
-};
-
-// 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(
-    convertSerializedConnectionsToConnections(
-      inputSolvedRoutes.map((route) => route.connection),
-      graph
-    ).map((connection) => [connection.connectionId, connection])
-  );
-  return inputSolvedRoutes.map((inputSolvedRoute) => {
-    const 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,
-        g: originalCandidate.g,
-        h: originalCandidate.h,
-        f: originalCandidate.f,
-        hops: originalCandidate.hops,
-        ripRequired: originalCandidate.ripRequired
-      };
-      if (originalCandidate.lastPortId) {
-        candidate.lastPort = getRequiredPort(
-          portMap,
-          originalCandidate.lastPortId,
-          inputSolvedRoute.connection.connectionId
-        );
-      }
-      if (originalCandidate.lastRegionId) {
-        candidate.lastRegion = getRequiredRegion(
-          regionMap,
-          originalCandidate.lastRegionId,
-          inputSolvedRoute.connection.connectionId
-        );
-      }
-      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) {
+      console.error(`  startCandidate port: ${startCandidate.port.portId}`);
+      console.error(
+        `  Available regions in sectionRegionMap:`,
+        Array.from(sectionRegionMap.keys())
+      );
       throw new Error(
-        `Connection ${inputSolvedRoute.connection.connectionId} not found while deserializing solved route`
+        `startRegion ${startRegionId} not found in sectionRegionMap`
       );
     }
-    return {
-      path,
-      connection,
-      requiredRip: inputSolvedRoute.requiredRip
+    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
     };
-  });
-};
-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}`
+    const rawPath = solvedRoute.path.slice(
+      solvedPathStartIndex,
+      solvedPathEndIndex + 1
     );
+    const sectionRouteBase = {
+      globalRoute: solvedRoute,
+      globalConnection: solvedRoute.connection,
+      sectionConnection,
+      sectionStartIndex: solvedPathStartIndex,
+      sectionEndIndex: solvedPathEndIndex
+    };
+    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 region;
+  return {
+    centralRegionId: centralRegion.regionId,
+    sectionRegionIds,
+    graph: sectionGraph,
+    connections: sectionConnections,
+    sectionRoutes
+  };
 };
 
 // lib/convertSolvedRoutesToSerializedSolvedRoutes.ts
@@ -1948,6 +2136,11 @@ var extractSectionOfHyperGraph = (input) => {
       `Central region ${input.centralRegionId} not found in hypergraph`
     );
   }
+  if (!input.graph.solvedRoutes) {
+    throw new Error(
+      "extractSectionOfHyperGraph requires graph.solvedRoutes to be present"
+    );
+  }
   const solvedRoutes = convertSerializedSolvedRoutesToSolvedRoutes(
     input.graph.solvedRoutes,
     deserializedGraph
@@ -1960,9 +2153,16 @@ var extractSectionOfHyperGraph = (input) => {
   });
   return {
     ...convertHyperGraphToSerializedHyperGraph(section.graph),
+    connections: convertConnectionsToSerializedConnections(section.connections),
     solvedRoutes: convertSolvedRoutesToSerializedSolvedRoutes(
       section.sectionRoutes.map((route) => route.sectionRoute)
-    )
+    ),
+    _sectionCentralRegionId: section.centralRegionId,
+    _sectionRouteBindings: section.sectionRoutes.map((route) => ({
+      connectionId: route.globalConnection.connectionId,
+      solvedPathStartIndex: route.sectionStartIndex,
+      solvedPathEndIndex: route.sectionEndIndex
+    }))
   };
 };
 
@@ -2575,6 +2775,118 @@ var HyperGraphSolver = class extends BaseSolver {
   }
 };
 
+// lib/reattachSectionToGraph.ts
+var reattachSectionToGraph = (input) => {
+  const { fullGraph, solvedSectionGraph } = input;
+  if (!fullGraph.solvedRoutes) {
+    throw new Error("reattachSectionToGraph requires fullGraph.solvedRoutes");
+  }
+  if (!solvedSectionGraph.solvedRoutes) {
+    throw new Error(
+      "reattachSectionToGraph requires solvedSectionGraph.solvedRoutes"
+    );
+  }
+  if (!solvedSectionGraph._sectionRouteBindings) {
+    throw new Error(
+      "reattachSectionToGraph requires solvedSectionGraph._sectionRouteBindings"
+    );
+  }
+  const bindingByConnectionId = new Map(
+    solvedSectionGraph._sectionRouteBindings.map((binding) => [
+      binding.connectionId,
+      binding
+    ])
+  );
+  const replacementByConnectionId = new Map(
+    solvedSectionGraph.solvedRoutes.map((route) => [
+      route.connection.connectionId,
+      route
+    ])
+  );
+  return {
+    ...fullGraph,
+    solvedRoutes: fullGraph.solvedRoutes.map((fullSolvedRoute) => {
+      const binding = bindingByConnectionId.get(
+        fullSolvedRoute.connection.connectionId
+      );
+      if (!binding) return fullSolvedRoute;
+      const replacementSolvedRoute = replacementByConnectionId.get(
+        fullSolvedRoute.connection.connectionId
+      );
+      if (!replacementSolvedRoute) return fullSolvedRoute;
+      const replacementInteriorPath = replacementSolvedRoute.path.slice(1, -1);
+      const replacementPath = binding.solvedPathStartIndex === binding.solvedPathEndIndex ? [fullSolvedRoute.path[binding.solvedPathStartIndex]] : [
+        fullSolvedRoute.path[binding.solvedPathStartIndex],
+        ...replacementInteriorPath.map((candidate) => ({
+          ...candidate
+        })),
+        fullSolvedRoute.path[binding.solvedPathEndIndex]
+      ];
+      return {
+        connection: fullSolvedRoute.connection,
+        requiredRip: fullSolvedRoute.requiredRip || replacementSolvedRoute.requiredRip,
+        path: normalizeSerializedPath(
+          [
+            ...fullSolvedRoute.path.slice(0, binding.solvedPathStartIndex),
+            ...replacementPath.map((candidate) => ({
+              ...candidate
+            })),
+            ...fullSolvedRoute.path.slice(binding.solvedPathEndIndex + 1)
+          ],
+          fullGraph
+        )
+      };
+    })
+  };
+};
+var normalizeSerializedPath = (path, graph) => {
+  const portMap = new Map(graph.ports.map((port) => [port.portId, port]));
+  return path.map((candidate, index) => {
+    const previousCandidate = index > 0 ? path[index - 1] : void 0;
+    const nextCandidate = index < path.length - 1 ? path[index + 1] : void 0;
+    return {
+      ...candidate,
+      hops: index,
+      lastPortId: previousCandidate?.portId,
+      lastRegionId: previousCandidate ? getSharedRegionId(portMap, previousCandidate.portId, candidate.portId) : void 0,
+      nextRegionId: nextCandidate ? getSharedRegionId(portMap, candidate.portId, nextCandidate.portId) : void 0
+    };
+  });
+};
+var getSharedRegionId = (portMap, firstPortId, secondPortId) => {
+  const firstPort = portMap.get(firstPortId);
+  const secondPort = portMap.get(secondPortId);
+  if (!firstPort || !secondPort) return void 0;
+  const firstRegionIds = [firstPort.region1Id, firstPort.region2Id];
+  return firstRegionIds.find(
+    (regionId) => regionId === secondPort.region1Id || regionId === secondPort.region2Id
+  );
+};
+
+// lib/pruneDeadEndPorts.ts
+var pruneDeadEndPorts = (graph, retainedPortIds = []) => {
+  const retainedPortIdSet = new Set(retainedPortIds);
+  const regionPortCounts = new Map(
+    graph.regions.map((region) => [region.regionId, region.ports.length])
+  );
+  const nextPorts = [];
+  for (const region of graph.regions) {
+    region.ports = [];
+  }
+  for (const port of graph.ports) {
+    const isDeadEndPort = regionPortCounts.get(port.region1.regionId) === 1 || regionPortCounts.get(port.region2.regionId) === 1;
+    if (isDeadEndPort && !retainedPortIdSet.has(port.portId)) {
+      continue;
+    }
+    nextPorts.push(port);
+    port.region1.ports.push(port);
+    port.region2.ports.push(port);
+  }
+  graph.ports = nextPorts;
+  graph.regions = graph.regions.filter((region) => region.ports.length > 0);
+  return graph;
+};
+
 // lib/HyperGraphSectionOptimizer/HyperGraphSectionOptimizer.ts
 import { BaseSolver as BaseSolver2 } from "@tscircuit/solver-utils";
 
@@ -3380,6 +3692,318 @@ var HyperGraphSectionOptimizer = class extends BaseSolver2 {
   }
 };
 
+// lib/HyperGraphSectionOptimizer/HyperGraphSectionOptimizer2.ts
+import { BaseSolver as BaseSolver3 } from "@tscircuit/solver-utils";
+var HyperGraphSectionOptimizer2 = class extends BaseSolver3 {
+  config;
+  rootSolver;
+  graph;
+  connections;
+  solvedRoutes;
+  activeAttempt = null;
+  targetRegionAttemptCounts = /* @__PURE__ */ new Map();
+  attemptedSectionCount = 0;
+  constructor(input) {
+    super();
+    this.config = normalizeInput(input);
+    this.rootSolver = this.createHyperGraphSolver({
+      inputGraph: this.config.inputGraph,
+      inputConnections: this.config.inputConnections,
+      inputSolvedRoutes: this.config.inputSolvedRoutes
+    });
+    this.graph = this.rootSolver.graph;
+    this.connections = this.rootSolver.connections;
+    this.solvedRoutes = this.rootSolver.solvedRoutes;
+    this.MAX_ITERATIONS = Math.ceil(this.MAX_ITERATIONS * this.config.effort);
+  }
+  getSolverName() {
+    return "HyperGraphSectionOptimizer2";
+  }
+  getConstructorParams() {
+    return {
+      inputGraph: convertHyperGraphToSerializedHyperGraph(this.graph),
+      inputConnections: convertConnectionsToSerializedConnections(
+        this.connections
+      ),
+      inputSolvedRoutes: convertSolvedRoutesToSerializedSolvedRoutes(
+        this.solvedRoutes
+      ),
+      sectionExpansionHops: this.config.sectionExpansionHops,
+      maxTargetRegionAttempts: this.config.maxTargetRegionAttempts,
+      maxSectionAttempts: this.config.maxSectionAttempts,
+      minCentralRegionCost: this.config.minCentralRegionCost,
+      effort: this.config.effort
+    };
+  }
+  getOutput() {
+    return this.solvedRoutes;
+  }
+  _setup() {
+    this.startNextSectionAttempt();
+  }
+  visualize() {
+    if (this.activeSubSolver) {
+      return this.activeSubSolver.visualize();
+    }
+    return {
+      title: "HyperGraphSectionOptimizer2",
+      points: [],
+      lines: [],
+      rects: [],
+      circles: [],
+      texts: [],
+      polygons: [],
+      arrows: []
+    };
+  }
+  createHyperGraphSolver(input) {
+    const graph = convertSerializedHyperGraphToHyperGraph(input.inputGraph);
+    return new HyperGraphSolver({
+      inputGraph: graph,
+      inputConnections: input.inputConnections,
+      inputSolvedRoutes: convertSerializedSolvedRoutesToSolvedRoutes(
+        input.inputSolvedRoutes,
+        graph
+      )
+    });
+  }
+  getCostOfCentralRegion(region) {
+    const attempts = this.targetRegionAttemptCounts.get(region.regionId) ?? 0;
+    return this.getRegionSolutionCost(this.rootSolver, region) + attempts * 1e4;
+  }
+  getSectionCost(input) {
+    const sectionSolver = this.createHyperGraphSolver({
+      inputGraph: input.solvedGraph,
+      inputConnections: input.solvedGraph.connections ?? [],
+      inputSolvedRoutes: input.solvedGraph.solvedRoutes ?? []
+    });
+    let totalCost = 0;
+    for (const region of sectionSolver.graph.regions) {
+      if (!input.sectionRegionIds.has(region.regionId)) continue;
+      totalCost += this.getRegionSolutionCost(sectionSolver, region);
+    }
+    return totalCost;
+  }
+  _step() {
+    if (!this.activeSubSolver) {
+      this.startNextSectionAttempt();
+      return;
+    }
+    this.activeSubSolver.step();
+    if (!this.activeAttempt) return;
+    if (this.activeSubSolver.failed) {
+      this.rejectActiveAttempt();
+      return;
+    }
+    if (!this.activeSubSolver.solved) return;
+    const solvedBlankSection = {
+      ...this.activeAttempt.blankSectionProblem,
+      solvedRoutes: convertSolvedRoutesToSerializedSolvedRoutes(
+        this.activeSubSolver.solvedRoutes
+      )
+    };
+    const mergedGraph = reattachSectionToGraph({
+      fullGraph: this.activeAttempt.fullGraphSnapshot,
+      solvedSectionGraph: solvedBlankSection
+    });
+    const mergedSectionCost = this.getSectionCost({
+      solvedGraph: mergedGraph,
+      sectionRegionIds: this.activeAttempt.sectionRegionIds
+    });
+    if (mergedSectionCost < this.activeAttempt.currentSectionCost) {
+      this.acceptMergedGraph(mergedGraph);
+      return;
+    }
+    this.rejectActiveAttempt();
+  }
+  startNextSectionAttempt() {
+    if (this.attemptedSectionCount >= this.config.maxSectionAttempts) {
+      this.solved = true;
+      return;
+    }
+    const targetRegion = this.selectTargetRegion();
+    if (!targetRegion) {
+      this.solved = true;
+      return;
+    }
+    this.attemptedSectionCount += 1;
+    const nextAttempt = this.createSectionSolveAttempt(targetRegion);
+    if (!nextAttempt) {
+      this.bumpTargetRegionAttemptCount(targetRegion.regionId);
+      return;
+    }
+    this.activeAttempt = nextAttempt;
+    this.activeSubSolver = this.createHyperGraphSolver({
+      inputGraph: nextAttempt.blankSectionProblem,
+      inputConnections: nextAttempt.blankSectionProblem.connections ?? [],
+      inputSolvedRoutes: []
+    });
+  }
+  selectTargetRegion() {
+    let bestRegion = null;
+    let bestCost = Infinity;
+    for (const region of this.graph.regions) {
+      if ((region.assignments?.length ?? 0) === 0) continue;
+      if ((this.targetRegionAttemptCounts.get(region.regionId) ?? 0) >= this.config.maxTargetRegionAttempts) {
+        continue;
+      }
+      const cost = this.getCostOfCentralRegion(region);
+      if (cost <= this.config.minCentralRegionCost) continue;
+      if (cost >= bestCost) continue;
+      bestCost = cost;
+      bestRegion = region;
+    }
+    return bestRegion;
+  }
+  createSectionSolveAttempt(targetRegion) {
+    const fullGraphSnapshot = this.serializeSolvedGraph();
+    const extractedSection = extractSectionOfHyperGraph({
+      graph: fullGraphSnapshot,
+      centralRegionId: targetRegion.regionId,
+      expansionHopsFromCentralRegion: this.config.sectionExpansionHops
+    });
+    const prunedSection = this.pruneSectionForBlanking(extractedSection);
+    if ((prunedSection.connections?.length ?? 0) === 0) {
+      return null;
+    }
+    const sectionRegionIds = this.getSectionRegionIds(extractedSection);
+    return {
+      targetRegionId: targetRegion.regionId,
+      sectionRegionIds,
+      fullGraphSnapshot,
+      blankSectionProblem: createBlankHyperGraph(prunedSection),
+      currentSectionCost: this.getSectionCost({
+        solvedGraph: fullGraphSnapshot,
+        sectionRegionIds
+      })
+    };
+  }
+  acceptMergedGraph(mergedGraph) {
+    this.rootSolver.solvedRoutes = commitSolvedRoutes({
+      graph: this.rootSolver.graph,
+      connections: this.rootSolver.connections,
+      solvedRoutes: this.deserializeSolvedRoutes(mergedGraph)
+    });
+    this.solvedRoutes = this.rootSolver.solvedRoutes;
+    this.graph = this.rootSolver.graph;
+    this.connections = this.rootSolver.connections;
+    for (const regionId of this.activeAttempt?.sectionRegionIds ?? []) {
+      this.targetRegionAttemptCounts.set(regionId, 0);
+    }
+    this.clearActiveAttempt();
+  }
+  rejectActiveAttempt() {
+    if (this.activeSubSolver?.failed) {
+      this.failedSubSolvers ??= [];
+      this.failedSubSolvers.push(this.activeSubSolver);
+    }
+    if (this.activeAttempt) {
+      this.bumpTargetRegionAttemptCount(this.activeAttempt.targetRegionId);
+    }
+    this.clearActiveAttempt();
+  }
+  clearActiveAttempt() {
+    this.activeSubSolver = null;
+    this.activeAttempt = null;
+  }
+  bumpTargetRegionAttemptCount(regionId) {
+    this.targetRegionAttemptCounts.set(
+      regionId,
+      (this.targetRegionAttemptCounts.get(regionId) ?? 0) + 1
+    );
+  }
+  serializeSolvedGraph() {
+    return {
+      ...convertHyperGraphToSerializedHyperGraph(this.graph),
+      connections: convertConnectionsToSerializedConnections(this.connections),
+      solvedRoutes: convertSolvedRoutesToSerializedSolvedRoutes(
+        this.solvedRoutes
+      )
+    };
+  }
+  deserializeSolvedRoutes(graph) {
+    if (!graph.solvedRoutes) return [];
+    return convertSerializedSolvedRoutesToSolvedRoutes(
+      graph.solvedRoutes,
+      convertSerializedHyperGraphToHyperGraph(graph)
+    );
+  }
+  getSectionRegionIds(sectionGraph) {
+    const fullRegionIds = new Set(
+      this.graph.regions.map((region) => region.regionId)
+    );
+    return new Set(
+      sectionGraph.regions.map((region) => region.regionId).filter((regionId) => fullRegionIds.has(regionId))
+    );
+  }
+  pruneSectionForBlanking(extractedSection) {
+    const mutableSectionGraph = convertSerializedHyperGraphToHyperGraph(extractedSection);
+    const retainedPortIds = extractedSection.solvedRoutes?.flatMap((solvedRoute) => {
+      const firstPortId = solvedRoute.path[0]?.portId;
+      const lastPortId = solvedRoute.path[solvedRoute.path.length - 1]?.portId;
+      return [firstPortId, lastPortId].filter(
+        (portId) => Boolean(portId)
+      );
+    }) ?? [];
+    pruneDeadEndPorts(mutableSectionGraph, retainedPortIds);
+    return {
+      ...convertHyperGraphToSerializedHyperGraph(mutableSectionGraph),
+      connections: extractedSection.connections ? structuredClone(extractedSection.connections) : void 0,
+      solvedRoutes: extractedSection.solvedRoutes ? structuredClone(extractedSection.solvedRoutes) : void 0,
+      _sectionCentralRegionId: extractedSection._sectionCentralRegionId,
+      _sectionRouteBindings: extractedSection._sectionRouteBindings ? structuredClone(extractedSection._sectionRouteBindings) : void 0
+    };
+  }
+  getRegionSolutionCost(solver, region) {
+    const previousConnection = solver.currentConnection;
+    let totalCost = 0;
+    for (const assignment of region.assignments ?? []) {
+      solver.currentConnection = assignment.connection;
+      totalCost += solver.computeIncreasedRegionCostIfPortsAreUsed(
+        region,
+        assignment.regionPort1,
+        assignment.regionPort2
+      );
+    }
+    solver.currentConnection = previousConnection;
+    return totalCost;
+  }
+};
+var normalizeInput = (input) => {
+  const inputConnections = input.inputConnections ?? input.inputGraph.connections;
+  const inputSolvedRoutes = input.inputSolvedRoutes ?? input.inputGraph.solvedRoutes;
+  const sectionExpansionHops = input.sectionExpansionHops ?? input.expansionHopsFromCentralRegion;
+  const maxTargetRegionAttempts = input.maxTargetRegionAttempts ?? input.MAX_ATTEMPTS_PER_REGION;
+  if (!inputConnections) {
+    throw new Error("HyperGraphSectionOptimizer2 requires inputConnections");
+  }
+  if (!inputSolvedRoutes) {
+    throw new Error("HyperGraphSectionOptimizer2 requires inputSolvedRoutes");
+  }
+  if (sectionExpansionHops === void 0) {
+    throw new Error("HyperGraphSectionOptimizer2 requires sectionExpansionHops");
+  }
+  if (maxTargetRegionAttempts === void 0) {
+    throw new Error(
+      "HyperGraphSectionOptimizer2 requires maxTargetRegionAttempts"
+    );
+  }
+  return {
+    inputGraph: {
+      ...input.inputGraph,
+      connections: void 0,
+      solvedRoutes: void 0
+    },
+    inputConnections: structuredClone(inputConnections),
+    inputSolvedRoutes: structuredClone(inputSolvedRoutes),
+    sectionExpansionHops,
+    maxTargetRegionAttempts,
+    maxSectionAttempts: input.maxSectionAttempts ?? input.MAX_ATTEMPTS_PER_SECTION ?? 500,
+    minCentralRegionCost: input.minCentralRegionCost ?? input.ACCEPTABLE_CENTRAL_REGION_COST ?? 0,
+    effort: input.effort ?? 1
+  };
+};
+
 // node_modules/transformation-matrix/src/applyToPoint.js
 function applyToPoint(matrix2, point2) {
   return Array.isArray(point2) ? [
@@ -15305,7 +15929,7 @@ function setStepOfAllObjects(graphics, step) {
   }
   return graphics;
 }
-var BaseSolver3 = class {
+var BaseSolver4 = class {
   MAX_ITERATIONS = 1e5;
   solved = false;
   failed = false;
@@ -15412,7 +16036,7 @@ function definePipelineStep(solverName, solverClass, getConstructorParams, opts
     onSolved: opts.onSolved
   };
 }
-var BasePipelineSolver = class extends BaseSolver3 {
+var BasePipelineSolver = class extends BaseSolver4 {
   startTimeOfStage = {};
   endTimeOfStage = {};
   timeSpentOnStage = {};
@@ -15627,7 +16251,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 BaseSolver3 {
+var BuildRegionsSolver = class extends BaseSolver4 {
   input;
   output = null;
   constructor(input) {
@@ -16048,7 +16672,7 @@ var generateBoundaryPointsWithEdges = (params) => {
     hadCrossings: resolved.hadCrossings
   };
 };
-var GeneratePointsSolver = class extends BaseSolver3 {
+var GeneratePointsSolver = class extends BaseSolver4 {
   input;
   output = null;
   constructor(input) {
@@ -16503,7 +17127,7 @@ var mergeCellsPolyanya = (params) => {
   const depths = liveCells.map(() => 0);
   return { cells: liveCells, depths };
 };
-var MergeCellsSolver = class extends BaseSolver3 {
+var MergeCellsSolver = class extends BaseSolver4 {
   input;
   output = null;
   constructor(input) {
@@ -16761,7 +17385,7 @@ var filterTris = (params) => {
     return true;
   });
 };
-var TriangulateSolver = class extends BaseSolver3 {
+var TriangulateSolver = class extends BaseSolver4 {
   input;
   output = null;
   constructor(input) {
@@ -24719,6 +25343,7 @@ function createConvexViaGraphFromXYConnections(xyConnections, viaTileOrProblem,
 export {
   ConnectBuilder,
   HyperGraphSectionOptimizer,
+  HyperGraphSectionOptimizer2,
   HyperGraphSolver,
   JUMPER_GRAPH_SOLVER_DEFAULTS,
   JumperGraphSolver,
@@ -24732,6 +25357,7 @@ export {
   calculateGraphBounds,
   convertConnectionsToSerializedConnections,
   convertHyperGraphToSerializedHyperGraph,
+  createBlankHyperGraph,
   createConvexViaGraphFromXYConnections,
   createGraphWithConnectionsFromBaseGraph,
   createViaGraphWithConnections,
@@ -24741,6 +25367,8 @@ export {
   generateJumperGrid,
   generateJumperX4Grid,
   generateViaTopologyRegions,
+  pruneDeadEndPorts,
+  reattachSectionToGraph,
   recommendViaTileFromGraphInput,
   rotateGraph90Degrees,
   via_tile_4_regions_default as viaTile

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/hypergraph",
   "main": "dist/index.js",
-  "version": "0.0.68",
+  "version": "0.0.70",
   "type": "module",
   "scripts": {
     "start": "cosmos",