@tscircuit/hypergraph 0.0.67 → 0.0.69

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)[];
@@ -1312,4 +1327,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 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 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,
@@ -1543,9 +1857,9 @@ var sliceSolvedRouteIntoLocalSection = (input) => {
     const nextRegion = port.region1 === currentRegion ? port.region2 : port.region1;
     path.push({
       port,
-      g: originalCandidate.g,
-      h: originalCandidate.h,
-      f: originalCandidate.f,
+      g: 0,
+      h: 0,
+      f: 0,
       hops: index,
       ripRequired: originalCandidate.ripRequired,
       parent: index > 0 ? path[index - 1] : void 0,
@@ -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)) {
@@ -1740,13 +2070,16 @@ var getSectionOfHyperGraphAsHyperGraph = (input) => {
       startRegion,
       endRegion
     };
-    const rawPath = solvedRoute.path.slice(span.startIndex, span.endIndex + 1);
+    const rawPath = solvedRoute.path.slice(
+      solvedPathStartIndex,
+      solvedPathEndIndex + 1
+    );
     const sectionRouteBase = {
       globalRoute: solvedRoute,
       globalConnection: solvedRoute.connection,
       sectionConnection,
-      sectionStartIndex: span.startIndex,
-      sectionEndIndex: span.endIndex
+      sectionStartIndex: solvedPathStartIndex,
+      sectionEndIndex: solvedPathEndIndex
     };
     sectionRoutes.push({
       ...sectionRouteBase,
@@ -1771,151 +2104,6 @@ var getSectionOfHyperGraphAsHyperGraph = (input) => {
   };
 };
 
-// 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/convertSolvedRoutesToSerializedSolvedRoutes.ts
 var convertSolvedRoutesToSerializedSolvedRoutes = (solvedRoutes) => {
   return solvedRoutes.map((solvedRoute) => ({
@@ -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";
 
@@ -24732,6 +25044,7 @@ export {
   calculateGraphBounds,
   convertConnectionsToSerializedConnections,
   convertHyperGraphToSerializedHyperGraph,
+  createBlankHyperGraph,
   createConvexViaGraphFromXYConnections,
   createGraphWithConnectionsFromBaseGraph,
   createViaGraphWithConnections,
@@ -24741,6 +25054,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.67",
+  "version": "0.0.69",
   "type": "module",
   "scripts": {
     "start": "cosmos",