/** 작업 이름 — 새 작업을 재기 시작하면 여기 늘린다(문자열을 자유롭게 쓰지 않는다: 오타가 새 칸이 된다). */
export declare const LOAD_PHASES: readonly ["tick", "snapshot", "deltas", "publish", "journal", "ingest", "forecast", "forkTick", "warmStart", "stimulus"];
export type LoadPhase = (typeof LOAD_PHASES)[number];
export interface PhaseStats {
    /** 잰 횟수. */
    count: number;
    /** 마지막 소요(ms). */
    lastMs: number;
    /** 가장 오래 걸린 것(ms) — 평균은 순간 정체를 가린다. */
    maxMs: number;
    /** 소요 합(ms). 나눗셈은 읽는 쪽에서 한다. */
    totalMs: number;
}
/** 창(window) 하나의 누적 — "지금 얼마나 쓰고 있나" 를 답한다. */
interface Window {
    /** 창이 열린 시각. **아직 안 열렸으면 `-1`** — 0 으로 두면 시각 0 과 구별이 안 된다(검사가 잡았다). */
    startMs: number;
    phases: Partial<Record<LoadPhase, PhaseStats>>;
}
export interface LoadMeter {
    /** **누적** — 프로세스가 뜬 뒤 전부. 총량과 최악값을 본다. */
    phases: Partial<Record<LoadPhase, PhaseStats>>;
    /** 지금 쌓고 있는 창. */
    window: Window;
    /** **마지막으로 닫힌 창** — 이것이 "실시간" 이다. 없으면 아직 한 창도 안 지났다. */
    recent: (Window & {
        endMs: number;
    }) | null;
    /** 이 트윈에서 만들어진 fork 수(누적) — 예측 한 번이 수십 개를 만든다. */
    forksCreated: number;
    /** 한 주기(틱)가 예산을 넘긴 횟수. */
    overBudget: number;
    /**
     * 마지막 경고 시각(ms). **한 번도 안 했으면 `-Infinity`** — 0 으로 두면 "0 시점에 경고했다" 가 되어
     * 첫 느린 틱이 알리지 않고 지나간다(검사가 그것을 잡았다).
     */
    lastWarnMs: number;
}
export declare function newLoadMeter(): LoadMeter;
/**
 * 예산 — 틱 간격의 절반. 넘으면 루프의 절반을 이 트윈 하나가 쓰고 있다는 뜻이다.
 *
 * 절반인 이유: 트윈이 여럿이라 각자 간격을 다 쓰면 이미 포화다. 절반에서 알아야 손 쓸 틈이 있다.
 */
export declare const TICK_BUDGET_RATIO = 0.5;
/** 경고를 다시 낼 때까지의 최소 간격(ms) — 느린 트윈은 매 틱 느리므로, 그대로 두면 로그가 원인을 덮는다. */
export declare const WARN_COOLDOWN_MS = 30000;
/**
 * 한 작업의 소요를 기록한다. **누적만 하고 판단하지 않는다.**
 *
 * 음수·NaN 은 기록하지 않는다(시계가 뒤로 간 경우). 없는 값을 0 으로 세면 평균이 거짓이 된다.
 */
export declare function recordPhase(meter: LoadMeter, phase: LoadPhase, tookMs: number, nowMs?: number): void;
/** fork 하나가 만들어졌다 — 예측 한 번이 수십 개를 만든다. 수를 알아야 부하의 출처를 짚는다. */
export declare function recordFork(meter: LoadMeter, count?: number): void;
/** 실시간 창의 길이(ms) — 이보다 길게 보려면 누적을 본다. */
export declare const WINDOW_MS = 10000;
/** 창이 다 찼으면 닫고 새로 연다. **닫힌 창만 "최근" 으로 읽는다** — 채우는 중인 창은 과소 집계다. */
export declare function rollWindow(meter: LoadMeter, nowMs: number, windowMs?: number): void;
/**
 * 이 주기가 예산을 넘었나 — 넘었으면 세고, **말할 때인지**까지 답한다.
 */
export declare function judgeCycle(meter: LoadMeter, tookMs: number, tickMs: number, nowMs: number, budgetRatio?: number, cooldownMs?: number): {
    over: boolean;
    warn: boolean;
    budgetMs: number;
};
export interface PhaseRow {
    phase: LoadPhase;
    count: number;
    lastMs: number;
    maxMs: number;
    avgMs: number;
    totalMs: number;
    /** 잰 작업 전체 시간 중 이 작업의 몫(0~1). 어디를 고칠지 이 값이 정한다. */
    share: number;
}
export interface LoadView {
    phases: PhaseRow[];
    measuredTotalMs: number;
    /** 이 구간의 길이(ms). 누적은 프로세스 기동 이후라 알 수 없으므로 `null`. */
    spanMs: number | null;
    /** 구간 중 몇 %를 이 트윈이 썼나(0~1+). 구간을 모르면 `null` — **0 이 아니다.** */
    busyRatio: number | null;
}
/**
 * 읽기용 요약 — **실시간과 누적을 함께** 낸다.
 *
 *  · `recent` — 마지막으로 **닫힌** 창. 지금 이 트윈이 루프를 얼마나 쓰고 있나. 채우는 중인 창은
 *    과소 집계라 쓰지 않는다.
 *  · `total` — 기동 이후 전부. 총량과 최악값.
 *
 * 잰 적이 없으면 **`null` 이다.** 0 으로 채우면 "0ms 다"(= 아주 빠르다)로 읽혀, 재지 않은 것과 정반대의
 * 뜻이 된다. 몫(`share`)도 잰 작업들 사이의 비율일 뿐 — **재지 않은 작업은 분모에 없다.**
 */
