/**
 * True when drift telemetry is being watched — the `@colyseus/sdk/debug` overlay
 * is loaded (its live receiver on `globalThis.__colyseusDebug` is what the panel
 * reads). Reconcilers skip ALL drift/correction bookkeeping when this is false
 * and no `warnOnDivergence` tolerance is set, so a production build that imports
 * neither pays nothing for the diagnostic.
 *
 * Delegates to {@link debugOverlayActive} so the pre-load PUBLISH BUFFER (which a
 * plain `Predict`/room publish now installs even without the overlay) doesn't
 * read as active — only the overlay's live receiver flips this on.
 */
export declare function diagnosticsActive(): boolean;
/**
 * Wiring warning, fired (once per controller) when a render value was read
 * BETWEEN `predict.tick()` and the frame's `input.send()` calls. Such a read is
 * one fixed step stale — the render interpolation clamps at the latest applied
 * step (it never extrapolates), so on late step-boundary frames the read
 * flat-tops, and frame jitter renders as visible stutter on fast objects.
 * Default-on (like the input replay-buffer overflow warning): this is a frame-
 * order bug with an established fix, not tuning telemetry.
 */
export declare function warnReadBeforePump(): void;
/**
 * Dev-only memo collision warning ({@link diagnosticsActive}-gated, warn-once
 * per key per store). Fired when two `ctx.memo` calls in ONE step land on the
 * same slot — two key-less calls, or the same explicit key twice. The live
 * calls each run their compute (last write wins the slot), but every replay of
 * that seq returns the ONE frozen value to both call sites — a silent,
 * latency-dependent re-simulation corruption. Warns instead of throwing: a
 * single key-less memo per step is the common, correct form.
 */
export declare function warnMemoCollision(tick: number, key: string): void;
/**
 * Dev-only divergence warning, wired by the opt-in `warnOnDivergence` tolerance
 * on a {@link Reconciler}/{@link SimReconciler}. Fired when the reconciler's
 * verdict is `diverging` (the *persistent* drift `ema` crossed the tolerance —
 * NOT a single jitter spike), throttled to one warning per second across all
 * reconcilers so a sustained divergence doesn't flood the console.
 *
 * The reconcile correction IS the client-vs-server divergence (the client
 * already holds the server's authoritative state it reconciles against), so this
 * needs no extra wire traffic. It names the input seq, the worst field + its
 * signed delta, and the usual cause — actionable, not just "something's off".
 */
export declare function warnDivergence(acked: number, lastCorrection: Record<string, number>, ema: number, tolerance: number): void;