@tscircuit/capacity-autorouter 0.0.18 → 0.0.20

package/dist/index.d.ts

@@ -93,7 +93,9 @@ declare class BaseSolver {
     iterations: number;
     progress: number;
     error: string | null;
+    activeSubSolver?: BaseSolver | null;
     failedSubSolvers?: BaseSolver[];
+    timeToSolve?: number;
     /** DO NOT OVERRIDE! Override _step() instead */
     step(): void;
     _step(): void;
@@ -889,6 +891,222 @@ declare class MultipleHighDensityRouteStitchSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
+type SegmentPointId = string;
+type SegmentId = string;
+interface BaseUnravelIssue {
+    probabilityOfFailure: number;
+}
+interface UnravelTransitionViaIssue extends BaseUnravelIssue {
+    type: "transition_via";
+    capacityMeshNodeId: CapacityMeshNodeId;
+    segmentPoints: SegmentPointId[];
+}
+interface UnravelSameLayerCrossingIssue extends BaseUnravelIssue {
+    type: "same_layer_crossing";
+    capacityMeshNodeId: CapacityMeshNodeId;
+    crossingLine1: [SegmentPointId, SegmentPointId];
+    crossingLine2: [SegmentPointId, SegmentPointId];
+}
+interface UnravelSingleTransitionCrossingIssue extends BaseUnravelIssue {
+    type: "single_transition_crossing";
+    capacityMeshNodeId: CapacityMeshNodeId;
+    sameLayerCrossingLine: [SegmentPointId, SegmentPointId];
+    transitionCrossingLine: [SegmentPointId, SegmentPointId];
+}
+interface UnravelDoubleTransitionCrossingIssue extends BaseUnravelIssue {
+    type: "double_transition_crossing";
+    capacityMeshNodeId: CapacityMeshNodeId;
+    crossingLine1: [SegmentPointId, SegmentPointId];
+    crossingLine2: [SegmentPointId, SegmentPointId];
+}
+interface UnravelTraceCapacityIssue extends BaseUnravelIssue {
+    type: "same_layer_trace_imbalance_with_low_capacity";
+    capacityMeshNodeId: CapacityMeshNodeId;
+    z: number;
+    tracesOnLayer: Array<{
+        A: SegmentPointId;
+        B: SegmentPointId;
+    }>;
+}
+interface SegmentPoint {
+    segmentPointId: SegmentPointId;
+    directlyConnectedSegmentPointIds: SegmentPointId[];
+    connectionName: string;
+    segmentId: string;
+    capacityMeshNodeIds: CapacityMeshNodeId[];
+    x: number;
+    y: number;
+    z: number;
+}
+type SegmentPointMap = Map<SegmentPointId, SegmentPoint>;
+type UnravelIssue = UnravelTransitionViaIssue | UnravelSameLayerCrossingIssue | UnravelSingleTransitionCrossingIssue | UnravelDoubleTransitionCrossingIssue | UnravelTraceCapacityIssue;
+interface UnravelSection {
+    allNodeIds: CapacityMeshNodeId[];
+    mutableNodeIds: CapacityMeshNodeId[];
+    mutableSegmentIds: Set<string>;
+    immutableNodeIds: CapacityMeshNodeId[];
+    segmentPointMap: SegmentPointMap;
+    segmentPairsInNode: Map<CapacityMeshNodeId, Array<[SegmentPointId, SegmentPointId]>>;
+    segmentPointsInNode: Map<CapacityMeshNodeId, SegmentPointId[]>;
+    segmentPointsInSegment: Map<SegmentId, SegmentPointId[]>;
+}
+interface UnravelChangeLayerOperation {
+    type: "change_layer";
+    newZ: number;
+    segmentPointIds: SegmentPointId[];
+}
+interface UnravelSwapPositionOnSegmentOperation {
+    type: "swap_position_on_segment";
+    segmentPointIds: SegmentPointId[];
+}
+interface UnravelCombinedOperation {
+    type: "combined";
+    operations: Array<UnravelChangeLayerOperation | UnravelSwapPositionOnSegmentOperation>;
+}
+type UnravelOperation = UnravelChangeLayerOperation | UnravelSwapPositionOnSegmentOperation | UnravelCombinedOperation;
+type UnravelCandidate = {
+    operationsPerformed: number;
+    /**
+     * A hash of the pointModifications to know if this candidate has already been
+     * explored
+     */
+    candidateHash: string;
+    /**
+     * More expensive hash that includes original positions
+     */
+    candidateFullHash?: string;
+    pointModifications: Map<SegmentPointId, {
+        x?: number;
+        y?: number;
+        z?: number;
+    }>;
+    issues: UnravelIssue[];
+    /**
+     * The cost of this candidate (log probability of failure) considering all of
+     * the point modifications
+     */
+    g: number;
+    /**
+     * The estimated cost of this candidate (log probability of failure). We don't
+     * currently know how to compute this so it's always 0.
+     */
+    h: number;
+    /**
+     * Candidate cost ~(g + h)
+     */
+    f: number;
+};
+
+/**
+ * The UntangleSectionSolver optimizes a section of connected capacity nodes
+ * with their deduplicated segments.
+ *
+ * The section always has a "root" node. From the root node, MUTABLE_HOPS are
+ * taken to reach other nodes that are mutable. One additional hop is taken to
+ * have all the impacted nodes in section. So a section is composed of mutable
+ * and immutable nodes.
+ *
+ * The goal of the solver is to perform operations on the mutable nodes of the
+ * section to lower the overall cost of the section.
+ *
+ * The untangle phase will perform "operations" on segments based on "issues"
+ *
+ * An "issue" is anything that increases the cost of the node:
+ * - Anything that causes a via (e.g. layer transition)
+ * - Any time two traces cross on the same layer
+ *
+ * An operation is a change to a segment. There are two main operations:
+ * - Change layer
+ * - Change point order on segment
+ *
+ * This solver works by exploring different paths of operations. When an
+ * operation is performed, new issues are created. Each path has a cost, and
+ * a set of neighbors representing next operations to perform.
+ *
+ */
+declare class UnravelSectionSolver extends BaseSolver {
+    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    dedupedSegments: SegmentWithAssignedPoints[];
+    MUTABLE_HOPS: number;
+    unravelSection: UnravelSection;
+    candidates: UnravelCandidate[];
+    lastProcessedCandidate: UnravelCandidate | null;
+    bestCandidate: UnravelCandidate | null;
+    originalCandidate: UnravelCandidate;
+    rootNodeId: CapacityMeshNodeId;
+    nodeIdToSegmentIds: Map<CapacityMeshNodeId, CapacityMeshNodeId[]>;
+    segmentIdToNodeIds: Map<CapacityMeshNodeId, CapacityMeshNodeId[]>;
+    colorMap: Record<string, string>;
+    tunedNodeCapacityMap: Map<CapacityMeshNodeId, number>;
+    MAX_CANDIDATES: number;
+    selectedCandidateIndex: number | "best" | "original" | null;
+    queuedOrExploredCandidatePointModificationHashes: Set<string>;
+    constructor(params: {
+        rootNodeId: CapacityMeshNodeId;
+        colorMap?: Record<string, string>;
+        MUTABLE_HOPS?: number;
+        nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+        dedupedSegments: SegmentWithAssignedPoints[];
+        nodeIdToSegmentIds: Map<CapacityMeshNodeId, CapacityMeshNodeId[]>;
+        segmentIdToNodeIds: Map<CapacityMeshNodeId, CapacityMeshNodeId[]>;
+        segmentPointMap?: SegmentPointMap;
+    });
+    createUnravelSection(segmentPointMap?: SegmentPointMap): UnravelSection;
+    createInitialCandidate(): UnravelCandidate;
+    get nextCandidate(): UnravelCandidate | null;
+    getPointInCandidate(candidate: UnravelCandidate, segmentPointId: SegmentPointId): {
+        x: number;
+        y: number;
+        z: number;
+        segmentId: string;
+    };
+    getOperationsForIssue(candidate: UnravelCandidate, issue: UnravelIssue): UnravelOperation[];
+    computeG(params: {
+        issues: UnravelIssue[];
+        originalCandidate: UnravelCandidate;
+        operationsPerformed: number;
+        operation: UnravelOperation;
+    }): number;
+    getNeighborByApplyingOperation(currentCandidate: UnravelCandidate, operation: UnravelOperation): UnravelCandidate;
+    getNeighborOperationsForCandidate(candidate: UnravelCandidate): UnravelOperation[];
+    getNeighbors(candidate: UnravelCandidate): UnravelCandidate[];
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
+declare class UnravelMultiSectionSolver extends BaseSolver {
+    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    dedupedSegments: SegmentWithAssignedPoints[];
+    nodeIdToSegmentIds: Map<CapacityMeshNodeId, CapacityMeshNodeId[]>;
+    segmentIdToNodeIds: Map<CapacityMeshNodeId, CapacityMeshNodeId[]>;
+    colorMap: Record<string, string>;
+    tunedNodeCapacityMap: Map<CapacityMeshNodeId, number>;
+    MAX_NODE_ATTEMPTS: number;
+    MUTABLE_HOPS: number;
+    ACCEPTABLE_PF: number;
+    /**
+     * Probability of failure for each node
+     */
+    nodePfMap: Map<CapacityMeshNodeId, number>;
+    attemptsToFixNode: Map<CapacityMeshNodeId, number>;
+    activeSolver: UnravelSectionSolver | null;
+    segmentPointMap: SegmentPointMap;
+    constructor({ assignedSegments, colorMap, nodes, }: {
+        assignedSegments: NodePortSegment[];
+        colorMap?: Record<string, string>;
+        /**
+         * This isn't used by the algorithm, but allows associating metadata
+         * for the result datatype (the center, width, height of the node)
+         */
+        nodes: CapacityMeshNode[];
+    });
+    computeInitialPfMap(): Map<string, number>;
+    computeNodePf(node: CapacityMeshNode): number;
+    _step(): void;
+    visualize(): GraphicsObject;
+    getNodesWithPortPoints(): NodeWithPortPoints[];
+}
+
 interface CapacityMeshSolverOptions {
     capacityDepth?: number;
     targetMinCapacity?: number;
@@ -910,6 +1128,7 @@ declare class CapacityMeshSolver extends BaseSolver {
     edgeToPortSegmentSolver?: CapacityEdgeToPortSegmentSolver;
     colorMap: Record<string, string>;
     segmentToPointSolver?: CapacitySegmentToPointSolver;
+    unravelMultiSectionSolver?: UnravelMultiSectionSolver;
     segmentToPointOptimizer?: CapacitySegmentPointOptimizer;
     highDensityRouteSolver?: HighDensitySolver;
     highDensityStitchSolver?: MultipleHighDensityRouteStitchSolver;
@@ -919,7 +1138,7 @@ declare class CapacityMeshSolver extends BaseSolver {
     activeSolver?: BaseSolver | null;
     connMap: ConnectivityMap;
     srjWithPointPairs?: SimpleRouteJson;
-    pipelineDef: (PipelineStep<typeof NetToPointPairsSolver> | PipelineStep<typeof CapacityMeshNodeSolver> | PipelineStep<typeof CapacityNodeTargetMerger> | PipelineStep<typeof CapacityMeshEdgeSolver> | PipelineStep<typeof CapacityPathingSolver4_FlexibleNegativeCapacity> | PipelineStep<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep<typeof CapacitySegmentToPointSolver> | PipelineStep<typeof CapacitySegmentPointOptimizer> | PipelineStep<typeof HighDensitySolver> | PipelineStep<typeof MultipleHighDensityRouteStitchSolver>)[];
+    pipelineDef: (PipelineStep<typeof NetToPointPairsSolver> | PipelineStep<typeof CapacityMeshNodeSolver> | PipelineStep<typeof CapacityNodeTargetMerger> | PipelineStep<typeof CapacityMeshEdgeSolver> | PipelineStep<typeof CapacityPathingSolver4_FlexibleNegativeCapacity> | PipelineStep<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep<typeof CapacitySegmentToPointSolver> | PipelineStep<typeof UnravelMultiSectionSolver> | PipelineStep<typeof HighDensitySolver> | PipelineStep<typeof MultipleHighDensityRouteStitchSolver>)[];
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions);
     currentPipelineStepIndex: number;
     _step(): void;
@@ -940,6 +1159,10 @@ declare class CapacityMeshSolver extends BaseSolver {
 
 /**
  * Calculate the capacity of a node based on its width
+ *
+ * This capacity corresponds to how many vias the node can fit, tuned for two
+ * layers.
+ *
  * @param nodeOrWidth The node or width to calculate capacity for
  * @param maxCapacityFactor Optional multiplier to adjust capacity
  * @returns The calculated capacity