export declare function loadSummary(meter: LoadMeter | undefined, tickMs: number): {
    recent: LoadView | null;
    total: LoadView | null;
    forksCreated: number;
    overBudget: number;
    budgetMs: number;
    /** 마지막 틱이 간격을 얼마나 썼나(0~1+). 1 이면 간격을 통째로 쓴다. */
    loadRatio: number | null;
} | null;
/**
 * 경고 한 줄 — **무엇이 느린지까지 말한다.** "틱이 800ms" 만으로는 어디를 볼지 알 수 없다.
 *
 * 가장 무거운 작업 셋을 몫과 함께 적는다.
 */
export declare function slowTickMessage(instanceId: string, tookMs: number, budgetMs: number, meter: LoadMeter): string;
/**
 * 전체 한눈에 — **누가 루프를 점유하고 있나.**
 *
 * 인스턴스 목록을 받아 대수·모드별 수·fork 총수를 세고, **최근 창의 부하가 큰 순서**로 줄을 세운다.
 * 누적이 아니라 최근으로 세우는 이유: 지금 아픈 것을 먼저 봐야 한다(누적 1위는 오래 떠 있던 것일 뿐일
 * 수 있다).
 */
export declare function fleetLoad(rows: {
    instanceId: string;
    mode: string;
    domainId?: string;
    domainLabel?: string;
    meter?: LoadMeter;
}[], tickMs: number): {
    instances: number;
    byMode: Record<string, number>;
    /**
     * **테넌트별 몫** — 운영자가 먼저 묻는 것은 "어느 테넌트가 루프를 먹나" 다.
     *
     * 실측으로 필요해졌다: 한 도메인 트윈 22개가 CPU 를 110% 쓰는 동안 다른 도메인 화면은 0 이었다.
     * 무거운 순으로 낸다. 몫은 **잰 트윈들 사이의 비율**이다(안 잰 트윈은 분모에 없다).
     */
    byDomain: {
        domainId: string;
        label: string;
        instances: number;
        recentBusyMs: number;
        share: number;
    }[];
    forksCreated: number;
    /** 최근 창에서 트윈들이 쓴 시간의 합(ms) — 창 길이를 넘으면 루프가 이미 밀리고 있다. */
    recentBusyMs: number;
    /** 그 창의 길이(ms). 창이 하나도 안 닫혔으면 `null`. */
    recentSpanMs: number | null;
    /** 전체가 루프를 얼마나 쓰나(0~1+). 1 을 넘으면 **한 틱 안에 다 못 끝낸다.** */
    fleetBusyRatio: number | null;
    slowest: {
        instanceId: string;
        mode: string;
        domainId?: string;
        domainLabel?: string;
        recentBusyMs: number;
        topPhase: LoadPhase | null;
        overBudget: number;
    }[];
};
/**
 * 프로세스가 실제로 쓴 CPU — **계기판의 다른 숫자들과 뜻이 다르다.**
 *
 * 이 파일의 다른 값들은 트윈의 **계측된 8개 작업**만 잰 것이다. 그런데 프로세스는 그 밖에도 일한다:
 * GraphQL·TypeORM·GC·webpack·HTTP. 그래서 "루프 점유 <1%" 인데 CPU 는 110% 일 수 있고, 실제로 그런
 * 상태를 겪었다. 두 숫자를 나란히 두면 **트윈이 범인인지 아닌지**를 바로 가릴 수 있다.
 *
 * 코어 여러 개를 쓰면 1 을 넘을 수 있다(운영체제의 `%CPU` 와 같은 뜻).
 */
export type CpuSampler = {
    lastMicros: number;
    lastMs: number;
};
/** 첫 표본은 비교 대상이 없다 — `-1` 로 두어 "아직 모른다" 와 0 을 구별한다. */
export declare function newCpuSampler(): CpuSampler;
/**
 * 두 표본 사이의 CPU 점유율. 처음 부르면 `null`(0 이 아니다 — 잰 구간이 없다).
 *
 * @param totalMicros `process.cpuUsage()` 의 user + system (마이크로초 누적)
 */
export declare function sampleCpu(s: CpuSampler, totalMicros: number, nowMs: number): {
    ratio: number;
    spanMs: number;
} | null;
export {};