/**
 * rgui core — semantic-zoom LOD (level of detail).
 *
 * Render rule: readability is a SCREEN-space property. Whatever an element's
 * world size is, at the current viewer scale it must either be drawn readable
 * or be replaced by a readable abstraction.
 *
 * When a group of sibling nodes falls below the readability threshold, the
 * group collapses into one pseudo-node drawn at constant screen size, showing
 * only the group's OPEN ports (ports wired across the group boundary, or
 * unconnected). Internal wires are hidden; boundary wires reroute to the
 * pseudo-node's ports.
 */
import { type Edge, type Graph, type GraphNode, type Port } from "./graph.js";
import { type RgRule } from "./rule.js";
export interface PseudoNode {
    id: string;
    title: string;
    /** world center of the member bounding box (may be shifted by declutter) */
    cx: number;
    cy: number;
    /** world size of the member ENCLOSURE (the merged block occupies the
     * footprint of what it replaced, clamped to a readable minimum) */
    bw: number;
    bh: number;
    members: GraphNode[];
    inputs: Port[];
    outputs: Port[];
    /** set for singleton pseudo-nodes (an unreadable ungrouped node) */
    category?: GraphNode["category"];
}
export type EndpointRef = {
    at: "node";
    node: GraphNode;
    side: "in" | "out";
    index: number;
} | {
    at: "pseudo";
    pseudo: PseudoNode;
    side: "in" | "out";
    index: number;
};
export interface RenderEdge {
    from: EndpointRef;
    to: EndpointRef;
    kind: Port["kind"];
    dashed?: boolean;
    /** the original graph edge this render edge represents */
    source: Edge;
}
export interface RenderGraph {
    nodes: GraphNode[];
    pseudo: PseudoNode[];
    edges: RenderEdge[];
}
/**
 * pseudo-node rect in world units at scale k: the members' enclosure,
 * never smaller than the readable minimum (screen px)
 */
export declare function pseudoRect(p: PseudoNode, k: number, rule?: RgRule): {
    x: number;
    y: number;
    w: number;
    h: number;
};
export declare function pseudoPortPos(p: PseudoNode, side: "in" | "out", i: number, k: number, rule?: RgRule): [number, number];
export declare function endpointPos(ref: EndpointRef, k: number, rule?: RgRule): [number, number];
/** Build the LOD render graph for the current viewer scale. */
export declare function buildRenderGraph(graph: Graph, k: number, rule?: RgRule, 
/**
 * screen linear map applied AFTER k (viewport 3-D rotation): apparent
 * sizes/gaps shrink under foreshortening, so visually converging nodes
 * merge — a pure rendering trick, base positions never change
 */
xform?: readonly [number, number, number, number], 
/**
 * RG MONOTONICITY: memberships carried from the previous (finer) scale —
 * while zooming out, an already-merged block never releases its children.
 * Pass pairs from the last build's pseudo members when k decreased;
 * omit when zooming in so blocks re-expand.
 */
carry?: readonly [string, string][]): RenderGraph;
//# sourceMappingURL=lod.d.ts.map