/**
 * AdaptiveFrameRateManager
 *
 * Classifies thermal pressure from proxy signals (frame time, dropped frames)
 * and emits state-change callbacks that downstream systems (QualityManager)
 * consume to shed workload.
 */
type ThermalState = 'cool' | 'warm' | 'hot' | 'critical';
interface ThermalThresholds {
    warmFrameTimeMs: number;
    hotFrameTimeMs: number;
    criticalFrameTimeMs: number;
    warmDroppedFrames: number;
    hotDroppedFrames: number;
    criticalDroppedFrames: number;
}
declare const DEFAULT_THRESHOLDS: ThermalThresholds;
interface FrameSample {
    deltaTimeMs: number;
    dropped: number;
}
interface AdaptiveFrameRateManagerOptions {
    thresholds?: Partial<ThermalThresholds>;
    maxHistory?: number;
    classificationWindow?: number;
}
declare class AdaptiveFrameRateManager {
    private readonly thresholds;
    private readonly history;
    private readonly callbacks;
    private readonly maxHistory;
    private readonly classificationWindow;
    private currentState;
    constructor(options?: AdaptiveFrameRateManagerOptions);
    recordFrame(deltaTimeMs: number, droppedFrames?: number): void;
    getThermalState(): ThermalState;
    getHistory(): readonly FrameSample[];
    onStateChange(callback: (state: ThermalState, previous: ThermalState) => void): () => void;
    private classify;
    private notify;
}

/**
 * QualityManager
 *
 * Applies quality overrides (LOD bias, Gaussian budget shedding, feature
 * disabling) in response to thermal-state changes from AdaptiveFrameRateManager.
 */

interface LODPolicy {
    /** Offset added to the base LOD level (positive = lower detail). */
    biasDelta: number;
    /** Hard cap on LOD level; undefined means no override. */
    maxLevelOverride?: number;
    /** Render features disabled at this thermal tier. */
    disabledFeatures: RenderFeature[];
}
type RenderFeature = 'shadows' | 'reflections' | 'particles' | 'postProcessing' | 'ambientOcclusion' | 'antiAliasing';
interface GaussianBudget {
    /** Maximum number of 3D Gaussian splats. */
    maxSplats: number;
    /** Maximum memory footprint in megabytes. */
    maxMemoryMB: number;
}
interface QualityPolicy {
    cool: LODPolicy & {
        gaussian: GaussianBudget;
    };
    warm: LODPolicy & {
        gaussian: GaussianBudget;
    };
    hot: LODPolicy & {
        gaussian: GaussianBudget;
    };
    critical: LODPolicy & {
        gaussian: GaussianBudget;
    };
}
declare const DEFAULT_QUALITY_POLICY: QualityPolicy;
declare class QualityManager {
    private readonly policy;
    private currentState;
    constructor(policy?: Partial<QualityPolicy>);
    applyThermalPolicy(state: ThermalState): void;
    getCurrentState(): ThermalState;
    getLODPolicy(): LODPolicy;
    getGaussianBudget(): GaussianBudget;
    shouldShedFeature(feature: RenderFeature): boolean;
    getEffectiveBudgetRatio(): number;
}

/**
 * RenderInferenceSeparation
 *
 * Keeps inference work (model evaluation, trait embedding lookup, synthetic-
 * data generation, etc.) from stalling the render thread.
 *
 * Four primitives:
 *   RenderSafeInferenceReader  – non-blocking result consumption
 *   InferenceIsolationBarrier  – tracks what work is in-flight / isolated
 *   FrameDeadlineEnforcer      – per-frame CPU budget guard
 *   InferencePriorityScheduler – priority queue + preemption
 *
 * All classes are single-threaded; marshal across a worker boundary yourself
 * if you need true thread isolation.
 */
type InferencePriority = 'critical' | 'high' | 'normal' | 'low';
interface InferenceTask<TInput = unknown, TOutput = unknown> {
    readonly id: string;
    readonly priority: InferencePriority;
    readonly input: TInput;
    readonly createdAt: number;
    execute(): TOutput | Promise<TOutput>;
}
interface InferenceResult<TOutput = unknown> {
    readonly taskId: string;
    readonly output: TOutput;
    readonly startedAt: number;
    readonly finishedAt: number;
}
interface InferenceMetrics {
    /** Number of tasks currently queued. */
    queueDepth: number;
    /** Number of tasks actively executing (inside the barrier). */
    inFlight: number;
    /** Total completed since creation. */
    completed: number;
    /** Total dropped (deadline exceeded or pre-empted) since creation. */
    dropped: number;
    /** Average latency (ms) of the last N completed tasks. */
    averageLatencyMs: number;
    /** Percentage of frames in the recent window that missed the deadline. */
    deadlineMissRate: number;
}
interface RenderSafeInferenceReaderOptions {
    /** Max results to retain before back-pressure drops oldest. */
    maxBufferedResults?: number;
}
/**
 * Consumes inference results without blocking the render loop.
 * Producers push results; the renderer polls `drain()` once per frame.
 */
