@tscircuit/rectdiff 0.0.32 → 0.0.34

package/dist/index.js

@@ -1,2764 +0,0 @@
-// lib/RectDiffPipeline.ts
-import {
-  BasePipelineSolver as BasePipelineSolver3,
-  definePipelineStep as definePipelineStep3
-} from "@tscircuit/solver-utils";
-
-// lib/solvers/GapFillSolver/GapFillSolverPipeline.ts
-import {
-  BasePipelineSolver,
-  definePipelineStep
-} from "@tscircuit/solver-utils";
-
-// lib/solvers/GapFillSolver/FindSegmentsWithAdjacentEmptySpaceSolver.ts
-import { BaseSolver } from "@tscircuit/solver-utils";
-import Flatbush from "flatbush";
-
-// lib/solvers/GapFillSolver/projectToUncoveredSegments.ts
-var EPS = 1e-4;
-function projectToUncoveredSegments(primaryEdge, overlappingEdges) {
-  const isHorizontal = Math.abs(primaryEdge.start.y - primaryEdge.end.y) < EPS;
-  const isVertical = Math.abs(primaryEdge.start.x - primaryEdge.end.x) < EPS;
-  if (!isHorizontal && !isVertical) return [];
-  const axis = isHorizontal ? "x" : "y";
-  const perp = isHorizontal ? "y" : "x";
-  const lineCoord = primaryEdge.start[perp];
-  const p0 = primaryEdge.start[axis];
-  const p1 = primaryEdge.end[axis];
-  const pMin = Math.min(p0, p1);
-  const pMax = Math.max(p0, p1);
-  const clamp2 = (v) => Math.max(pMin, Math.min(pMax, v));
-  const intervals = [];
-  for (const e of overlappingEdges) {
-    if (e === primaryEdge) continue;
-    const eIsHorizontal = Math.abs(e.start.y - e.end.y) < EPS;
-    const eIsVertical = Math.abs(e.start.x - e.end.x) < EPS;
-    if (axis === "x" && !eIsHorizontal) continue;
-    if (axis === "y" && !eIsVertical) continue;
-    if (Math.abs(e.start[perp] - lineCoord) > EPS) continue;
-    const eMin = Math.min(e.start[axis], e.end[axis]);
-    const eMax = Math.max(e.start[axis], e.end[axis]);
-    const s = clamp2(eMin);
-    const t = clamp2(eMax);
-    if (t - s > EPS) intervals.push({ s, e: t });
-  }
-  if (intervals.length === 0) {
-    return [
-      {
-        ...primaryEdge,
-        start: { ...primaryEdge.start },
-        end: { ...primaryEdge.end }
-      }
-    ];
-  }
-  intervals.sort((a, b) => a.s - b.s);
-  const merged = [];
-  for (const it of intervals) {
-    const last = merged[merged.length - 1];
-    if (!last || it.s > last.e + EPS) merged.push({ ...it });
-    else last.e = Math.max(last.e, it.e);
-  }
-  const uncovered = [];
-  let cursor = pMin;
-  for (const m of merged) {
-    if (m.s > cursor + EPS) uncovered.push({ s: cursor, e: m.s });
-    cursor = Math.max(cursor, m.e);
-    if (cursor >= pMax - EPS) break;
-  }
-  if (pMax > cursor + EPS) uncovered.push({ s: cursor, e: pMax });
-  if (uncovered.length === 0) return [];
-  return uncovered.filter((u) => u.e - u.s > EPS).map((u) => {
-    const start = axis === "x" ? { x: u.s, y: lineCoord } : { x: lineCoord, y: u.s };
-    const end = axis === "x" ? { x: u.e, y: lineCoord } : { x: lineCoord, y: u.e };
-    return {
-      parent: primaryEdge.parent,
-      facingDirection: primaryEdge.facingDirection,
-      start,
-      end,
-      z: primaryEdge.z
-    };
-  });
-}
-
-// lib/solvers/GapFillSolver/edge-constants.ts
-var EDGES = [
-  {
-    facingDirection: "x-",
-    dx: -1,
-    dy: 0,
-    startX: -0.5,
-    startY: 0.5,
-    endX: -0.5,
-    endY: -0.5
-  },
-  {
-    facingDirection: "x+",
-    dx: 1,
-    dy: 0,
-    startX: 0.5,
-    startY: 0.5,
-    endX: 0.5,
-    endY: -0.5
-  },
-  {
-    facingDirection: "y-",
-    dx: 0,
-    dy: -1,
-    startX: -0.5,
-    startY: -0.5,
-    endX: 0.5,
-    endY: -0.5
-  },
-  {
-    facingDirection: "y+",
-    dx: 0,
-    dy: 1,
-    startX: 0.5,
-    startY: 0.5,
-    endX: -0.5,
-    endY: 0.5
-  }
-];
-var EDGE_MAP = {
-  "x-": EDGES.find((e) => e.facingDirection === "x-"),
-  "x+": EDGES.find((e) => e.facingDirection === "x+"),
-  "y-": EDGES.find((e) => e.facingDirection === "y-"),
-  "y+": EDGES.find((e) => e.facingDirection === "y+")
-};
-
-// lib/solvers/GapFillSolver/visuallyOffsetLine.ts
-var OFFSET_DIR_MAP = {
-  "x-": {
-    x: -1,
-    y: 0
-  },
-  "x+": {
-    x: 1,
-    y: 0
-  },
-  "y-": {
-    x: 0,
-    y: -1
-  },
-  "y+": {
-    x: 0,
-    y: 1
-  }
-};
-var visuallyOffsetLine = (line, options) => {
-  const { dir, amt } = options;
-  const offset = OFFSET_DIR_MAP[dir];
-  return line.map((p) => ({
-    x: p.x + offset.x * amt,
-    y: p.y + offset.y * amt
-  }));
-};
-
-// lib/solvers/GapFillSolver/FindSegmentsWithAdjacentEmptySpaceSolver.ts
-import "@tscircuit/math-utils";
-var EPS2 = 1e-4;
-var FindSegmentsWithAdjacentEmptySpaceSolver = class extends BaseSolver {
-  constructor(input) {
-    super();
-    this.input = input;
-    for (const node of this.input.meshNodes) {
-      for (const edge of EDGES) {
-        let start = {
-          x: node.center.x + node.width * edge.startX,
-          y: node.center.y + node.height * edge.startY
-        };
-        let end = {
-          x: node.center.x + node.width * edge.endX,
-          y: node.center.y + node.height * edge.endY
-        };
-        if (start.x > end.x) {
-          ;
-          [start, end] = [end, start];
-        }
-        if (Math.abs(start.x - end.x) < EPS2 && start.y > end.y) {
-          ;
-          [start, end] = [end, start];
-        }
-        for (const z of node.availableZ) {
-          this.unprocessedEdges.push({
-            parent: node,
-            start,
-            end,
-            facingDirection: edge.facingDirection,
-            z
-          });
-        }
-      }
-    }
-    this.allEdges = [...this.unprocessedEdges];
-    this.edgeSpatialIndex = new Flatbush(this.allEdges.length);
-    for (const edge of this.allEdges) {
-      this.edgeSpatialIndex.add(
-        edge.start.x,
-        edge.start.y,
-        edge.end.x,
-        edge.end.y
-      );
-    }
-    this.edgeSpatialIndex.finish();
-  }
-  input;
-  allEdges;
-  unprocessedEdges = [];
-  segmentsWithAdjacentEmptySpace = [];
-  edgeSpatialIndex;
-  lastCandidateEdge = null;
-  lastOverlappingEdges = null;
-  lastUncoveredSegments = null;
-  _step() {
-    if (this.unprocessedEdges.length === 0) {
-      this.solved = true;
-      this.lastCandidateEdge = null;
-      this.lastOverlappingEdges = null;
-      this.lastUncoveredSegments = null;
-      return;
-    }
-    const candidateEdge = this.unprocessedEdges.shift();
-    this.lastCandidateEdge = candidateEdge;
-    const nearbyEdges = this.edgeSpatialIndex.search(
-      candidateEdge.start.x - EPS2,
-      candidateEdge.start.y - EPS2,
-      candidateEdge.end.x + EPS2,
-      candidateEdge.end.y + EPS2
-    );
-    const overlappingEdges = nearbyEdges.map((i) => this.allEdges[i]).filter((e) => e.z === candidateEdge.z);
-    this.lastOverlappingEdges = overlappingEdges;
-    const uncoveredSegments = projectToUncoveredSegments(
-      candidateEdge,
-      overlappingEdges
-    );
-    this.lastUncoveredSegments = uncoveredSegments;
-    this.segmentsWithAdjacentEmptySpace.push(...uncoveredSegments);
-  }
-  getOutput() {
-    return {
-      segmentsWithAdjacentEmptySpace: this.segmentsWithAdjacentEmptySpace
-    };
-  }
-  visualize() {
-    const graphics = {
-      title: "FindSegmentsWithAdjacentEmptySpace",
-      coordinateSystem: "cartesian",
-      rects: [],
-      points: [],
-      lines: [],
-      circles: [],
-      arrows: [],
-      texts: []
-    };
-    for (const node of this.input.meshNodes) {
-      graphics.rects.push({
-        center: node.center,
-        width: node.width,
-        height: node.height,
-        stroke: "rgba(0, 0, 0, 0.1)"
-      });
-    }
-    for (const unprocessedEdge of this.unprocessedEdges) {
-      graphics.lines.push({
-        points: visuallyOffsetLine(
-          [unprocessedEdge.start, unprocessedEdge.end],
-          { dir: unprocessedEdge.facingDirection, amt: -0.1 }
-        ),
-        strokeColor: "rgba(0, 0, 255, 0.5)",
-        strokeDash: "5 5"
-      });
-    }
-    for (const edge of this.segmentsWithAdjacentEmptySpace) {
-      graphics.lines.push({
-        points: [edge.start, edge.end],
-        strokeColor: "rgba(0,255,0, 0.5)"
-      });
-    }
-    if (this.lastCandidateEdge) {
-      graphics.lines.push({
-        points: [this.lastCandidateEdge.start, this.lastCandidateEdge.end],
-        strokeColor: "blue"
-      });
-    }
-    if (this.lastOverlappingEdges) {
-      for (const edge of this.lastOverlappingEdges) {
-        graphics.lines.push({
-          points: visuallyOffsetLine([edge.start, edge.end], {
-            dir: edge.facingDirection,
-            amt: 0.05
-          }),
-          strokeColor: "red",
-          strokeDash: "2 2"
-        });
-      }
-    }
-    if (this.lastUncoveredSegments) {
-      for (const edge of this.lastUncoveredSegments) {
-        graphics.lines.push({
-          points: visuallyOffsetLine([edge.start, edge.end], {
-            dir: edge.facingDirection,
-            amt: -0.05
-          }),
-          strokeColor: "green",
-          strokeDash: "2 2"
-        });
-      }
-    }
-    return graphics;
-  }
-};
-
-// lib/solvers/GapFillSolver/ExpandEdgesToEmptySpaceSolver.ts
-import { BaseSolver as BaseSolver2 } from "@tscircuit/solver-utils";
-import RBush from "rbush";
-
-// lib/solvers/GapFillSolver/getBoundsFromCorners.ts
-var getBoundsFromCorners = (corners) => {
-  return {
-    minX: Math.min(...corners.map((c) => c.x)),
-    minY: Math.min(...corners.map((c) => c.y)),
-    maxX: Math.max(...corners.map((c) => c.x)),
-    maxY: Math.max(...corners.map((c) => c.y))
-  };
-};
-
-// lib/solvers/GapFillSolver/ExpandEdgesToEmptySpaceSolver.ts
-import { segmentToBoxMinDistance } from "@tscircuit/math-utils";
-var EPS3 = 1e-4;
-var ExpandEdgesToEmptySpaceSolver = class extends BaseSolver2 {
-  constructor(input) {
-    super();
-    this.input = input;
-    this.unprocessedSegments = [...this.input.segmentsWithAdjacentEmptySpace];
-    this.rectSpatialIndex = new RBush();
-    this.rectSpatialIndex.load(
-      this.input.boardVoid?.boardVoidRects.map((rect, index) => ({
-        capacityMeshNodeId: `void-rect-${index}`,
-        center: {
-          x: rect.x + rect.width / 2,
-          y: rect.y + rect.height / 2
-        },
-        width: rect.width,
-        height: rect.height,
-        availableZ: Array.from(
-          { length: this.input.boardVoid?.layerCount || 0 },
-          (_, i) => i
-        ),
-        layer: "void",
-        minX: rect.x,
-        minY: rect.y,
-        maxX: rect.x + rect.width,
-        maxY: rect.y + rect.height
-      })) || []
-    );
-    this.rectSpatialIndex.load(
-      this.input.inputMeshNodes.map((n) => ({
-        ...n,
-        minX: n.center.x - n.width / 2,
-        minY: n.center.y - n.height / 2,
-        maxX: n.center.x + n.width / 2,
-        maxY: n.center.y + n.height / 2
-      }))
-    );
-  }
-  input;
-  unprocessedSegments = [];
-  expandedSegments = [];
-  lastSegment = null;
-  lastSearchBounds = null;
-  lastCollidingNodes = null;
-  lastSearchCorner1 = null;
-  lastSearchCorner2 = null;
-  lastExpandedSegment = null;
-  rectSpatialIndex;
-  _step() {
-    if (this.unprocessedSegments.length === 0) {
-      this.solved = true;
-      return;
-    }
-    const segment = this.unprocessedSegments.shift();
-    this.lastSegment = segment;
-    const { dx, dy } = EDGE_MAP[segment.facingDirection];
-    const deltaStartEnd = {
-      x: segment.end.x - segment.start.x,
-      y: segment.end.y - segment.start.y
-    };
-    const segLength = Math.sqrt(deltaStartEnd.x ** 2 + deltaStartEnd.y ** 2);
-    const normDeltaStartEnd = {
-      x: deltaStartEnd.x / segLength,
-      y: deltaStartEnd.y / segLength
-    };
-    let collidingNodes = null;
-    let searchDistance = 1;
-    const searchCorner1 = {
-      x: segment.start.x + dx * EPS3 + normDeltaStartEnd.x * EPS3 * 10,
-      y: segment.start.y + dy * EPS3 + normDeltaStartEnd.y * EPS3 * 10
-    };
-    const searchCorner2 = {
-      x: segment.end.x + dx * EPS3 - normDeltaStartEnd.x * EPS3 * 10,
-      y: segment.end.y + dy * EPS3 - normDeltaStartEnd.y * EPS3 * 10
-    };
-    this.lastSearchCorner1 = searchCorner1;
-    this.lastSearchCorner2 = searchCorner2;
-    while ((!collidingNodes || collidingNodes.length === 0) && searchDistance < 1e3) {
-      const searchBounds = getBoundsFromCorners([
-        searchCorner1,
-        searchCorner2,
-        {
-          x: searchCorner1.x + dx * searchDistance,
-          y: searchCorner1.y + dy * searchDistance
-        },
-        {
-          x: searchCorner2.x + dx * searchDistance,
-          y: searchCorner2.y + dy * searchDistance
-        }
-      ]);
-      this.lastSearchBounds = searchBounds;
-      collidingNodes = this.rectSpatialIndex.search(searchBounds).filter((n) => n.availableZ.includes(segment.z)).filter(
-        (n) => n.capacityMeshNodeId !== segment.parent.capacityMeshNodeId
-      );
-      searchDistance *= 4;
-    }
-    if (!collidingNodes || collidingNodes.length === 0) {
-      return;
-    }
-    this.lastCollidingNodes = collidingNodes;
-    let smallestDistance = Infinity;
-    for (const node of collidingNodes) {
-      const distance = segmentToBoxMinDistance(segment.start, segment.end, node);
-      if (distance < smallestDistance) {
-        smallestDistance = distance;
-      }
-    }
-    const expandDistance = smallestDistance;
-    const nodeBounds = getBoundsFromCorners([
-      segment.start,
-      segment.end,
-      {
-        x: segment.start.x + dx * expandDistance,
-        y: segment.start.y + dy * expandDistance
-      },
-      {
-        x: segment.end.x + dx * expandDistance,
-        y: segment.end.y + dy * expandDistance
-      }
-    ]);
-    const nodeCenter = {
-      x: (nodeBounds.minX + nodeBounds.maxX) / 2,
-      y: (nodeBounds.minY + nodeBounds.maxY) / 2
-    };
-    const nodeWidth = nodeBounds.maxX - nodeBounds.minX;
-    const nodeHeight = nodeBounds.maxY - nodeBounds.minY;
-    const expandedSegment = {
-      segment,
-      newNode: {
-        capacityMeshNodeId: `new-${segment.parent.capacityMeshNodeId}-${this.expandedSegments.length}`,
-        center: nodeCenter,
-        width: nodeWidth,
-        height: nodeHeight,
-        availableZ: [segment.z],
-        layer: segment.parent.layer
-      }
-    };
-    this.lastExpandedSegment = expandedSegment;
-    if (nodeWidth < EPS3 || nodeHeight < EPS3) {
-      return;
-    }
-    this.expandedSegments.push(expandedSegment);
-    this.rectSpatialIndex.insert({
-      ...expandedSegment.newNode,
-      ...nodeBounds
-    });
-  }
-  getOutput() {
-    return {
-      expandedSegments: this.expandedSegments
-    };
-  }
-  visualize() {
-    const graphics = {
-      title: "ExpandEdgesToEmptySpace",
-      coordinateSystem: "cartesian",
-      rects: [],
-      points: [],
-      lines: [],
-      circles: [],
-      arrows: [],
-      texts: []
-    };
-    for (const node of this.input.inputMeshNodes) {
-      graphics.rects.push({
-        center: node.center,
-        width: node.width,
-        height: node.height,
-        stroke: "rgba(0, 0, 0, 0.1)",
-        layer: `z${node.availableZ.join(",")}`,
-        label: [
-          `node ${node.capacityMeshNodeId}`,
-          `z:${node.availableZ.join(",")}`
-        ].join("\n")
-      });
-    }
-    for (const { newNode } of this.expandedSegments) {
-      graphics.rects.push({
-        center: newNode.center,
-        width: newNode.width,
-        height: newNode.height,
-        fill: "green",
-        label: `expandedSegment (z=${newNode.availableZ.join(",")})`,
-        layer: `z${newNode.availableZ.join(",")}`
-      });
-    }
-    if (this.lastSegment) {
-      graphics.lines.push({
-        points: [this.lastSegment.start, this.lastSegment.end],
-        strokeColor: "rgba(0, 0, 255, 0.5)"
-      });
-    }
-    if (this.lastSearchBounds) {
-      graphics.rects.push({
-        center: {
-          x: (this.lastSearchBounds.minX + this.lastSearchBounds.maxX) / 2,
-          y: (this.lastSearchBounds.minY + this.lastSearchBounds.maxY) / 2
-        },
-        width: this.lastSearchBounds.maxX - this.lastSearchBounds.minX,
-        height: this.lastSearchBounds.maxY - this.lastSearchBounds.minY,
-        fill: "rgba(0, 0, 255, 0.25)"
-      });
-    }
-    if (this.lastSearchCorner1 && this.lastSearchCorner2) {
-      graphics.points.push({
-        x: this.lastSearchCorner1.x,
-        y: this.lastSearchCorner1.y,
-        color: "rgba(0, 0, 255, 0.5)",
-        label: ["searchCorner1", `z=${this.lastSegment?.z}`].join("\n")
-      });
-      graphics.points.push({
-        x: this.lastSearchCorner2.x,
-        y: this.lastSearchCorner2.y,
-        color: "rgba(0, 0, 255, 0.5)",
-        label: ["searchCorner2", `z=${this.lastSegment?.z}`].join("\n")
-      });
-    }
-    if (this.lastExpandedSegment) {
-      graphics.rects.push({
-        center: this.lastExpandedSegment.newNode.center,
-        width: this.lastExpandedSegment.newNode.width,
-        height: this.lastExpandedSegment.newNode.height,
-        fill: "purple",
-        label: `expandedSegment (z=${this.lastExpandedSegment.segment.z})`
-      });
-    }
-    if (this.lastCollidingNodes) {
-      for (const node of this.lastCollidingNodes) {
-        graphics.rects.push({
-          center: node.center,
-          width: node.width,
-          height: node.height,
-          fill: "rgba(255, 0, 0, 0.5)"
-        });
-      }
-    }
-    return graphics;
-  }
-};
-
-// lib/solvers/GapFillSolver/GapFillSolverPipeline.ts
-var GapFillSolverPipeline = class extends BasePipelineSolver {
-  findSegmentsWithAdjacentEmptySpaceSolver;
-  expandEdgesToEmptySpaceSolver;
-  pipelineDef = [
-    definePipelineStep(
-      "findSegmentsWithAdjacentEmptySpaceSolver",
-      FindSegmentsWithAdjacentEmptySpaceSolver,
-      (gapFillPipeline) => [
-        {
-          meshNodes: gapFillPipeline.inputProblem.meshNodes
-        }
-      ],
-      {
-        onSolved: () => {
-        }
-      }
-    ),
-    definePipelineStep(
-      "expandEdgesToEmptySpaceSolver",
-      ExpandEdgesToEmptySpaceSolver,
-      (gapFillPipeline) => [
-        {
-          inputMeshNodes: gapFillPipeline.inputProblem.meshNodes,
-          segmentsWithAdjacentEmptySpace: gapFillPipeline.findSegmentsWithAdjacentEmptySpaceSolver.getOutput().segmentsWithAdjacentEmptySpace,
-          boardVoid: gapFillPipeline.inputProblem.boardVoid
-        }
-      ],
-      {
-        onSolved: () => {
-        }
-      }
-    )
-  ];
-  getOutput() {
-    const expandedSegments = this.expandEdgesToEmptySpaceSolver?.getOutput().expandedSegments ?? [];
-    const expandedNodes = expandedSegments.map((es) => es.newNode);
-    return {
-      outputNodes: [...this.inputProblem.meshNodes, ...expandedNodes]
-    };
-  }
-  initialVisualize() {
-    const graphics = {
-      title: "GapFillSolverPipeline - Initial",
-      coordinateSystem: "cartesian",
-      rects: [],
-      points: [],
-      lines: [],
-      circles: [],
-      arrows: [],
-      texts: []
-    };
-    for (const node of this.inputProblem.meshNodes) {
-      graphics.rects.push({
-        center: node.center,
-        width: node.width,
-        height: node.height,
-        stroke: "rgba(0, 0, 0, 0.3)",
-        fill: "rgba(100, 100, 100, 0.1)",
-        layer: `z${node.availableZ.join(",")}`,
-        label: [
-          `node ${node.capacityMeshNodeId}`,
-          `z:${node.availableZ.join(",")}`
-        ].join("\n")
-      });
-    }
-    return graphics;
-  }
-  finalVisualize() {
-    const graphics = {
-      title: "GapFillSolverPipeline - Final",
-      coordinateSystem: "cartesian",
-      rects: [],
-      points: [],
-      lines: [],
-      circles: [],
-      arrows: [],
-      texts: []
-    };
-    const { outputNodes } = this.getOutput();
-    const expandedSegments = this.expandEdgesToEmptySpaceSolver?.getOutput().expandedSegments ?? [];
-    const expandedNodeIds = new Set(
-      expandedSegments.map((es) => es.newNode.capacityMeshNodeId)
-    );
-    for (const node of outputNodes) {
-      const isExpanded = expandedNodeIds.has(node.capacityMeshNodeId);
-      graphics.rects.push({
-        center: node.center,
-        width: node.width,
-        height: node.height,
-        stroke: isExpanded ? "rgba(0, 128, 0, 0.8)" : "rgba(0, 0, 0, 0.3)",
-        fill: isExpanded ? "rgba(0, 200, 0, 0.3)" : "rgba(100, 100, 100, 0.1)",
-        layer: `z${node.availableZ.join(",")}`,
-        label: [
-          `${isExpanded ? "[expanded] " : ""}node ${node.capacityMeshNodeId}`,
-          `z:${node.availableZ.join(",")}`
-        ].join("\n")
-      });
-    }
-    return graphics;
-  }
-};
-
-// lib/solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline.ts
-import {
-  BasePipelineSolver as BasePipelineSolver2,
-  definePipelineStep as definePipelineStep2
-} from "@tscircuit/solver-utils";
-
-// lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver.ts
-import { BaseSolver as BaseSolver3 } from "@tscircuit/solver-utils";
-
-// lib/utils/rectdiff-geometry.ts
-var EPS4 = 1e-9;
-var clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
-var gt = (a, b) => a > b + EPS4;
-var gte = (a, b) => a > b - EPS4;
-var lt = (a, b) => a < b - EPS4;
-var lte = (a, b) => a < b + EPS4;
-function overlaps(a, b) {
-  return !(a.x + a.width <= b.x + EPS4 || b.x + b.width <= a.x + EPS4 || a.y + a.height <= b.y + EPS4 || b.y + b.height <= a.y + EPS4);
-}
-function containsPoint(r, p) {
-  return p.x >= r.x - EPS4 && p.x <= r.x + r.width + EPS4 && p.y >= r.y - EPS4 && p.y <= r.y + r.height + EPS4;
-}
-function distancePointToRectEdges(p, r) {
-  const minX = r.x;
-  const maxX = r.x + r.width;
-  const minY = r.y;
-  const maxY = r.y + r.height;
-  if (p.x >= minX && p.x <= maxX && p.y >= minY && p.y <= maxY) {
-    return Math.min(p.x - minX, maxX - p.x, p.y - minY, maxY - p.y);
-  }
-  const dx = p.x < minX ? minX - p.x : p.x > maxX ? p.x - maxX : 0;
-  const dy = p.y < minY ? minY - p.y : p.y > maxY ? p.y - maxY : 0;
-  if (dx === 0) return dy;
-  if (dy === 0) return dx;
-  return Math.hypot(dx, dy);
-}
-function intersect1D(r1, r2) {
-  const lo = Math.max(r1[0], r2[0]);
-  const hi = Math.min(r1[1], r2[1]);
-  return hi > lo + EPS4 ? [lo, hi] : null;
-}
-function subtractRect2D(A, B) {
-  if (!overlaps(A, B)) return [A];
-  const Xi = intersect1D([A.x, A.x + A.width], [B.x, B.x + B.width]);
-  const Yi = intersect1D([A.y, A.y + A.height], [B.y, B.y + B.height]);
-  if (!Xi || !Yi) return [A];
-  const [X0, X1] = Xi;
-  const [Y0, Y1] = Yi;
-  const out = [];
-  if (X0 > A.x + EPS4) {
-    out.push({ x: A.x, y: A.y, width: X0 - A.x, height: A.height });
-  }
-  if (A.x + A.width > X1 + EPS4) {
-    out.push({ x: X1, y: A.y, width: A.x + A.width - X1, height: A.height });
-  }
-  const midW = Math.max(0, X1 - X0);
-  if (midW > EPS4 && Y0 > A.y + EPS4) {
-    out.push({ x: X0, y: A.y, width: midW, height: Y0 - A.y });
-  }
-  if (midW > EPS4 && A.y + A.height > Y1 + EPS4) {
-    out.push({ x: X0, y: Y1, width: midW, height: A.y + A.height - Y1 });
-  }
-  return out.filter((r) => r.width > EPS4 && r.height > EPS4);
-}
-
-// lib/solvers/RectDiffSeedingSolver/isPointInPolygon.ts
-function isPointInPolygon(p, polygon) {
-  let inside = false;
-  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
-    const xi = polygon[i].x, yi = polygon[i].y;
-    const xj = polygon[j].x, yj = polygon[j].y;
-    const intersect = yi > p.y !== yj > p.y && p.x < (xj - xi) * (p.y - yi) / (yj - yi) + xi;
-    if (intersect) inside = !inside;
-  }
-  return inside;
-}
-
-// lib/solvers/RectDiffSeedingSolver/computeInverseRects.ts
-function simplifyPolygon(polygon, precision) {
-  const round = (v) => Math.round(v / precision) * precision;
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const p of polygon) {
-    const rx = round(p.x);
-    const ry = round(p.y);
-    const key = `${rx},${ry}`;
-    if (!seen.has(key)) {
-      seen.add(key);
-      result.push({ x: rx, y: ry });
-    }
-  }
-  return result;
-}
-function computeInverseRects(bounds, polygon) {
-  if (!polygon || polygon.length < 3) return [];
-  const MAX_POLYGON_POINTS = 100;
-  const workingPolygon = polygon.length > MAX_POLYGON_POINTS ? simplifyPolygon(
-    polygon,
-    Math.max(bounds.width, bounds.height) / MAX_POLYGON_POINTS
-  ) : polygon;
-  const xs = /* @__PURE__ */ new Set([bounds.x, bounds.x + bounds.width]);
-  const ys = /* @__PURE__ */ new Set([bounds.y, bounds.y + bounds.height]);
-  for (const p of workingPolygon) {
-    xs.add(p.x);
-    ys.add(p.y);
-  }
-  const xSorted = Array.from(xs).sort((a, b) => a - b);
-  const ySorted = Array.from(ys).sort((a, b) => a - b);
-  const rawRects = [];
-  for (let i = 0; i < xSorted.length - 1; i++) {
-    for (let j = 0; j < ySorted.length - 1; j++) {
-      const x0 = xSorted[i];
-      const x1 = xSorted[i + 1];
-      const y0 = ySorted[j];
-      const y1 = ySorted[j + 1];
-      const cx = (x0 + x1) / 2;
-      const cy = (y0 + y1) / 2;
-      if (cx >= bounds.x && cx <= bounds.x + bounds.width && cy >= bounds.y && cy <= bounds.y + bounds.height) {
-        if (!isPointInPolygon({ x: cx, y: cy }, polygon)) {
-          rawRects.push({ x: x0, y: y0, width: x1 - x0, height: y1 - y0 });
-        }
-      }
-    }
-  }
-  const finalRects = [];
-  rawRects.sort((a, b) => {
-    if (Math.abs(a.y - b.y) > EPS4) return a.y - b.y;
-    return a.x - b.x;
-  });
-  let current = null;
-  for (const r of rawRects) {
-    if (!current) {
-      current = r;
-      continue;
-    }
-    const sameY = Math.abs(current.y - r.y) < EPS4;
-    const sameHeight = Math.abs(current.height - r.height) < EPS4;
-    const touchesX = Math.abs(current.x + current.width - r.x) < EPS4;
-    if (sameY && sameHeight && touchesX) {
-      current.width += r.width;
-    } else {
-      finalRects.push(current);
-      current = r;
-    }
-  }
-  if (current) finalRects.push(current);
-  finalRects.sort((a, b) => {
-    if (Math.abs(a.x - b.x) > EPS4) return a.x - b.x;
-    return a.y - b.y;
-  });
-  const mergedVertical = [];
-  current = null;
-  for (const r of finalRects) {
-    if (!current) {
-      current = r;
-      continue;
-    }
-    const sameX = Math.abs(current.x - r.x) < EPS4;
-    const sameWidth = Math.abs(current.width - r.width) < EPS4;
-    const touchesY = Math.abs(current.y + current.height - r.y) < EPS4;
-    if (sameX && sameWidth && touchesY) {
-      current.height += r.height;
-    } else {
-      mergedVertical.push(current);
-      current = r;
-    }
-  }
-  if (current) mergedVertical.push(current);
-  return mergedVertical;
-}
-
-// lib/solvers/RectDiffSeedingSolver/layers.ts
-function layerSortKey(n) {
-  const L = n.toLowerCase();
-  if (L === "top") return -1e6;
-  if (L === "bottom") return 1e6;
-  const m = /^inner(\d+)$/i.exec(L);
-  if (m) return parseInt(m[1], 10) || 0;
-  return 100 + L.charCodeAt(0);
-}
-function canonicalizeLayerOrder(names) {
-  return Array.from(new Set(names)).sort((a, b) => {
-    const ka = layerSortKey(a);
-    const kb = layerSortKey(b);
-    if (ka !== kb) return ka - kb;
-    return a.localeCompare(b);
-  });
-}
-function buildZIndexMap(params) {
-  const names = canonicalizeLayerOrder(
-    (params.obstacles ?? []).flatMap((o) => o.layers ?? [])
-  );
-  const declaredLayerCount = Math.max(1, params.layerCount || names.length || 1);
-  const fallback = Array.from(
-    { length: declaredLayerCount },
-    (_, i) => i === 0 ? "top" : i === declaredLayerCount - 1 ? "bottom" : `inner${i}`
-  );
-  const ordered = [];
-  const seen = /* @__PURE__ */ new Set();
-  const push = (n) => {
-    const key = n.toLowerCase();
-    if (seen.has(key)) return;
-    seen.add(key);
-    ordered.push(n);
-  };
-  fallback.forEach(push);
-  names.forEach(push);
-  const layerNames = ordered.slice(0, declaredLayerCount);
-  const clampIndex = (nameLower) => {
-    if (layerNames.length <= 1) return 0;
-    if (nameLower === "top") return 0;
-    if (nameLower === "bottom") return layerNames.length - 1;
-    const m = /^inner(\d+)$/i.exec(nameLower);
-    if (m) {
-      if (layerNames.length <= 2) return layerNames.length - 1;
-      const parsed = parseInt(m[1], 10);
-      const maxInner = layerNames.length - 2;
-      const clampedInner = Math.min(
-        maxInner,
-        Math.max(1, Number.isFinite(parsed) ? parsed : 1)
-      );
-      return clampedInner;
-    }
-    return 0;
-  };
-  const map = /* @__PURE__ */ new Map();
-  layerNames.forEach((n, i) => map.set(n.toLowerCase(), i));
-  ordered.slice(layerNames.length).forEach((n) => {
-    const key = n.toLowerCase();
-    map.set(key, clampIndex(key));
-  });
-  return { layerNames, zIndexByName: map };
-}
-function obstacleZs(ob, zIndexByName) {
-  if (ob.zLayers?.length)
-    return Array.from(new Set(ob.zLayers)).sort((a, b) => a - b);
-  const fromNames = (ob.layers ?? []).map((n) => zIndexByName.get(n.toLowerCase())).filter((v) => typeof v === "number");
-  return Array.from(new Set(fromNames)).sort((a, b) => a - b);
-}
-function obstacleToXYRect(ob) {
-  const w = ob.width;
-  const h = ob.height;
-  if (typeof w !== "number" || typeof h !== "number") return null;
-  return { x: ob.center.x - w / 2, y: ob.center.y - h / 2, width: w, height: h };
-}
-
-// lib/utils/isSelfRect.ts
-var EPS5 = 1e-9;
-var isSelfRect = (params) => Math.abs(params.rect.x + params.rect.width / 2 - params.startX) < EPS5 && Math.abs(params.rect.y + params.rect.height / 2 - params.startY) < EPS5 && Math.abs(params.rect.width - params.initialW) < EPS5 && Math.abs(params.rect.height - params.initialH) < EPS5;
-
-// lib/utils/searchStrip.ts
-var searchStripRight = ({
-  rect,
-  bounds
-}) => ({
-  x: rect.x,
-  y: rect.y,
-  width: bounds.x + bounds.width - rect.x,
-  height: rect.height
-});
-var searchStripDown = ({
-  rect,
-  bounds
-}) => ({
-  x: rect.x,
-  y: rect.y,
-  width: rect.width,
-  height: bounds.y + bounds.height - rect.y
-});
-var searchStripLeft = ({
-  rect,
-  bounds
-}) => ({
-  x: bounds.x,
-  y: rect.y,
-  width: rect.x - bounds.x,
-  height: rect.height
-});
-var searchStripUp = ({
-  rect,
-  bounds
-}) => ({
-  x: rect.x,
-  y: bounds.y,
-  width: rect.width,
-  height: rect.y - bounds.y
-});
-
-// lib/utils/expandRectFromSeed.ts
-var quantize = (value, precision = 1e-6) => Math.round(value / precision) * precision;
-var quantizeRect = (rect) => ({
-  x: quantize(rect.x),
-  y: quantize(rect.y),
-  width: quantize(rect.width),
-  height: quantize(rect.height)
-});
-function maxExpandRight(params) {
-  const { r, bounds, blockers, maxAspect } = params;
-  let maxWidth = bounds.x + bounds.width - r.x;
-  for (const b of blockers) {
-    const verticallyOverlaps = r.y + r.height > b.y + EPS4 && b.y + b.height > r.y + EPS4;
-    if (verticallyOverlaps) {
-      if (gte(b.x, r.x + r.width)) {
-        maxWidth = Math.min(maxWidth, b.x - r.x);
-      } else if (b.x + b.width > r.x + r.width - EPS4 && b.x < r.x + r.width + EPS4) {
-        return 0;
-      }
-    }
-  }
-  let e = Math.max(0, maxWidth - r.width);
-  if (e <= 0) return 0;
-  if (maxAspect != null) {
-    const w = r.width, h = r.height;
-    if (w >= h) e = Math.min(e, maxAspect * h - w);
-  }
-  return Math.max(0, e);
-}
-function maxExpandDown(params) {
-  const { r, bounds, blockers, maxAspect } = params;
-  let maxHeight = bounds.y + bounds.height - r.y;
-  for (const b of blockers) {
-    const horizOverlaps = r.x + r.width > b.x + EPS4 && b.x + b.width > r.x + EPS4;
-    if (horizOverlaps) {
-      if (gte(b.y, r.y + r.height)) {
-        maxHeight = Math.min(maxHeight, b.y - r.y);
-      } else if (b.y + b.height > r.y + r.height - EPS4 && b.y < r.y + r.height + EPS4) {
-        return 0;
-      }
-    }
-  }
-  let e = Math.max(0, maxHeight - r.height);
-  if (e <= 0) return 0;
-  if (maxAspect != null) {
-    const w = r.width, h = r.height;
-    if (h >= w) e = Math.min(e, maxAspect * w - h);
-  }
-  return Math.max(0, e);
-}
-function maxExpandLeft(params) {
-  const { r, bounds, blockers, maxAspect } = params;
-  let minX = bounds.x;
-  for (const b of blockers) {
-    const verticallyOverlaps = r.y + r.height > b.y + EPS4 && b.y + b.height > r.y + EPS4;
-    if (verticallyOverlaps) {
-      if (lte(b.x + b.width, r.x)) {
-        minX = Math.max(minX, b.x + b.width);
-      } else if (b.x < r.x + EPS4 && b.x + b.width > r.x - EPS4) {
-        return 0;
-      }
-    }
-  }
-  let e = Math.max(0, r.x - minX);
-  if (e <= 0) return 0;
-  if (maxAspect != null) {
-    const w = r.width, h = r.height;
-    if (w >= h) e = Math.min(e, maxAspect * h - w);
-  }
-  return Math.max(0, e);
-}
-function maxExpandUp(params) {
-  const { r, bounds, blockers, maxAspect } = params;
-  let minY = bounds.y;
-  for (const b of blockers) {
-    const horizOverlaps = r.x + r.width > b.x + EPS4 && b.x + b.width > r.x + EPS4;
-    if (horizOverlaps) {
-      if (lte(b.y + b.height, r.y)) {
-        minY = Math.max(minY, b.y + b.height);
-      } else if (b.y < r.y + EPS4 && b.y + b.height > r.y - EPS4) {
-        return 0;
-      }
-    }
-  }
-  let e = Math.max(0, r.y - minY);
-  if (e <= 0) return 0;
-  if (maxAspect != null) {
-    const w = r.width, h = r.height;
-    if (h >= w) e = Math.min(e, maxAspect * w - h);
-  }
-  return Math.max(0, e);
-}
-var addBlocker = (params) => {
-  const { rect, seen, blockers } = params;
-  if (seen.has(rect)) return;
-  seen.add(rect);
-  blockers.push(rect);
-};
-var toQueryRect = (params) => {
-  const { bounds, rect } = params;
-  const minX = Math.max(bounds.x, rect.x);
-  const minY = Math.max(bounds.y, rect.y);
-  const maxX = Math.min(bounds.x + bounds.width, rect.x + rect.width);
-  const maxY = Math.min(bounds.y + bounds.height, rect.y + rect.height);
-  if (maxX <= minX + EPS4 || maxY <= minY + EPS4) return null;
-  return { minX, minY, maxX, maxY };
-};
-function expandRectFromSeed(params) {
-  const {
-    startX,
-    startY,
-    gridSize,
-    bounds,
-    obsticalIndexByLayer,
-    placedIndexByLayer,
-    initialCellRatio,
-    maxAspectRatio,
-    minReq
-  } = params;
-  const minSide = Math.max(1e-9, gridSize * initialCellRatio);
-  const initialW = Math.max(minSide, minReq.width);
-  const initialH = Math.max(minSide, minReq.height);
-  const blockers = [];
-  const seen = /* @__PURE__ */ new Set();
-  const totalLayers = placedIndexByLayer.length;
-  const collectBlockers = (searchRect) => {
-    const query = toQueryRect({ bounds, rect: searchRect });
-    if (!query) return;
-    for (const z of params.zLayers) {
-      const blockersIndex = obsticalIndexByLayer[z];
-      if (blockersIndex) {
-        for (const entry of blockersIndex.search(query))
-          addBlocker({ rect: entry, seen, blockers });
-      }
-      const placedLayer = placedIndexByLayer[z];
-      if (placedLayer) {
-        for (const entry of placedLayer.search(query)) {
-          const isFullStack = entry.zLayers.length >= totalLayers;
-          if (!isFullStack) continue;
-          if (isSelfRect({
-            rect: entry,
-            startX,
-            startY,
-            initialW,
-            initialH
-          }))
-            continue;
-          addBlocker({ rect: entry, seen, blockers });
-        }
-      }
-    }
-  };
-  const strategies = [
-    { ox: 0, oy: 0 },
-    { ox: -initialW, oy: 0 },
-    { ox: 0, oy: -initialH },
-    { ox: -initialW, oy: -initialH },
-    { ox: -initialW / 2, oy: -initialH / 2 }
-  ];
-  let best = null;
-  let bestArea = 0;
-  STRATS: for (const s of strategies) {
-    let r = {
-      x: startX + s.ox,
-      y: startY + s.oy,
-      width: initialW,
-      height: initialH
-    };
-    collectBlockers(r);
-    if (lt(r.x, bounds.x) || lt(r.y, bounds.y) || gt(r.x + r.width, bounds.x + bounds.width) || gt(r.y + r.height, bounds.y + bounds.height)) {
-      continue;
-    }
-    for (const b of blockers) if (overlaps(r, b)) continue STRATS;
-    const MIN_EXPANSION = 1e-6;
-    const MAX_ITERATIONS = 1e3;
-    let improved = true;
-    let iterations = 0;
-    while (improved && iterations < MAX_ITERATIONS) {
-      iterations++;
-      improved = false;
-      const commonParams = { bounds, blockers, maxAspect: maxAspectRatio };
-      collectBlockers(searchStripRight({ rect: r, bounds }));
-      const eR = maxExpandRight({ ...commonParams, r });
-      if (eR > MIN_EXPANSION) {
-        r = { ...r, width: r.width + eR };
-        collectBlockers(r);
-        improved = true;
-      }
-      collectBlockers(searchStripDown({ rect: r, bounds }));
-      const eD = maxExpandDown({ ...commonParams, r });
-      if (eD > MIN_EXPANSION) {
-        r = { ...r, height: r.height + eD };
-        collectBlockers(r);
-        improved = true;
-      }
-      collectBlockers(searchStripLeft({ rect: r, bounds }));
-      const eL = maxExpandLeft({ ...commonParams, r });
-      if (eL > MIN_EXPANSION) {
-        r = { x: r.x - eL, y: r.y, width: r.width + eL, height: r.height };
-        collectBlockers(r);
-        improved = true;
-      }
-      collectBlockers(searchStripUp({ rect: r, bounds }));
-      const eU = maxExpandUp({ ...commonParams, r });
-      if (eU > MIN_EXPANSION) {
-        r = { x: r.x, y: r.y - eU, width: r.width, height: r.height + eU };
-        collectBlockers(r);
-        improved = true;
-      }
-    }
-    if (r.width + EPS4 >= minReq.width && r.height + EPS4 >= minReq.height) {
-      const area = r.width * r.height;
-      if (area > bestArea) {
-        best = quantizeRect(r);
-        bestArea = area;
-      }
-    }
-  }
-  return best;
-}
-
-// lib/solvers/RectDiffSeedingSolver/computeDefaultGridSizes.ts
-function computeDefaultGridSizes(bounds) {
-  const ref = Math.max(bounds.width, bounds.height);
-  return [ref / 8, ref / 16, ref / 32];
-}
-
-// lib/utils/isFullyOccupiedAtPoint.ts
-import "rbush";
-function isFullyOccupiedAtPoint(params) {
-  const query = {
-    minX: params.point.x,
-    minY: params.point.y,
-    maxX: params.point.x,
-    maxY: params.point.y
-  };
-  for (let z = 0; z < params.layerCount; z++) {
-    const obstacleIdx = params.obstacleIndexByLayer[z];
-    const hasObstacle = !!obstacleIdx && obstacleIdx.collides(query);
-    const placedIdx = params.placedIndexByLayer[z];
-    const hasPlaced = !!placedIdx && placedIdx.collides(query);
-    if (!hasObstacle && !hasPlaced) return false;
-  }
-  return true;
-}
-
-// lib/solvers/RectDiffSeedingSolver/longestFreeSpanAroundZ.ts
-function longestFreeSpanAroundZ(params) {
-  const {
-    x,
-    y,
-    z,
-    layerCount,
-    minSpan,
-    maxSpan,
-    obstacleIndexByLayer,
-    additionalBlockersByLayer
-  } = params;
-  const isFreeAt = (layer) => {
-    const query = {
-      minX: x,
-      minY: y,
-      maxX: x,
-      maxY: y
-    };
-    const obstacleIdx = obstacleIndexByLayer[layer];
-    if (obstacleIdx && obstacleIdx.collides(query)) return false;
-    const extras = additionalBlockersByLayer?.[layer] ?? [];
-    return !extras.some((b) => containsPoint(b, { x, y }));
-  };
-  let lo = z;
-  let hi = z;
-  while (lo - 1 >= 0 && isFreeAt(lo - 1)) lo--;
-  while (hi + 1 < layerCount && isFreeAt(hi + 1)) hi++;
-  if (typeof maxSpan === "number") {
-    const target = clamp(maxSpan, 1, layerCount);
-    while (hi - lo + 1 > target) {
-      if (z - lo > hi - z) lo++;
-      else hi--;
-    }
-  }
-  const res = [];
-  for (let i = lo; i <= hi; i++) res.push(i);
-  return res.length >= minSpan ? res : [];
-}
-
-// lib/solvers/RectDiffSeedingSolver/computeCandidates3D.ts
-var quantize2 = (value, precision = 1e-6) => Math.round(value / precision) * precision;
-function computeCandidates3D(params) {
-  const {
-    bounds,
-    gridSize,
-    layerCount,
-    obstacleIndexByLayer,
-    placedIndexByLayer,
-    hardPlacedByLayer
-  } = params;
-  const out = /* @__PURE__ */ new Map();
-  const hardRectsByLayer = Array.from({ length: layerCount }, (_, z) => [
-    ...obstacleIndexByLayer[z]?.all() ?? [],
-    ...hardPlacedByLayer[z] ?? []
-  ]);
-  for (let x = bounds.x; x < bounds.x + bounds.width; x += gridSize) {
-    for (let y = bounds.y; y < bounds.y + bounds.height; y += gridSize) {
-      if (Math.abs(x - bounds.x) < EPS4 || Math.abs(y - bounds.y) < EPS4 || x > bounds.x + bounds.width - gridSize - EPS4 || y > bounds.y + bounds.height - gridSize - EPS4) {
-        continue;
-      }
-      if (isFullyOccupiedAtPoint({
-        layerCount,
-        obstacleIndexByLayer,
-        placedIndexByLayer,
-        point: { x, y }
-      }))
-        continue;
-      let bestSpan = [];
-      let bestZ = 0;
-      for (let z = 0; z < layerCount; z++) {
-        const s = longestFreeSpanAroundZ({
-          x,
-          y,
-          z,
-          layerCount,
-          minSpan: 1,
-          maxSpan: void 0,
-          obstacleIndexByLayer,
-          additionalBlockersByLayer: hardPlacedByLayer
-        });
-        if (s.length > bestSpan.length) {
-          bestSpan = s;
-          bestZ = z;
-        }
-      }
-      const anchorZ = bestSpan.length ? bestSpan[Math.floor(bestSpan.length / 2)] : bestZ;
-      const hardAtZ = hardRectsByLayer[anchorZ] ?? [];
-      let d = distancePointToRectEdges({ x, y }, bounds);
-      for (const blocker of hardAtZ) {
-        d = Math.min(d, distancePointToRectEdges({ x, y }, blocker));
-      }
-      const distance = quantize2(d);
-      const k = `${x.toFixed(6)}|${y.toFixed(6)}`;
-      const cand = {
-        x,
-        y,
-        z: anchorZ,
-        distance,
-        zSpanLen: bestSpan.length
-      };
-      const prev = out.get(k);
-      if (!prev || cand.zSpanLen > (prev.zSpanLen ?? 0) || cand.zSpanLen === prev.zSpanLen && cand.distance > prev.distance) {
-        out.set(k, cand);
-      }
-    }
-  }
-  const arr = Array.from(out.values());
-  arr.sort(
-    (a, b) => b.zSpanLen - a.zSpanLen || b.distance - a.distance || a.z - b.z || a.x - b.x || a.y - b.y
-  );
-  return arr;
-}
-
-// lib/solvers/RectDiffSeedingSolver/computeEdgeCandidates3D.ts
-var quantize3 = (value, precision = 1e-6) => Math.round(value / precision) * precision;
-var toRect = (rect) => "minX" in rect ? {
-  x: rect.minX,
-  y: rect.minY,
-  width: rect.maxX - rect.minX,
-  height: rect.maxY - rect.minY
-} : rect;
-function computeUncoveredSegments(params) {
-  const { lineStart, lineEnd, coveringIntervals, minSegmentLength } = params;
-  const lineStartQ = quantize3(lineStart);
-  const lineEndQ = quantize3(lineEnd);
-  const normalizedIntervals = coveringIntervals.map((i) => {
-    const s = quantize3(i.start);
-    const e = quantize3(i.end);
-    return { start: Math.min(s, e), end: Math.max(s, e) };
-  }).filter((i) => i.end > i.start + EPS4);
-  if (normalizedIntervals.length === 0) {
-    const center = (lineStartQ + lineEndQ) / 2;
-    return [{ start: lineStartQ, end: lineEndQ, center }];
-  }
-  const sorted = [...normalizedIntervals].sort((a, b) => a.start - b.start);
-  const merged = [];
-  let current = { ...sorted[0] };
-  for (let i = 1; i < sorted.length; i++) {
-    const interval = sorted[i];
-    if (interval.start <= current.end + EPS4) {
-      current.end = Math.max(current.end, interval.end);
-    } else {
-      merged.push(current);
-      current = { ...interval };
-    }
-  }
-  merged.push(current);
-  const uncovered = [];
-  if (merged[0].start > lineStartQ + EPS4) {
-    const start = lineStartQ;
-    const end = merged[0].start;
-    if (end - start >= minSegmentLength) {
-      uncovered.push({ start, end, center: (start + end) / 2 });
-    }
-  }
-  for (let i = 0; i < merged.length - 1; i++) {
-    const start = merged[i].end;
-    const end = merged[i + 1].start;
-    if (end - start >= minSegmentLength) {
-      uncovered.push({ start, end, center: (start + end) / 2 });
-    }
-  }
-  if (merged[merged.length - 1].end < lineEndQ - EPS4) {
-    const start = merged[merged.length - 1].end;
-    const end = lineEndQ;
-    if (end - start >= minSegmentLength) {
-      uncovered.push({ start, end, center: (start + end) / 2 });
-    }
-  }
-  return uncovered;
-}
-function computeEdgeCandidates3D(params) {
-  const {
-    bounds,
-    minSize,
-    layerCount,
-    obstacleIndexByLayer,
-    placedIndexByLayer,
-    hardPlacedByLayer
-  } = params;
-  const out = [];
-  const \u03B4 = Math.max(minSize * 0.15, EPS4 * 3);
-  const dedup = /* @__PURE__ */ new Set();
-  const hardRectsByLayer = Array.from(
-    { length: layerCount },
-    (_, z) => [
-      ...obstacleIndexByLayer[z]?.all() ?? [],
-      ...hardPlacedByLayer[z] ?? []
-    ].map(toRect)
-  );
-  const key = (p) => `${p.z}|${p.x.toFixed(6)}|${p.y.toFixed(6)}`;
-  function fullyOcc(p) {
-    return isFullyOccupiedAtPoint({
-      layerCount,
-      obstacleIndexByLayer,
-      placedIndexByLayer,
-      point: p
-    });
-  }
-  function pushIfFree(p) {
-    const qx = quantize3(p.x);
-    const qy = quantize3(p.y);
-    const { z } = p;
-    const x = qx;
-    const y = qy;
-    if (x < bounds.x + EPS4 || y < bounds.y + EPS4 || x > bounds.x + bounds.width - EPS4 || y > bounds.y + bounds.height - EPS4)
-      return;
-    if (fullyOcc({ x, y })) return;
-    const hard = hardRectsByLayer[z] ?? [];
-    let d = distancePointToRectEdges({ x, y }, bounds);
-    for (const blocker of hard) {
-      d = Math.min(d, distancePointToRectEdges({ x, y }, blocker));
-    }
-    const distance = quantize3(d);
-    const k = key({ x, y, z });
-    if (dedup.has(k)) return;
-    dedup.add(k);
-    const span = longestFreeSpanAroundZ({
-      x,
-      y,
-      z,
-      layerCount,
-      minSpan: 1,
-      maxSpan: void 0,
-      obstacleIndexByLayer,
-      additionalBlockersByLayer: hardPlacedByLayer
-    });
-    out.push({
-      x,
-      y,
-      z,
-      distance,
-      zSpanLen: span.length,
-      isEdgeSeed: true
-    });
-  }
-  for (let z = 0; z < layerCount; z++) {
-    const blockers = (hardRectsByLayer[z] ?? []).map((b) => ({
-      x: quantize3(b.x),
-      y: quantize3(b.y),
-      width: quantize3(b.width),
-      height: quantize3(b.height)
-    }));
-    const corners = [
-      { x: bounds.x + \u03B4, y: bounds.y + \u03B4 },
-      // top-left
-      { x: bounds.x + bounds.width - \u03B4, y: bounds.y + \u03B4 },
-      // top-right
-      { x: bounds.x + \u03B4, y: bounds.y + bounds.height - \u03B4 },
-      // bottom-left
-      { x: bounds.x + bounds.width - \u03B4, y: bounds.y + bounds.height - \u03B4 }
-      // bottom-right
-    ];
-    for (const corner of corners) {
-      pushIfFree({ x: corner.x, y: corner.y, z });
-    }
-    const topY = bounds.y + \u03B4;
-    const topCovering = blockers.filter((b) => b.y <= topY && b.y + b.height >= topY).map((b) => ({
-      start: Math.max(bounds.x, b.x),
-      end: Math.min(bounds.x + bounds.width, b.x + b.width)
-    }));
-    const topUncovered = computeUncoveredSegments({
-      lineStart: bounds.x + \u03B4,
-      lineEnd: bounds.x + bounds.width - \u03B4,
-      coveringIntervals: topCovering,
-      minSegmentLength: minSize * 0.5
-    });
-    for (const seg of topUncovered) {
-      const segLen = seg.end - seg.start;
-      if (segLen >= minSize) {
-        pushIfFree({ x: seg.center, y: topY, z });
-        if (segLen > minSize * 1.5) {
-          pushIfFree({ x: seg.start + minSize * 0.4, y: topY, z });
-          pushIfFree({ x: seg.end - minSize * 0.4, y: topY, z });
-        }
-      }
-    }
-    const bottomY = bounds.y + bounds.height - \u03B4;
-    const bottomCovering = blockers.filter((b) => b.y <= bottomY && b.y + b.height >= bottomY).map((b) => ({
-      start: Math.max(bounds.x, b.x),
-      end: Math.min(bounds.x + bounds.width, b.x + b.width)
-    }));
-    const bottomUncovered = computeUncoveredSegments({
-      lineStart: bounds.x + \u03B4,
-      lineEnd: bounds.x + bounds.width - \u03B4,
-      coveringIntervals: bottomCovering,
-      minSegmentLength: minSize * 0.5
-    });
-    for (const seg of bottomUncovered) {
-      const segLen = seg.end - seg.start;
-      if (segLen >= minSize) {
-        pushIfFree({ x: seg.center, y: bottomY, z });
-        if (segLen > minSize * 1.5) {
-          pushIfFree({ x: seg.start + minSize * 0.4, y: bottomY, z });
-          pushIfFree({ x: seg.end - minSize * 0.4, y: bottomY, z });
-        }
-      }
-    }
-    const leftX = bounds.x + \u03B4;
-    const leftCovering = blockers.filter((b) => b.x <= leftX && b.x + b.width >= leftX).map((b) => ({
-      start: Math.max(bounds.y, b.y),
-      end: Math.min(bounds.y + bounds.height, b.y + b.height)
-    }));
-    const leftUncovered = computeUncoveredSegments({
-      lineStart: bounds.y + \u03B4,
-      lineEnd: bounds.y + bounds.height - \u03B4,
-      coveringIntervals: leftCovering,
-      minSegmentLength: minSize * 0.5
-    });
-    for (const seg of leftUncovered) {
-      const segLen = seg.end - seg.start;
-      if (segLen >= minSize) {
-        pushIfFree({ x: leftX, y: seg.center, z });
-        if (segLen > minSize * 1.5) {
-          pushIfFree({ x: leftX, y: seg.start + minSize * 0.4, z });
-          pushIfFree({ x: leftX, y: seg.end - minSize * 0.4, z });
-        }
-      }
-    }
-    const rightX = bounds.x + bounds.width - \u03B4;
-    const rightCovering = blockers.filter((b) => b.x <= rightX && b.x + b.width >= rightX).map((b) => ({
-      start: Math.max(bounds.y, b.y),
-      end: Math.min(bounds.y + bounds.height, b.y + b.height)
-    }));
-    const rightUncovered = computeUncoveredSegments({
-      lineStart: bounds.y + \u03B4,
-      lineEnd: bounds.y + bounds.height - \u03B4,
-      coveringIntervals: rightCovering,
-      minSegmentLength: minSize * 0.5
-    });
-    for (const seg of rightUncovered) {
-      const segLen = seg.end - seg.start;
-      if (segLen >= minSize) {
-        pushIfFree({ x: rightX, y: seg.center, z });
-        if (segLen > minSize * 1.5) {
-          pushIfFree({ x: rightX, y: seg.start + minSize * 0.4, z });
-          pushIfFree({ x: rightX, y: seg.end - minSize * 0.4, z });
-        }
-      }
-    }
-    for (const b of blockers) {
-      const obLeftX = b.x - \u03B4;
-      if (obLeftX > bounds.x + EPS4 && obLeftX < bounds.x + bounds.width - EPS4) {
-        const obLeftCovering = blockers.filter(
-          (bl) => bl !== b && bl.x <= obLeftX && bl.x + bl.width >= obLeftX
-        ).map((bl) => ({
-          start: Math.max(b.y, bl.y),
-          end: Math.min(b.y + b.height, bl.y + bl.height)
-        }));
-        const obLeftUncovered = computeUncoveredSegments({
-          lineStart: b.y,
-          lineEnd: b.y + b.height,
-          coveringIntervals: obLeftCovering,
-          minSegmentLength: minSize * 0.5
-        });
-        for (const seg of obLeftUncovered) {
-          pushIfFree({ x: obLeftX, y: seg.center, z });
-        }
-      }
-      const obRightX = b.x + b.width + \u03B4;
-      if (obRightX > bounds.x + EPS4 && obRightX < bounds.x + bounds.width - EPS4) {
-        const obRightCovering = blockers.filter(
-          (bl) => bl !== b && bl.x <= obRightX && bl.x + bl.width >= obRightX
-        ).map((bl) => ({
-          start: Math.max(b.y, bl.y),
-          end: Math.min(b.y + b.height, bl.y + bl.height)
-        }));
-        const obRightUncovered = computeUncoveredSegments({
-          lineStart: b.y,
-          lineEnd: b.y + b.height,
-          coveringIntervals: obRightCovering,
-          minSegmentLength: minSize * 0.5
-        });
-        for (const seg of obRightUncovered) {
-          pushIfFree({ x: obRightX, y: seg.center, z });
-        }
-      }
-      const obTopY = b.y - \u03B4;
-      if (obTopY > bounds.y + EPS4 && obTopY < bounds.y + bounds.height - EPS4) {
-        const obTopCovering = blockers.filter(
-          (bl) => bl !== b && bl.y <= obTopY && bl.y + bl.height >= obTopY
-        ).map((bl) => ({
-          start: Math.max(b.x, bl.x),
-          end: Math.min(b.x + b.width, bl.x + bl.width)
-        }));
-        const obTopUncovered = computeUncoveredSegments({
-          lineStart: b.x,
-          lineEnd: b.x + b.width,
-          coveringIntervals: obTopCovering,
-          minSegmentLength: minSize * 0.5
-        });
-        for (const seg of obTopUncovered) {
-          pushIfFree({ x: seg.center, y: obTopY, z });
-        }
-      }
-      const obBottomY = b.y + b.height + \u03B4;
-      if (obBottomY > bounds.y + EPS4 && obBottomY < bounds.y + bounds.height - EPS4) {
-        const obBottomCovering = blockers.filter(
-          (bl) => bl !== b && bl.y <= obBottomY && bl.y + bl.height >= obBottomY
-        ).map((bl) => ({
-          start: Math.max(b.x, bl.x),
-          end: Math.min(b.x + b.width, bl.x + bl.width)
-        }));
-        const obBottomUncovered = computeUncoveredSegments({
-          lineStart: b.x,
-          lineEnd: b.x + b.width,
-          coveringIntervals: obBottomCovering,
-          minSegmentLength: minSize * 0.5
-        });
-        for (const seg of obBottomUncovered) {
-          pushIfFree({ x: seg.center, y: obBottomY, z });
-        }
-      }
-    }
-  }
-  out.sort(
-    (a, b) => b.zSpanLen - a.zSpanLen || b.distance - a.distance || a.z - b.z || a.x - b.x || a.y - b.y
-  );
-  return out;
-}
-
-// lib/utils/buildHardPlacedByLayer.ts
-function allLayerNode(params) {
-  const out = Array.from({ length: params.layerCount }, () => []);
-  for (const p of params.placed) {
-    if (p.zLayers.length >= params.layerCount) {
-      for (const z of p.zLayers) out[z].push(p.rect);
-    }
-  }
-  return out;
-}
-
-// lib/utils/rectToTree.ts
-var rectToTree = (rect, opts) => ({
-  ...rect,
-  minX: rect.x,
-  minY: rect.y,
-  maxX: rect.x + rect.width,
-  maxY: rect.y + rect.height,
-  zLayers: opts.zLayers
-});
-
-// lib/utils/resizeSoftOverlaps.ts
-function resizeSoftOverlaps(params, newIndex) {
-  const newcomer = params.placed[newIndex];
-  const { rect: newR, zLayers: newZs } = newcomer;
-  const layerCount = params.layerCount;
-  const removeIdx = [];
-  const toAdd = [];
-  for (let i = 0; i < params.placed.length; i++) {
-    if (i === newIndex) continue;
-    const old = params.placed[i];
-    if (old.zLayers.length >= layerCount) continue;
-    const sharedZ = old.zLayers.filter((z) => newZs.includes(z));
-    if (sharedZ.length === 0) continue;
-    if (!overlaps(old.rect, newR)) continue;
-    const parts = subtractRect2D(old.rect, newR);
-    removeIdx.push(i);
-    const unaffectedZ = old.zLayers.filter((z) => !newZs.includes(z));
-    if (unaffectedZ.length > 0) {
-      toAdd.push({ rect: old.rect, zLayers: unaffectedZ });
-    }
-    const minW = Math.min(
-      params.options.minSingle.width,
-      params.options.minMulti.width
-    );
-    const minH = Math.min(
-      params.options.minSingle.height,
-      params.options.minMulti.height
-    );
-    for (const p of parts) {
-      if (p.width + EPS4 >= minW && p.height + EPS4 >= minH) {
-        toAdd.push({ rect: p, zLayers: sharedZ.slice() });
-      }
-    }
-  }
-  const sameRect = (a, b) => a.minX === b.minX && a.minY === b.minY && a.maxX === b.maxX && a.maxY === b.maxY;
-  removeIdx.sort((a, b) => b - a).forEach((idx) => {
-    const rem = params.placed.splice(idx, 1)[0];
-    if (params.placedIndexByLayer) {
-      for (const z of rem.zLayers) {
-        const tree = params.placedIndexByLayer[z];
-        if (tree)
-          tree.remove(
-            rectToTree(rem.rect, { zLayers: rem.zLayers }),
-            sameRect
-          );
-      }
-    }
-  });
-  for (const p of toAdd) {
-    params.placed.push(p);
-    for (const z of p.zLayers) {
-      if (params.placedIndexByLayer) {
-        const idx = params.placedIndexByLayer[z];
-        if (idx) {
-          idx.insert(rectToTree(p.rect, { zLayers: p.zLayers.slice() }));
-        }
-      }
-    }
-  }
-}
-
-// lib/utils/getColorForZLayer.ts
-var getColorForZLayer = (zLayers) => {
-  const minZ = Math.min(...zLayers);
-  const colors = [
-    { fill: "#dbeafe", stroke: "#3b82f6" },
-    { fill: "#fef3c7", stroke: "#f59e0b" },
-    { fill: "#d1fae5", stroke: "#10b981" },
-    { fill: "#e9d5ff", stroke: "#a855f7" },
-    { fill: "#fed7aa", stroke: "#f97316" },
-    { fill: "#fecaca", stroke: "#ef4444" }
-  ];
-  return colors[minZ % colors.length];
-};
-
-// lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver.ts
-import RBush3 from "rbush";
-var RectDiffSeedingSolver = class extends BaseSolver3 {
-  constructor(input) {
-    super();
-    this.input = input;
-  }
-  input;
-  // Engine fields (mirrors initState / engine.ts)
-  srj;
-  layerNames;
-  layerCount;
-  bounds;
-  options;
-  boardVoidRects;
-  gridIndex;
-  candidates;
-  placed;
-  placedIndexByLayer;
-  hardPlacedByLayer;
-  expansionIndex;
-  edgeAnalysisDone;
-  totalSeedsThisGrid;
-  consumedSeedsThisGrid;
-  _setup() {
-    const srj = this.input.simpleRouteJson;
-    const opts = this.input.gridOptions ?? {};
-    const precomputed = this.input.layerNames && this.input.zIndexByName;
-    const { layerNames, zIndexByName } = precomputed ? {
-      layerNames: this.input.layerNames,
-      zIndexByName: this.input.zIndexByName
-    } : buildZIndexMap({
-      obstacles: srj.obstacles,
-      layerCount: srj.layerCount
-    });
-    const layerCount = Math.max(1, layerNames.length, srj.layerCount || 1);
-    const bounds = {
-      x: srj.bounds.minX,
-      y: srj.bounds.minY,
-      width: srj.bounds.maxX - srj.bounds.minX,
-      height: srj.bounds.maxY - srj.bounds.minY
-    };
-    const trace = Math.max(0.01, srj.minTraceWidth || 0.15);
-    const defaults = {
-      gridSizes: [],
-      initialCellRatio: 0.2,
-      maxAspectRatio: 3,
-      minSingle: { width: 2 * trace, height: 2 * trace },
-      minMulti: {
-        width: 4 * trace,
-        height: 4 * trace,
-        minLayers: Math.min(2, Math.max(1, srj.layerCount || 1))
-      },
-      preferMultiLayer: true,
-      maxMultiLayerSpan: void 0
-    };
-    const options = {
-      ...defaults,
-      ...opts,
-      gridSizes: opts.gridSizes ?? // re-use the helper that was previously in engine
-      computeDefaultGridSizes(bounds)
-    };
-    this.srj = srj;
-    this.layerNames = layerNames;
-    this.layerCount = layerCount;
-    this.bounds = bounds;
-    this.options = options;
-    this.boardVoidRects = this.input.boardVoidRects;
-    this.gridIndex = 0;
-    this.candidates = [];
-    this.placed = [];
-    this.placedIndexByLayer = Array.from(
-      { length: layerCount },
-      () => new RBush3()
-    );
-    this.hardPlacedByLayer = Array.from({ length: layerCount }, () => []);
-    this.expansionIndex = 0;
-    this.edgeAnalysisDone = false;
-    this.totalSeedsThisGrid = 0;
-    this.consumedSeedsThisGrid = 0;
-    this.stats = {
-      gridIndex: this.gridIndex
-    };
-  }
-  /** Exactly ONE grid candidate step per call. */
-  _step() {
-    this._stepGrid();
-    this.stats.gridIndex = this.gridIndex;
-    this.stats.placed = this.placed.length;
-  }
-  /**
-   * One micro-step during the GRID phase: handle exactly one candidate.
-   */
-  _stepGrid() {
-    const {
-      gridSizes,
-      initialCellRatio,
-      maxAspectRatio,
-      minSingle,
-      minMulti,
-      preferMultiLayer,
-      maxMultiLayerSpan
-    } = this.options;
-    const grid = gridSizes[this.gridIndex];
-    if (this.candidates.length === 0 && this.consumedSeedsThisGrid === 0) {
-      this.candidates = computeCandidates3D({
-        bounds: this.bounds,
-        gridSize: grid,
-        layerCount: this.layerCount,
-        hardPlacedByLayer: this.hardPlacedByLayer,
-        obstacleIndexByLayer: this.input.obstacleIndexByLayer,
-        placedIndexByLayer: this.placedIndexByLayer
-      });
-      this.totalSeedsThisGrid = this.candidates.length;
-      this.consumedSeedsThisGrid = 0;
-    }
-    if (this.consumedSeedsThisGrid >= this.candidates.length) {
-      if (this.gridIndex + 1 < gridSizes.length) {
-        this.gridIndex += 1;
-        this.candidates = [];
-        this.totalSeedsThisGrid = 0;
-        this.consumedSeedsThisGrid = 0;
-        return;
-      } else {
-        if (!this.edgeAnalysisDone) {
-          const minSize = Math.min(minSingle.width, minSingle.height);
-          this.candidates = computeEdgeCandidates3D({
-            bounds: this.bounds,
-            minSize,
-            layerCount: this.layerCount,
-            obstacleIndexByLayer: this.input.obstacleIndexByLayer,
-            placedIndexByLayer: this.placedIndexByLayer,
-            hardPlacedByLayer: this.hardPlacedByLayer
-          });
-          this.edgeAnalysisDone = true;
-          this.totalSeedsThisGrid = this.candidates.length;
-          this.consumedSeedsThisGrid = 0;
-          return;
-        }
-        this.candidates = [];
-        this.solved = true;
-        this.expansionIndex = 0;
-        return;
-      }
-    }
-    const cand = this.candidates[this.consumedSeedsThisGrid++];
-    if (isFullyOccupiedAtPoint({
-      layerCount: this.layerCount,
-      obstacleIndexByLayer: this.input.obstacleIndexByLayer,
-      placedIndexByLayer: this.placedIndexByLayer,
-      point: { x: cand.x, y: cand.y }
-    })) {
-      return;
-    }
-    const span = longestFreeSpanAroundZ({
-      x: cand.x,
-      y: cand.y,
-      z: cand.z,
-      layerCount: this.layerCount,
-      minSpan: minMulti.minLayers,
-      maxSpan: maxMultiLayerSpan,
-      obstacleIndexByLayer: this.input.obstacleIndexByLayer,
-      additionalBlockersByLayer: this.hardPlacedByLayer
-    });
-    const attempts = [];
-    if (span.length >= minMulti.minLayers) {
-      attempts.push({
-        kind: "multi",
-        layers: span,
-        minReq: { width: minMulti.width, height: minMulti.height }
-      });
-    }
-    attempts.push({
-      kind: "single",
-      layers: [cand.z],
-      minReq: { width: minSingle.width, height: minSingle.height }
-    });
-    const ordered = preferMultiLayer ? attempts : attempts.reverse();
-    for (const attempt of ordered) {
-      const rect = expandRectFromSeed({
-        startX: cand.x,
-        startY: cand.y,
-        gridSize: grid,
-        bounds: this.bounds,
-        obsticalIndexByLayer: this.input.obstacleIndexByLayer,
-        placedIndexByLayer: this.placedIndexByLayer,
-        initialCellRatio,
-        maxAspectRatio,
-        minReq: attempt.minReq,
-        zLayers: attempt.layers
-      });
-      if (!rect) continue;
-      const placed = { rect, zLayers: [...attempt.layers] };
-      const newIndex = this.placed.push(placed) - 1;
-      for (const z of attempt.layers) {
-        const idx = this.placedIndexByLayer[z];
-        if (idx) {
-          idx.insert(rectToTree(rect, { zLayers: placed.zLayers }));
-        }
-      }
-      resizeSoftOverlaps(
-        {
-          layerCount: this.layerCount,
-          placed: this.placed,
-          options: this.options,
-          placedIndexByLayer: this.placedIndexByLayer
-        },
-        newIndex
-      );
-      this.hardPlacedByLayer = allLayerNode({
-        layerCount: this.layerCount,
-        placed: this.placed
-      });
-      return;
-    }
-  }
-  /** Compute solver progress (0 to 1) during GRID phase. */
-  computeProgress() {
-    if (this.solved) {
-      return 1;
-    }
-    const grids = this.options.gridSizes.length;
-    const g = this.gridIndex;
-    const base = g / (grids + 1);
-    const denom = Math.max(1, this.totalSeedsThisGrid);
-    const frac = denom ? this.consumedSeedsThisGrid / denom : 1;
-    return Math.min(0.999, base + frac * (1 / (grids + 1)));
-  }
-  /**
-   * Output the intermediate RectDiff engine data to feed into the
-   * expansion phase solver.
-   */
-  getOutput() {
-    return {
-      layerNames: this.layerNames,
-      layerCount: this.layerCount,
-      bounds: this.bounds,
-      options: this.options,
-      boardVoidRects: this.boardVoidRects,
-      gridIndex: this.gridIndex,
-      candidates: this.candidates,
-      placed: this.placed,
-      expansionIndex: this.expansionIndex,
-      edgeAnalysisDone: this.edgeAnalysisDone,
-      totalSeedsThisGrid: this.totalSeedsThisGrid,
-      consumedSeedsThisGrid: this.consumedSeedsThisGrid,
-      obstacles: this.srj.obstacles,
-      obstacleClearance: this.input.obstacleClearance
-    };
-  }
-  /** Visualization focused on the grid seeding phase. */
-  visualize() {
-    const rects = [];
-    const points = [];
-    const lines = [];
-    const srj = this.srj ?? this.input.simpleRouteJson;
-    const boardBounds = {
-      minX: srj.bounds.minX,
-      maxX: srj.bounds.maxX,
-      minY: srj.bounds.minY,
-      maxY: srj.bounds.maxY
-    };
-    if (srj.outline && srj.outline.length > 1) {
-      lines.push({
-        points: [...srj.outline, srj.outline[0]],
-        strokeColor: "#111827",
-        strokeWidth: 0.01,
-        label: "outline"
-      });
-    } else {
-      rects.push({
-        center: {
-          x: (boardBounds.minX + boardBounds.maxX) / 2,
-          y: (boardBounds.minY + boardBounds.maxY) / 2
-        },
-        width: boardBounds.maxX - boardBounds.minX,
-        height: boardBounds.maxY - boardBounds.minY,
-        fill: "none",
-        stroke: "#111827",
-        label: "board"
-      });
-    }
-    for (const obstacle of srj.obstacles ?? []) {
-      if (obstacle.type === "rect" || obstacle.type === "oval") {
-        rects.push({
-          center: { x: obstacle.center.x, y: obstacle.center.y },
-          width: obstacle.width,
-          height: obstacle.height,
-          fill: "#fee2e2",
-          stroke: "#ef4444",
-          layer: "obstacle",
-          label: "obstacle"
-        });
-      }
-    }
-    if (this.boardVoidRects) {
-      let outlineBBox = null;
-      if (srj.outline && srj.outline.length > 0) {
-        const xs = srj.outline.map((p) => p.x);
-        const ys = srj.outline.map((p) => p.y);
-        const minX = Math.min(...xs);
-        const minY = Math.min(...ys);
-        outlineBBox = {
-          x: minX,
-          y: minY,
-          width: Math.max(...xs) - minX,
-          height: Math.max(...ys) - minY
-        };
-      }
-      for (const r of this.boardVoidRects) {
-        if (outlineBBox && !overlaps(r, outlineBBox)) {
-          continue;
-        }
-        rects.push({
-          center: { x: r.x + r.width / 2, y: r.y + r.height / 2 },
-          width: r.width,
-          height: r.height,
-          fill: "rgba(0, 0, 0, 0.5)",
-          stroke: "none",
-          label: "void"
-        });
-      }
-    }
-    if (this.candidates?.length) {
-      for (const cand of this.candidates) {
-        points.push({
-          x: cand.x,
-          y: cand.y,
-          label: `z:${cand.z}`
-        });
-      }
-    }
-    if (this.placed?.length) {
-      for (const placement of this.placed) {
-        const colors = getColorForZLayer(placement.zLayers);
-        rects.push({
-          center: {
-            x: placement.rect.x + placement.rect.width / 2,
-            y: placement.rect.y + placement.rect.height / 2
-          },
-          width: placement.rect.width,
-          height: placement.rect.height,
-          fill: colors.fill,
-          stroke: colors.stroke,
-          layer: `z${placement.zLayers.join(",")}`,
-          label: `free
-z:${placement.zLayers.join(",")}`
-        });
-      }
-    }
-    return {
-      title: "RectDiff Grid",
-      coordinateSystem: "cartesian",
-      rects,
-      points,
-      lines
-    };
-  }
-};
-
-// lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts
-import { BaseSolver as BaseSolver4 } from "@tscircuit/solver-utils";
-
-// lib/utils/finalizeRects.ts
-function finalizeRects(params) {
-  const out = params.placed.map((p) => ({
-    minX: p.rect.x,
-    minY: p.rect.y,
-    maxX: p.rect.x + p.rect.width,
-    maxY: p.rect.y + p.rect.height,
-    zLayers: [...p.zLayers].sort((a, b) => a - b)
-  }));
-  const layersByKey = /* @__PURE__ */ new Map();
-  for (const obstacle of params.obstacles ?? []) {
-    const baseRect = obstacleToXYRect(obstacle);
-    if (!baseRect) continue;
-    const rect = params.obstacleClearance ? {
-      x: baseRect.x - params.obstacleClearance,
-      y: baseRect.y - params.obstacleClearance,
-      width: baseRect.width + 2 * params.obstacleClearance,
-      height: baseRect.height + 2 * params.obstacleClearance
-    } : baseRect;
-    const zLayers = obstacle.zLayers?.length && obstacle.zLayers.length > 0 ? obstacle.zLayers : obstacleZs(obstacle, params.zIndexByName);
-    const key = `${rect.x}:${rect.y}:${rect.width}:${rect.height}`;
-    let entry = layersByKey.get(key);
-    if (!entry) {
-      entry = { rect, layers: /* @__PURE__ */ new Set() };
-      layersByKey.set(key, entry);
-    }
-    zLayers.forEach((layer) => entry.layers.add(layer));
-  }
-  for (const { rect, layers } of layersByKey.values()) {
-    out.push({
-      minX: rect.x,
-      minY: rect.y,
-      maxX: rect.x + rect.width,
-      maxY: rect.y + rect.height,
-      zLayers: Array.from(layers).sort((a, b) => a - b),
-      isObstacle: true
-    });
-  }
-  return out;
-}
-
-// lib/solvers/RectDiffExpansionSolver/rectsToMeshNodes.ts
-function rectsToMeshNodes(rects) {
-  let id = 0;
-  const out = [];
-  for (const r of rects) {
-    const w = Math.max(0, r.maxX - r.minX);
-    const h = Math.max(0, r.maxY - r.minY);
-    if (w <= 0 || h <= 0 || r.zLayers.length === 0) continue;
-    out.push({
-      capacityMeshNodeId: `cmn_${id++}`,
-      center: { x: (r.minX + r.maxX) / 2, y: (r.minY + r.maxY) / 2 },
-      width: w,
-      height: h,
-      layer: "top",
-      availableZ: r.zLayers.slice(),
-      _containsObstacle: r.isObstacle,
-      _containsTarget: r.isObstacle
-    });
-  }
-  return out;
-}
-
-// lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts
-import RBush4 from "rbush";
-
-// lib/utils/sameTreeRect.ts
-var sameTreeRect = (a, b) => a.minX === b.minX && a.minY === b.minY && a.maxX === b.maxX && a.maxY === b.maxY;
-
-// lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts
-var RectDiffExpansionSolver = class extends BaseSolver4 {
-  constructor(input) {
-    super();
-    this.input = input;
-  }
-  input;
-  placedIndexByLayer = [];
-  _meshNodes = [];
-  _setup() {
-    this.stats = {
-      gridIndex: this.input.gridIndex
-    };
-    this.placedIndexByLayer = Array.from(
-      { length: this.input.layerCount },
-      () => new RBush4()
-    );
-    for (const placement of this.input.placed) {
-      for (const z of placement.zLayers) {
-        const placedIndex = this.placedIndexByLayer[z];
-        if (placedIndex)
-          placedIndex.insert(
-            rectToTree(placement.rect, { zLayers: placement.zLayers })
-          );
-      }
-    }
-  }
-  _step() {
-    if (this.solved) return;
-    this._stepExpansion();
-    this.stats.gridIndex = this.input.gridIndex;
-    this.stats.placed = this.input.placed.length;
-    if (this.input.expansionIndex >= this.input.placed.length) {
-      this.finalizeIfNeeded();
-    }
-  }
-  _stepExpansion() {
-    if (this.input.expansionIndex >= this.input.placed.length) {
-      return;
-    }
-    const idx = this.input.expansionIndex;
-    const p = this.input.placed[idx];
-    const lastGrid = this.input.options.gridSizes[this.input.options.gridSizes.length - 1];
-    const oldRect = p.rect;
-    const expanded = expandRectFromSeed({
-      startX: p.rect.x + p.rect.width / 2,
-      startY: p.rect.y + p.rect.height / 2,
-      gridSize: lastGrid,
-      bounds: this.input.bounds,
-      obsticalIndexByLayer: this.input.obstacleIndexByLayer,
-      placedIndexByLayer: this.placedIndexByLayer,
-      initialCellRatio: 0,
-      maxAspectRatio: null,
-      minReq: { width: p.rect.width, height: p.rect.height },
-      zLayers: p.zLayers
-    });
-    if (expanded) {
-      this.input.placed[idx] = { rect: expanded, zLayers: p.zLayers };
-      for (const z of p.zLayers) {
-        const tree = this.placedIndexByLayer[z];
-        if (tree) {
-          tree.remove(rectToTree(oldRect, { zLayers: p.zLayers }), sameTreeRect);
-          tree.insert(rectToTree(expanded, { zLayers: p.zLayers }));
-        }
-      }
-      resizeSoftOverlaps(
-        {
-          layerCount: this.input.layerCount,
-          placed: this.input.placed,
-          options: this.input.options,
-          placedIndexByLayer: this.placedIndexByLayer
-        },
-        idx
-      );
-    }
-    this.input.expansionIndex += 1;
-  }
-  finalizeIfNeeded() {
-    if (this.solved) return;
-    const rects = finalizeRects({
-      placed: this.input.placed,
-      obstacles: this.input.obstacles,
-      zIndexByName: this.input.zIndexByName,
-      boardVoidRects: this.input.boardVoidRects,
-      obstacleClearance: this.input.obstacleClearance
-    });
-    this._meshNodes = rectsToMeshNodes(rects);
-    this.solved = true;
-  }
-  computeProgress() {
-    if (this.solved) return 1;
-    const grids = this.input.options.gridSizes.length;
-    const base = grids / (grids + 1);
-    const denom = Math.max(1, this.input.placed.length);
-    const frac = denom ? this.input.expansionIndex / denom : 1;
-    return Math.min(0.999, base + frac * (1 / (grids + 1)));
-  }
-  getOutput() {
-    if (this.solved) return { meshNodes: this._meshNodes };
-    const previewNodes = this.input.placed.map(
-      (placement, idx) => ({
-        capacityMeshNodeId: `expand-preview-${idx}`,
-        center: {
-          x: placement.rect.x + placement.rect.width / 2,
-          y: placement.rect.y + placement.rect.height / 2
-        },
-        width: placement.rect.width,
-        height: placement.rect.height,
-        availableZ: placement.zLayers.slice(),
-        layer: `z${placement.zLayers.join(",")}`
-      })
-    );
-    return { meshNodes: previewNodes };
-  }
-  /** Simple visualization of expanded placements. */
-  visualize() {
-    const rects = [];
-    for (const placement of this.input.placed ?? []) {
-      rects.push({
-        center: {
-          x: placement.rect.x + placement.rect.width / 2,
-          y: placement.rect.y + placement.rect.height / 2
-        },
-        width: placement.rect.width,
-        height: placement.rect.height,
-        stroke: "rgba(37, 99, 235, 0.9)",
-        fill: "rgba(191, 219, 254, 0.5)",
-        layer: `z${placement.zLayers.join(",")}`,
-        label: `expanded
-z:${placement.zLayers.join(",")}`
-      });
-    }
-    return {
-      title: "RectDiff Expansion",
-      coordinateSystem: "cartesian",
-      rects,
-      points: [],
-      lines: []
-    };
-  }
-};
-
-// lib/solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline.ts
-import "rbush";
-
-// lib/solvers/RectDiffGridSolverPipeline/buildObstacleIndexes.ts
-import RBush5 from "rbush";
-
-// lib/utils/padRect.ts
-var padRect = (rect, clearance) => {
-  if (!clearance || clearance <= 0) return rect;
-  return {
-    x: rect.x - clearance,
-    y: rect.y - clearance,
-    width: rect.width + 2 * clearance,
-    height: rect.height + 2 * clearance
-  };
-};
-
-// lib/solvers/RectDiffGridSolverPipeline/buildObstacleIndexes.ts
-var buildObstacleIndexesByLayer = (params) => {
-  const { srj, boardVoidRects, obstacleClearance } = params;
-  const { layerNames, zIndexByName } = buildZIndexMap({
-    obstacles: srj.obstacles,
-    layerCount: srj.layerCount
-  });
-  const layerCount = Math.max(1, layerNames.length, srj.layerCount || 1);
-  const bounds = {
-    x: srj.bounds.minX,
-    y: srj.bounds.minY,
-    width: srj.bounds.maxX - srj.bounds.minX,
-    height: srj.bounds.maxY - srj.bounds.minY
-  };
-  const obstacleIndexByLayer = Array.from(
-    { length: layerCount },
-    () => new RBush5()
-  );
-  const insertObstacle = (rect, z) => {
-    const treeRect = {
-      ...rect,
-      minX: rect.x,
-      minY: rect.y,
-      maxX: rect.x + rect.width,
-      maxY: rect.y + rect.height,
-      zLayers: [z]
-    };
-    obstacleIndexByLayer[z]?.insert(treeRect);
-  };
-  if (srj.outline && srj.outline.length > 2) {
-    for (const voidRect of boardVoidRects ?? []) {
-      for (let z = 0; z < layerCount; z++) insertObstacle(voidRect, z);
-    }
-  }
-  for (const obstacle of srj.obstacles ?? []) {
-    const rectBase = obstacleToXYRect(obstacle);
-    if (!rectBase) continue;
-    const rect = padRect(rectBase, obstacleClearance ?? 0);
-    const zLayers = obstacleZs(obstacle, zIndexByName);
-    const invalidZs = zLayers.filter((z) => z < 0 || z >= layerCount);
-    if (invalidZs.length) {
-      throw new Error(
-        `RectDiff: obstacle uses z-layer indices ${invalidZs.join(",")} outside 0-${layerCount - 1}`
-      );
-    }
-    if ((!obstacle.zLayers || obstacle.zLayers.length === 0) && zLayers.length) {
-      obstacle.zLayers = zLayers;
-    }
-    for (const z of zLayers) insertObstacle(rect, z);
-  }
-  return { obstacleIndexByLayer, layerNames, zIndexByName };
-};
-
-// lib/solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline.ts
-var RectDiffGridSolverPipeline = class extends BasePipelineSolver2 {
-  rectDiffSeedingSolver;
-  rectDiffExpansionSolver;
-  obstacleIndexByLayer;
-  layerNames;
-  zIndexByName;
-  constructor(inputProblem) {
-    super(inputProblem);
-    const { obstacleIndexByLayer, layerNames, zIndexByName } = buildObstacleIndexesByLayer({
-      srj: {
-        bounds: inputProblem.bounds,
-        obstacles: inputProblem.obstacles,
-        connections: inputProblem.connections,
-        outline: inputProblem.outline?.outline,
-        layerCount: inputProblem.layerCount,
-        minTraceWidth: inputProblem.minTraceWidth
-      },
-      boardVoidRects: inputProblem.boardVoidRects,
-      obstacleClearance: inputProblem.obstacleClearance
-    });
-    this.obstacleIndexByLayer = obstacleIndexByLayer;
-    this.layerNames = inputProblem.layerNames ?? layerNames;
-    this.zIndexByName = inputProblem.zIndexByName ?? zIndexByName;
-  }
-  pipelineDef = [
-    definePipelineStep2(
-      "rectDiffSeedingSolver",
-      RectDiffSeedingSolver,
-      (pipeline) => [
-        {
-          simpleRouteJson: {
-            bounds: pipeline.inputProblem.bounds,
-            obstacles: pipeline.inputProblem.obstacles,
-            connections: pipeline.inputProblem.connections,
-            outline: pipeline.inputProblem.outline?.outline,
-            layerCount: pipeline.inputProblem.layerCount,
-            minTraceWidth: pipeline.inputProblem.minTraceWidth
-          },
-          gridOptions: pipeline.inputProblem.gridOptions,
-          obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
-          boardVoidRects: pipeline.inputProblem.boardVoidRects,
-          layerNames: pipeline.layerNames,
-          zIndexByName: pipeline.zIndexByName,
-          obstacleClearance: pipeline.inputProblem.obstacleClearance
-        }
-      ]
-    ),
-    definePipelineStep2(
-      "rectDiffExpansionSolver",
-      RectDiffExpansionSolver,
-      (pipeline) => {
-        const output = pipeline.rectDiffSeedingSolver?.getOutput();
-        if (!output) {
-          throw new Error("RectDiffSeedingSolver did not produce output");
-        }
-        return [
-          {
-            layerNames: output.layerNames ?? [],
-            boardVoidRects: pipeline.inputProblem.boardVoidRects ?? [],
-            layerCount: pipeline.inputProblem.layerCount,
-            bounds: output.bounds,
-            candidates: output.candidates,
-            consumedSeedsThisGrid: output.placed.length,
-            totalSeedsThisGrid: output.candidates.length,
-            placed: output.placed,
-            edgeAnalysisDone: output.edgeAnalysisDone,
-            gridIndex: output.gridIndex,
-            expansionIndex: output.expansionIndex,
-            obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
-            options: output.options,
-            zIndexByName: pipeline.zIndexByName,
-            layerNamesCanonical: pipeline.layerNames,
-            obstacles: pipeline.inputProblem.obstacles,
-            obstacleClearance: pipeline.inputProblem.obstacleClearance
-          }
-        ];
-      }
-    )
-  ];
-  getConstructorParams() {
-    return [this.inputProblem];
-  }
-  getOutput() {
-    if (this.rectDiffExpansionSolver) {
-      return this.rectDiffExpansionSolver.getOutput();
-    }
-    if (this.rectDiffSeedingSolver) {
-      const snapshot = this.rectDiffSeedingSolver.getOutput();
-      const meshNodes = snapshot.placed.map(
-        (placement, idx) => ({
-          capacityMeshNodeId: `grid-${idx}`,
-          center: {
-            x: placement.rect.x + placement.rect.width / 2,
-            y: placement.rect.y + placement.rect.height / 2
-          },
-          width: placement.rect.width,
-          height: placement.rect.height,
-          availableZ: placement.zLayers,
-          layer: `z${placement.zLayers.join(",")}`
-        })
-      );
-      return { meshNodes };
-    }
-    return { meshNodes: [] };
-  }
-  visualize() {
-    if (this.rectDiffExpansionSolver) {
-      return this.rectDiffExpansionSolver.visualize();
-    }
-    if (this.rectDiffSeedingSolver) {
-      return this.rectDiffSeedingSolver.visualize();
-    }
-    return {
-      title: "RectDiff Grid Pipeline",
-      coordinateSystem: "cartesian",
-      rects: [],
-      points: [],
-      lines: []
-    };
-  }
-};
-
-// lib/rectdiff-visualization.ts
-function createBaseVisualization(srj, title = "RectDiff") {
-  const rects = [];
-  const lines = [];
-  const boardBounds = {
-    minX: srj.bounds.minX,
-    maxX: srj.bounds.maxX,
-    minY: srj.bounds.minY,
-    maxY: srj.bounds.maxY
-  };
-  if (srj.outline && srj.outline.length > 1) {
-    lines.push({
-      points: [...srj.outline, srj.outline[0]],
-      strokeColor: "#111827",
-      strokeWidth: 0.01,
-      label: "outline"
-    });
-  } else {
-    rects.push({
-      center: {
-        x: (boardBounds.minX + boardBounds.maxX) / 2,
-        y: (boardBounds.minY + boardBounds.maxY) / 2
-      },
-      width: boardBounds.maxX - boardBounds.minX,
-      height: boardBounds.maxY - boardBounds.minY,
-      fill: "none",
-      stroke: "#111827",
-      label: "board"
-    });
-  }
-  for (const obstacle of srj.obstacles ?? []) {
-    if (obstacle.type === "rect" || obstacle.type === "oval") {
-      const layerLabel = (obstacle.zLayers ?? []).join(",") || "all";
-      rects.push({
-        center: { x: obstacle.center.x, y: obstacle.center.y },
-        width: obstacle.width,
-        height: obstacle.height,
-        fill: "#fee2e2",
-        stroke: "#ef4444",
-        layer: "obstacle",
-        label: `obstacle
-z:${layerLabel}`
-      });
-    }
-  }
-  return {
-    title,
-    coordinateSystem: "cartesian",
-    rects,
-    points: [],
-    lines
-  };
-}
-
-// lib/buildFinalRectDiffVisualization.ts
-import { mergeGraphics } from "graphics-debug";
-
-// lib/utils/buildOutlineGraphics.ts
-var buildOutlineGraphics = ({
-  srj
-}) => {
-  const hasOutline = srj.outline && srj.outline.length > 1;
-  const lines = hasOutline ? [
-    {
-      points: [...srj.outline, srj.outline[0]],
-      strokeColor: "#111827",
-      strokeWidth: 0.1,
-      label: "outline"
-    }
-  ] : [
-    {
-      points: [
-        { x: srj.bounds.minX, y: srj.bounds.minY },
-        { x: srj.bounds.maxX, y: srj.bounds.minY },
-        { x: srj.bounds.maxX, y: srj.bounds.maxY },
-        { x: srj.bounds.minX, y: srj.bounds.maxY },
-        { x: srj.bounds.minX, y: srj.bounds.minY }
-      ],
-      strokeColor: "#111827",
-      strokeWidth: 0.1,
-      label: "bounds"
-    }
-  ];
-  return {
-    title: "SimpleRoute Outline",
-    coordinateSystem: "cartesian",
-    lines
-  };
-};
-
-// lib/utils/renderObstacleClearance.ts
-var buildObstacleClearanceGraphics = (params) => {
-  const { srj, clearance } = params;
-  const c = clearance ?? 0;
-  if (c <= 0) {
-    return {
-      title: "Obstacle Clearance",
-      coordinateSystem: "cartesian",
-      rects: []
-    };
-  }
-  const rects = [];
-  for (const obstacle of srj.obstacles ?? []) {
-    if (obstacle.type !== "rect" && obstacle.type !== "oval") continue;
-    const expanded = {
-      x: obstacle.center.x - obstacle.width / 2 - c,
-      y: obstacle.center.y - obstacle.height / 2 - c,
-      width: obstacle.width + 2 * c,
-      height: obstacle.height + 2 * c
-    };
-    rects.push({
-      center: {
-        x: expanded.x + expanded.width / 2,
-        y: expanded.y + expanded.height / 2
-      },
-      width: expanded.width,
-      height: expanded.height,
-      stroke: "rgba(202, 138, 4, 0.9)",
-      fill: "rgba(234, 179, 8, 0.15)",
-      layer: "obstacle-clearance",
-      label: `clearance
-z:${(obstacle.zLayers ?? []).join(",") || "all"}`
-    });
-  }
-  return {
-    title: "Obstacle Clearance",
-    coordinateSystem: "cartesian",
-    rects
-  };
-};
-
-// lib/buildFinalRectDiffVisualization.ts
-var buildFinalRectDiffVisualization = ({
-  srj,
-  meshNodes,
-  obstacleClearance
-}) => {
-  const outline = buildOutlineGraphics({ srj });
-  const clearance = buildObstacleClearanceGraphics({
-    srj,
-    clearance: obstacleClearance
-  });
-  const rects = meshNodes.map((node) => ({
-    center: node.center,
-    width: node.width,
-    height: node.height,
-    stroke: getColorForZLayer(node.availableZ).stroke,
-    fill: node._containsObstacle ? "#fca5a5" : getColorForZLayer(node.availableZ).fill,
-    layer: `z${node.availableZ.join(",")}`,
-    label: `node ${node.capacityMeshNodeId}
-z:${node.availableZ.join(",")}`
-  }));
-  const nodesGraphic = {
-    title: "RectDiffPipeline - Final",
-    coordinateSystem: "cartesian",
-    rects,
-    lines: [],
-    points: [],
-    texts: []
-  };
-  return mergeGraphics(mergeGraphics(nodesGraphic, outline), clearance);
-};
-
-// lib/RectDiffPipeline.ts
-import { mergeGraphics as mergeGraphics2 } from "graphics-debug";
-var RectDiffPipeline = class extends BasePipelineSolver3 {
-  rectDiffGridSolverPipeline;
-  gapFillSolver;
-  boardVoidRects;
-  zIndexByName;
-  layerNames;
-  pipelineDef = [
-    definePipelineStep3(
-      "rectDiffGridSolverPipeline",
-      RectDiffGridSolverPipeline,
-      (rectDiffPipeline) => [
-        {
-          bounds: rectDiffPipeline.inputProblem.simpleRouteJson.bounds,
-          obstacles: rectDiffPipeline.inputProblem.simpleRouteJson.obstacles,
-          connections: rectDiffPipeline.inputProblem.simpleRouteJson.connections,
-          outline: rectDiffPipeline.inputProblem.simpleRouteJson.outline ? { outline: rectDiffPipeline.inputProblem.simpleRouteJson.outline } : void 0,
-          layerCount: rectDiffPipeline.inputProblem.simpleRouteJson.layerCount,
-          gridOptions: rectDiffPipeline.inputProblem.gridOptions,
-          boardVoidRects: rectDiffPipeline.boardVoidRects,
-          layerNames: rectDiffPipeline.layerNames,
-          zIndexByName: rectDiffPipeline.zIndexByName,
-          minTraceWidth: rectDiffPipeline.inputProblem.simpleRouteJson.minTraceWidth,
-          obstacleClearance: rectDiffPipeline.inputProblem.obstacleClearance
-        }
-      ]
-    ),
-    definePipelineStep3(
-      "gapFillSolver",
-      GapFillSolverPipeline,
-      (rectDiffPipeline) => [
-        {
-          meshNodes: rectDiffPipeline.rectDiffGridSolverPipeline?.getOutput().meshNodes ?? [],
-          boardVoid: {
-            boardVoidRects: rectDiffPipeline.boardVoidRects || [],
-            layerCount: rectDiffPipeline.inputProblem.simpleRouteJson.layerCount || 0
-          }
-        }
-      ]
-    )
-  ];
-  _setup() {
-    const { zIndexByName, layerNames } = buildZIndexMap({
-      obstacles: this.inputProblem.simpleRouteJson.obstacles,
-      layerCount: this.inputProblem.simpleRouteJson.layerCount
-    });
-    this.zIndexByName = zIndexByName;
-    this.layerNames = layerNames;
-    if (this.inputProblem.simpleRouteJson.outline) {
-      this.boardVoidRects = computeInverseRects(
-        {
-          x: this.inputProblem.simpleRouteJson.bounds.minX,
-          y: this.inputProblem.simpleRouteJson.bounds.minY,
-          width: this.inputProblem.simpleRouteJson.bounds.maxX - this.inputProblem.simpleRouteJson.bounds.minX,
-          height: this.inputProblem.simpleRouteJson.bounds.maxY - this.inputProblem.simpleRouteJson.bounds.minY
-        },
-        this.inputProblem.simpleRouteJson.outline ?? []
-      );
-    }
-  }
-  getConstructorParams() {
-    return [this.inputProblem];
-  }
-  getOutput() {
-    const gapFillOutput = this.gapFillSolver?.getOutput();
-    if (gapFillOutput) {
-      return { meshNodes: gapFillOutput.outputNodes };
-    }
-    if (this.rectDiffGridSolverPipeline) {
-      return this.rectDiffGridSolverPipeline.getOutput();
-    }
-    return { meshNodes: [] };
-  }
-  initialVisualize() {
-    const base = createBaseVisualization(
-      this.inputProblem.simpleRouteJson,
-      "RectDiffPipeline - Initial"
-    );
-    const clearance = buildObstacleClearanceGraphics({
-      srj: this.inputProblem.simpleRouteJson,
-      clearance: this.inputProblem.obstacleClearance
-    });
-    const initialNodes = this.rectDiffGridSolverPipeline?.getOutput().meshNodes ?? [];
-    const nodeRects = {
-      title: "Initial Nodes",
-      coordinateSystem: "cartesian",
-      rects: initialNodes.map((node) => ({
-        center: node.center,
-        width: node.width,
-        height: node.height,
-        stroke: "rgba(0, 0, 0, 0.3)",
-        fill: "rgba(100, 100, 100, 0.1)",
-        layer: `z${node.availableZ.join(",")}`,
-        label: [
-          `node ${node.capacityMeshNodeId}`,
-          `z:${node.availableZ.join(",")}`
-        ].join("\n")
-      }))
-    };
-    return mergeGraphics2(mergeGraphics2(base, clearance), nodeRects);
-  }
-  finalVisualize() {
-    return buildFinalRectDiffVisualization({
-      srj: this.inputProblem.simpleRouteJson,
-      meshNodes: this.getOutput().meshNodes,
-      obstacleClearance: this.inputProblem.obstacleClearance
-    });
-  }
-};
-export {
-  RectDiffPipeline
-};