@tscircuit/rectdiff 0.0.12 → 0.0.14

package/dist/index.d.ts

@@ -50,6 +50,12 @@ interface SimpleRouteConnection {
     externallyConnectedPointIds?: string[][];
 }
 
+type XYRect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
 type GridFill3DOptions = {
     gridSizes?: number[];
     initialCellRatio?: number;
@@ -66,6 +72,20 @@ type GridFill3DOptions = {
     preferMultiLayer?: boolean;
     maxMultiLayerSpan?: number;
 };
+type Candidate3D = {
+    x: number;
+    y: number;
+    z: number;
+    distance: number;
+    /** Larger values mean more multi-layer potential at this seed. */
+    zSpanLen?: number;
+    /** Marked when the seed came from the edge analysis pass. */
+    isEdgeSeed?: boolean;
+};
+type Placed3D = {
+    rect: XYRect;
+    zLayers: number[];
+};
 
 type CapacityMeshNodeId = string;
 interface CapacityMeshNode {
@@ -88,32 +108,12 @@ interface CapacityMeshNode {
     _adjacentNodeIds?: CapacityMeshNodeId[];
     _parent?: CapacityMeshNode;
 }
-
-/**
- * A streaming, one-step-per-iteration solver for capacity mesh generation.
- */
-declare class RectDiffSolver extends BaseSolver {
-    private srj;
-    private gridOptions;
-    private state;
-    private _meshNodes;
-    constructor(opts: {
-        simpleRouteJson: SimpleRouteJson;
-        gridOptions?: Partial<GridFill3DOptions>;
-    });
-    _setup(): void;
-    /** Exactly ONE small step per call. */
-    _step(): void;
-    /** Compute solver progress (0 to 1). */
-    computeProgress(): number;
-    getOutput(): {
-        meshNodes: CapacityMeshNode[];
-    };
-    /** Get color based on z layer for visualization. */
-    private getColorForZLayer;
-    /** Streaming visualization: board + obstacles + current placements. */
-    visualize(): GraphicsObject;
-}
+type RTreeRect = XYRect & {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+};
 
 interface SegmentWithAdjacentEmptySpace {
     parent: CapacityMeshNode;
@@ -204,12 +204,154 @@ declare class GapFillSolverPipeline extends BasePipelineSolver<{
     finalVisualize(): GraphicsObject;
 }
 
+type RectDiffSeedingSolverInput = {
+    simpleRouteJson: SimpleRouteJson;
+    obstacleIndexByLayer: Array<RBush<RTreeRect>>;
+    gridOptions?: Partial<GridFill3DOptions>;
+    boardVoidRects?: XYRect[];
+};
+/**
+ * First phase of RectDiff: grid-based seeding and placement.
+ *
+ * This solver is responsible for walking all grid sizes and producing
+ * an initial set of placed rectangles.
+ */
+declare class RectDiffSeedingSolver extends BaseSolver {
+    private input;
+    private srj;
+    private layerNames;
+    private layerCount;
+    private bounds;
+    private options;
+    private boardVoidRects?;
+    private gridIndex;
+    private candidates;
+    private placed;
+    private placedIndexByLayer;
+    private expansionIndex;
+    private edgeAnalysisDone;
+    private totalSeedsThisGrid;
+    private consumedSeedsThisGrid;
+    constructor(input: RectDiffSeedingSolverInput);
+    _setup(): void;
+    /** Exactly ONE grid candidate step per call. */
+    _step(): void;
+    /**
+     * One micro-step during the GRID phase: handle exactly one candidate.
+     */
+    private _stepGrid;
+    /** Compute solver progress (0 to 1) during GRID phase. */
+    computeProgress(): number;
+    /**
+     * Output the intermediate RectDiff engine data to feed into the
+     * expansion phase solver.
+     */
+    getOutput(): {
+        srj: SimpleRouteJson;
+        layerNames: string[];
+        layerCount: number;
+        bounds: XYRect;
+        options: Required<Omit<GridFill3DOptions, "gridSizes" | "maxMultiLayerSpan">> & {
+            gridSizes: number[];
+            maxMultiLayerSpan: number | undefined;
+        };
+        boardVoidRects: XYRect[] | undefined;
+        gridIndex: number;
+        candidates: Candidate3D[];
+        placed: Placed3D[];
+        expansionIndex: number;
+        edgeAnalysisDone: boolean;
+        totalSeedsThisGrid: number;
+        consumedSeedsThisGrid: number;
+    };
+    /** Get color based on z layer for visualization. */
+    private getColorForZLayer;
+    /** Visualization focused on the grid seeding phase. */
+    visualize(): GraphicsObject;
+}
+
+type RectDiffExpansionSolverSnapshot = {
+    srj: SimpleRouteJson;
+    layerNames: string[];
+    layerCount: number;
+    bounds: XYRect;
+    options: {
+        gridSizes: number[];
+        [key: string]: any;
+    };
+    boardVoidRects: XYRect[];
+    gridIndex: number;
+    candidates: Candidate3D[];
+    placed: Placed3D[];
+    expansionIndex: number;
+    edgeAnalysisDone: boolean;
+    totalSeedsThisGrid: number;
+    consumedSeedsThisGrid: number;
+};
+type RectDiffExpansionSolverInput = {
+    initialSnapshot: RectDiffExpansionSolverSnapshot;
+    obstacleIndexByLayer: Array<RBush<RTreeRect>>;
+};
+/**
+ * Second phase of RectDiff: expand placed rects to their maximal extents.
+ *
+ * This solver takes the intermediate data produced by RectDiffSeedingSolver
+ * and runs the EXPANSION phase, then finalizes to capacity mesh nodes.
+ */
+declare class RectDiffExpansionSolver extends BaseSolver {
+    private input;
+    private srj;
+    private layerNames;
+    private layerCount;
+    private bounds;
+    private options;
+    private boardVoidRects;
+    private gridIndex;
+    private candidates;
+    private placed;
+    private placedIndexByLayer;
+    private expansionIndex;
+    private edgeAnalysisDone;
+    private totalSeedsThisGrid;
+    private consumedSeedsThisGrid;
+    private _meshNodes;
+    constructor(input: RectDiffExpansionSolverInput);
+    _setup(): void;
+    _step(): void;
+    private _stepExpansion;
+    private finalizeIfNeeded;
+    computeProgress(): number;
+    getOutput(): {
+        meshNodes: CapacityMeshNode[];
+    };
+    /** Simple visualization of expanded placements. */
+    visualize(): GraphicsObject;
+}
+
+type RectDiffGridSolverPipelineInput = {
+    simpleRouteJson: SimpleRouteJson;
+    gridOptions?: Partial<GridFill3DOptions>;
+};
+declare class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGridSolverPipelineInput> {
+    rectDiffSeedingSolver?: RectDiffSeedingSolver;
+    rectDiffExpansionSolver?: RectDiffExpansionSolver;
+    private boardVoidRects?;
+    private obstacleIndexByLayer;
+    constructor(inputProblem: RectDiffGridSolverPipelineInput);
+    pipelineDef: PipelineStep<any>[];
+    getConstructorParams(): RectDiffGridSolverPipelineInput[];
+    getOutput(): {
+        meshNodes: CapacityMeshNode[];
+    };
+    visualize(): GraphicsObject;
+}
+
 interface RectDiffPipelineInput {
     simpleRouteJson: SimpleRouteJson;
     gridOptions?: Partial<GridFill3DOptions>;
 }
 declare class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput> {
-    rectDiffSolver?: RectDiffSolver;
+    rectDiffGridSolverPipeline?: RectDiffGridSolverPipeline;
     gapFillSolver?: GapFillSolverPipeline;
     pipelineDef: PipelineStep<any>[];
     getConstructorParams(): RectDiffPipelineInput[];