declare class RenderSafeInferenceReader<TOutput = unknown> {
    private readonly buffer;
    private readonly maxBuffered;
    constructor(options?: RenderSafeInferenceReaderOptions);
    /** Called by the inference side when a task finishes. */
    push(result: InferenceResult<TOutput>): void;
    /** Called once per frame by the renderer. Returns all buffered results. */
    drain(): InferenceResult<TOutput>[];
    peek(): readonly InferenceResult<TOutput>[];
    get bufferedCount(): number;
}
interface InferenceIsolationBarrierOptions {
    /** Max concurrent inference tasks allowed. */
    maxConcurrency?: number;
}
/**
 * Tracks which tasks are currently executing inside the "isolated"
 * inference zone. Prevents render-thread re-entrancy and enforces a
 * concurrency ceiling.
 */
declare class InferenceIsolationBarrier {
    private readonly maxConcurrency;
    private inFlight;
    constructor(options?: InferenceIsolationBarrierOptions);
    /** Attempt to enter the barrier. Returns false if at capacity. */
    enter(taskId: string): boolean;
    exit(taskId: string): void;
    get activeCount(): number;
    get remainingSlots(): number;
}
interface FrameDeadlineEnforcerOptions {
    /** Target frame time in ms (default 16.67 for 60 Hz). */
    targetFrameTimeMs?: number;
    /** Fraction of the frame reserved for inference (0..1). Default 0.3. */
    inferenceBudgetRatio?: number;
    /** History window for miss-rate calculation. */
    missRateWindow?: number;
}
/**
 * Ensures inference does not consume more than its allotted slice of a
 * frame. Tracks historical miss rate for telemetry.
 */
declare class FrameDeadlineEnforcer {
    readonly targetFrameTimeMs: number;
    readonly inferenceBudgetMs: number;
    private readonly history;
    private readonly windowSize;
    constructor(options?: FrameDeadlineEnforcerOptions);
    /** Call at the start of inference work for this frame. */
    beginFrame(now?: number): number;
    /**
     * Call after inference work finishes. Returns `true` if the work stayed
     * within budget, `false` if it exceeded the deadline.
     */
    endFrame(startedAt: number, now?: number): boolean;
    get missRate(): number;
    /** Remaining budget for the current frame (may be negative). */
    remainingBudgetMs(startedAt: number, now?: number): number;
}
interface InferencePrioritySchedulerOptions {
    barrier?: InferenceIsolationBarrier;
    reader?: RenderSafeInferenceReader;
    enforcer?: FrameDeadlineEnforcer;
    /** Latency averaging window. */
    latencyWindow?: number;
}
/**
 * Priority queue + execution loop. Tasks are ordered by priority then FIFO.
 * The scheduler respects the barrier concurrency limit and the frame deadline.
 * Completed results are pushed to the RenderSafeInferenceReader.
 */
declare class InferencePriorityScheduler {
    private readonly queue;
    private readonly barrier;
    readonly reader: RenderSafeInferenceReader;
    readonly enforcer: FrameDeadlineEnforcer;
    private completed;
    private dropped;
    private readonly latencies;
    private readonly latencyWindow;
    constructor(options?: InferencePrioritySchedulerOptions);
    /** Enqueue a task. */
    schedule<TInput, TOutput>(task: InferenceTask<TInput, TOutput>): void;
    /**
     * Run scheduling for the current frame. Returns the number of tasks
     * started. Must be called from the render loop (or a worker tick).
     */
    tick(now?: number): number;
    private recordLatency;
    getMetrics(): InferenceMetrics;
    clear(): void;
}

/**
 * VRPerformanceBudget
 *
 * Allocates and tracks per-frame CPU/GPU/render/inference budgets so that
 * the renderer can adapt before it misses the next VSync.
 *
 * Integrates with HololandRenderer.update() — call beginFrame() at the start
 * of the frame and endFrame() after all work is submitted.
 */
