/**
 * Process group detection via import graph connectivity (union-find).
 *
 * Replaces the old layer-utils.ts which hardcoded frontend/backend classification.
 * Instead of classifying modules by path keywords, we compute connected components
 * in the non-type-only import graph. Modules whose files share a connected component
 * are in the same OS process. Modules with no import connectivity are in separate
 * processes and may communicate via runtime protocols (HTTP, IPC, queues, etc.).
 */
import type { IndexDatabase } from '../../../db/database-facade.js';
import type { Module } from '../../../db/schema.js';
export interface ProcessGroups {
    /** moduleId → groupId */
    moduleToGroup: Map<number, number>;
    /** groupId → modules in that group */
    groupToModules: Map<number, Module[]>;
    /** Number of distinct process groups */
    groupCount: number;
}
/**
 * Compute process groups from import graph connectivity.
 *
 * 1. Get all file→module mappings
 * 2. Get runtime (non-type-only) import edges between files
 * 3. Union-find on file IDs using the edges → each file gets a group representative
 * 4. Map each module to its group via its files' representatives (majority vote)
 * 5. Build the ProcessGroups result
 */
export declare function computeProcessGroups(db: IndexDatabase): ProcessGroups;
/**
 * Check if two modules are in the same process group.
 */
export declare function areSameProcess(fromId: number, toId: number, groups: ProcessGroups): boolean;
/**
 * Human-readable description of the process relationship between two modules.
 */
export declare function getProcessDescription(fromId: number, toId: number, groups: ProcessGroups): string;
/**
 * Derive a label for a process group from its modules' common ancestor path.
 *
 * - If all modules start with `project.frontend.*` → label is "frontend"
 * - If mixed → use the depth-1 ancestors as the label (e.g., "backend, shared")
 */
export declare function getProcessGroupLabel(modules: Module[]): string;
/**
 * Get all pairs of process groups for cross-process inference.
 * Returns pairs of (groupA modules, groupB modules) for each unique group pair.
 * Excludes singleton groups — a single-module group has no internal structure
 * worth inferring cross-process communication for.
 */
export declare function getCrossProcessGroupPairs(groups: ProcessGroups): Array<[Module[], Module[]]>;
//# sourceMappingURL=process-utils.d.ts.map