@tscircuit/hypergraph 0.0.69 → 0.0.70

package/dist/index.d.ts

@@ -446,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;
@@ -1327,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 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 };
+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

@@ -3692,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) ? [
@@ -15617,7 +15929,7 @@ function setStepOfAllObjects(graphics, step) {
   }
   return graphics;
 }
-var BaseSolver3 = class {
+var BaseSolver4 = class {
   MAX_ITERATIONS = 1e5;
   solved = false;
   failed = false;
@@ -15724,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 = {};
@@ -15939,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) {
@@ -16360,7 +16672,7 @@ var generateBoundaryPointsWithEdges = (params) => {
     hadCrossings: resolved.hadCrossings
   };
 };
-var GeneratePointsSolver = class extends BaseSolver3 {
+var GeneratePointsSolver = class extends BaseSolver4 {
   input;
   output = null;
   constructor(input) {
@@ -16815,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) {
@@ -17073,7 +17385,7 @@ var filterTris = (params) => {
     return true;
   });
 };
-var TriangulateSolver = class extends BaseSolver3 {
+var TriangulateSolver = class extends BaseSolver4 {
   input;
   output = null;
   constructor(input) {
@@ -25031,6 +25343,7 @@ function createConvexViaGraphFromXYConnections(xyConnections, viaTileOrProblem,
 export {
   ConnectBuilder,
   HyperGraphSectionOptimizer,
+  HyperGraphSectionOptimizer2,
   HyperGraphSolver,
   JUMPER_GRAPH_SOLVER_DEFAULTS,
   JumperGraphSolver,

package/package.json

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