type BudgetCategory = 'render' | 'inference' | 'gpu' | 'cpu';
interface BudgetConfig {
    /** Target frame time in ms (default 16.67 for 60 Hz, 11.11 for 90 Hz). */
    targetFrameTimeMs: number;
    /** Fraction of the frame reserved for each category (must sum ≤ 1.0). */
    allocations: Record<BudgetCategory, number>;
    /** Number of historical frames to keep for averaging. */
    historyWindow: number;
}
interface BudgetSnapshot {
    category: BudgetCategory;
    budgetMs: number;
    usedMs: number;
    remainingMs: number;
    overBudget: boolean;
}
interface FrameBudgetReport {
    frameTimeMs: number;
    categories: BudgetSnapshot[];
    anyOverBudget: boolean;
    totalUsedMs: number;
    headroomMs: number;
}
declare const DEFAULT_BUDGET_CONFIG: BudgetConfig;
interface VRPerformanceBudgetOptions {
    targetFrameTimeMs?: number;
    allocations?: Partial<Record<BudgetCategory, number>>;
    historyWindow?: number;
}
declare class VRPerformanceBudget {
    private readonly config;
    private readonly usage;
    private frameStart;
    private readonly history;
    constructor(options?: VRPerformanceBudgetOptions);
    /** Call at the very start of the render frame. */
    beginFrame(now?: number): void;
    /** Record how much time a category consumed this frame. */
    recordUsage(category: BudgetCategory, ms: number): void;
    /** Call after all frame work is submitted. Returns the full report. */
    endFrame(now?: number): FrameBudgetReport;
    /** Current report from the most recent ended frame. */
    getLastReport(): FrameBudgetReport | null;
    /** Categories that exceeded their budget in the last frame. */
    getOverBudgetCategories(): BudgetCategory[];
    /** Rolling average frame time over the history window. */
    getAverageFrameTimeMs(): number;
    /** Fraction of historical frames that were over budget in any category. */
    getOverBudgetRate(): number;
    /** Remaining budget for a category in the current (open) frame. */
    getRemaining(category: BudgetCategory, now?: number): number;
    getTargetFrameTimeMs(): number;
    getAllocations(): Readonly<Record<BudgetCategory, number>>;
}

/**
 * HololandRenderer
 *
 * Orchestrates AdaptiveFrameRateManager and QualityManager so that thermal
 * pressure automatically drives LOD reduction, feature shedding, and
 * Gaussian-budget downgrades.
 *
 * Since 2026-05-09: also wires render-inference separation so that ML
 * inference work (trait embedding, motion matching, etc.) is scheduled on a
 * dedicated priority queue with frame-deadline enforcement.
 */

interface HololandRendererOptions {
    adaptiveFrameRate?: AdaptiveFrameRateManager;
    qualityManager?: QualityManager;
    inferenceScheduler?: InferencePriorityScheduler;
    performanceBudget?: VRPerformanceBudget;
}
declare class HololandRenderer {
    readonly adaptive: AdaptiveFrameRateManager;
    readonly quality: QualityManager;
    readonly inference: InferencePriorityScheduler;
    readonly budget: VRPerformanceBudget;
    private unsubscribe;
    private disposed;
    constructor(options?: HololandRendererOptions);
    /** Call once per frame with the measured delta time and dropped-frame count. */
    update(deltaTimeMs: number, droppedFrames?: number): void;
    getThermalState(): ThermalState;
    /** Drain inference results produced since the last frame. Non-blocking. */
    drainInferenceResults(): InferenceResult[];
    /** Current inference queue depth, latency, and deadline miss rate. */
    getInferenceMetrics(): InferenceMetrics;
    /** Latest frame budget report (null before the first update()). */
    getBudgetReport(): FrameBudgetReport | null;
    dispose(): void;
}

export { AdaptiveFrameRateManager, type AdaptiveFrameRateManagerOptions, type BudgetCategory, type BudgetConfig, type BudgetSnapshot, DEFAULT_BUDGET_CONFIG, DEFAULT_QUALITY_POLICY, DEFAULT_THRESHOLDS, type FrameBudgetReport, FrameDeadlineEnforcer, type FrameDeadlineEnforcerOptions, type FrameSample, type GaussianBudget, HololandRenderer, type HololandRendererOptions, InferenceIsolationBarrier, type InferenceIsolationBarrierOptions, type InferenceMetrics, type InferencePriority, InferencePriorityScheduler, type InferencePrioritySchedulerOptions, type InferenceResult, type InferenceTask, type LODPolicy, QualityManager, type QualityPolicy, type RenderFeature, RenderSafeInferenceReader, type RenderSafeInferenceReaderOptions, type ThermalState, type ThermalThresholds, VRPerformanceBudget, type VRPerformanceBudgetOptions };