import type { Object3D } from 'three';
import type { AssetScope, ThreeStandardAssetAdapters } from '../assets/index.js';
import type { ThreeBlocksTslBuildSnapshot } from '../devtools/buildObserver.js';
import type { HotScene } from '../hmr/index.js';
import type { ShaderSceneCache } from '../shaders/index.js';
import type { ThreeBlocksRuntimeFlags } from '../vite/types.js';
import type { StatsPanelMode, StatsSnapshot, StatsTextureFrame, StatsTexturePanelState } from 'three-blocks/stats';
import type { TextErrorState, TextFallbackSignal, TextReadyState, TextSyncDelivery } from '../text-runtime/index.js';
import type { SerializedWorkerError, TransferableValue, WorkerClient } from '../worker/index.js';
export type { ThreeBlocksTslBuildSnapshot } from '../devtools/buildObserver.js';
export interface ViewportState {
    readonly width: number;
    readonly height: number;
    readonly dpr: number;
}
export interface PointerState {
    readonly x: number;
    readonly y: number;
    readonly buttons: number;
}
export interface ScrollState {
    readonly progress: number;
    readonly position: number;
    readonly velocity: number;
    readonly direction: -1 | 0 | 1;
}
export interface VisibilityState {
    readonly visible: boolean;
}
export type RuntimeStage = 'starting' | 'worker ready' | 'assets ready' | 'compiled' | 'first frame' | 'updating' | 'error';
export interface RuntimeStatus {
    readonly stage: RuntimeStage;
    readonly detail?: string;
}
/** True when a lifecycle stage has reached or passed the requested milestone. */
export declare function runtimeStageReached(stage: RuntimeStage, milestone: RuntimeStage): boolean;
export interface WorkerBootState {
    readonly canvas: TransferableValue<OffscreenCanvas>;
    readonly page: TransferableValue<MessagePort>;
    /** Page URL switches; the worker's own `location` is its script URL. */
    readonly flags: ThreeBlocksRuntimeFlags;
    /** Development-only shader capture session relayed from the page shell. */
    readonly shaderCapture?: WorkerShaderCaptureActivation;
}
export type { ThreeBlocksRuntimeFlags };
export interface WorkerShaderCaptureActivation {
    readonly capture: boolean;
    readonly captureId?: string;
    readonly driven: boolean;
    readonly forceLive: boolean;
    readonly scene: string;
    readonly sessionKey?: string;
    readonly token?: string;
    readonly settleFrames: number;
    readonly settleTimeoutMs: number;
    readonly readiness: {
        readonly selector?: string;
        readonly global?: string;
    };
    readonly transform: number;
    readonly visible: boolean;
}
export declare const STATS_SCENE_PANEL: "scene/color";
export declare const STATS_PANEL_SIZE: {
    readonly width: 90;
    readonly height: 48;
};
export interface AppWorkerState {
    readonly boot: WorkerBootState;
    readonly viewport: ViewportState;
    readonly pointer: PointerState;
    readonly scroll: ScrollState;
    readonly visibility: VisibilityState;
    readonly statsPanel: StatsTexturePanelState & {
        readonly name: string;
    };
}
export interface AppWorkerEvents {
    readonly refresh: {
        readonly reason: string;
    };
    readonly textBatch: TextSyncDelivery;
}
export type AppWorkerRequests = Record<string, never>;
export interface RuntimeDiagnostics {
    readonly workerId: string;
    readonly viewport: ViewportState;
    readonly scroll: ScrollState;
    readonly visible: boolean;
    readonly shaderMode: 'precompiled' | 'live';
    /** Actual registered shader builds observed by the worker runtime. */
    readonly shaders?: ThreeBlocksShaderRuntimeSnapshot;
}
export interface AppPageState {
    readonly lifecycle: RuntimeStatus;
    readonly stats: StatsSnapshot;
    readonly tsl: ThreeBlocksTslBuildSnapshot;
    readonly diagnostics: RuntimeDiagnostics;
    readonly textReady: TextReadyState;
    readonly textFallback: TextFallbackSignal;
    readonly textError: TextErrorState;
}
export interface AppPageEvents {
    readonly texture: StatsTextureFrame;
    readonly error: SerializedWorkerError;
    readonly textReplay: {
        readonly reason: string;
    };
}
export type AppPageRequests = Record<string, never>;
export interface AppChannel<TState extends object, TEvents extends object, TRequests extends object> {
    readonly state: TState;
    readonly events: TEvents;
    readonly requests: TRequests;
}
export interface AppProtocol {
    readonly worker: AppChannel<AppWorkerState, AppWorkerEvents, AppWorkerRequests>;
    readonly page: AppChannel<AppPageState, AppPageEvents, AppPageRequests>;
}
export type WorkerLink = WorkerClient<AppWorkerState, AppWorkerEvents, AppWorkerRequests>;
export type PageLink = WorkerClient<AppPageState, AppPageEvents, AppPageRequests>;
export interface SceneContext {
    readonly assets: AssetScope<ThreeStandardAssetAdapters>;
    readonly shaders: ShaderSceneCache;
}
export type AppScene = Object3D & HotScene & {
    update(delta: number, scroll: ScrollState): void;
    pointer?(pointer: PointerState): void;
};
export interface ThreeBlocksReadiness {
    worker: boolean;
    workerReady: boolean;
    assetsReady: boolean;
    loadEnd: boolean;
    compileEnd: boolean;
    textReady: boolean;
    firstFrame: boolean;
}
export interface ThreeBlocksDevtoolsMetric {
    readonly label: string;
    readonly value: number;
    readonly max?: number;
    readonly unit?: string;
    readonly precision?: number;
}
/** Live shader-provider counters exposed to the development overlay. */
export interface ThreeBlocksShaderRuntimeSnapshot {
    readonly injected: number;
    readonly missed: number;
    readonly live: number;
    readonly hydrationMs?: number;
    readonly maxHydrationMs?: number;
}
export interface ThreeBlocksSmokeState {
    readonly protocolVersion: 1;
    readonly owner: 'page' | 'worker';
    /** False when the owning registration opted out of its one-time dev announcement. */
    readonly announce?: boolean;
    readonly renderer?: {
        readonly api: 'Three.js' | 'WebGL' | 'WebGPU';
    };
    readonly worker: {
        offscreenCanvas: boolean;
        visible: boolean;
        generation: number;
    };
    readonly readiness: ThreeBlocksReadiness;
    diagnostics?: {
        workerId: string;
        width: number;
        height: number;
        scrollPosition: number;
        visible: boolean;
        shaderMode: 'precompiled' | 'live';
    };
    readonly restart: {
        count: number;
        canvasReplaced: boolean;
        stateReplayed: boolean;
        lastReason: string;
    };
    /** Present while a shader provider or live-build observer is installed. */
    readonly shaders?: ThreeBlocksShaderRuntimeSnapshot | undefined;
    /** Present when development NodeBuilder timing is available. */
    readonly tsl?: ThreeBlocksTslBuildSnapshot | undefined;
    readonly stats: {
        readonly snapshots: number;
        readonly textures: number;
        /** Requested panel visibility. Hidden documents temporarily suppress the DOM panel. */
        readonly panelVisible: boolean;
        /** Optional page-owned counters rendered directly inside the devtools overlay. */
        readonly metrics?: Readonly<Record<string, ThreeBlocksDevtoolsMetric>>;
        setPanelVisible(visible: boolean): Promise<boolean>;
        setPanelMode(mode: Exclude<StatsPanelMode, 'hidden'>): Promise<boolean>;
    };
    restartWorker(reason?: string): Promise<void>;
}
export interface AppHotContext {
    on(event: 'three-blocks:worker-restart', callback: (payload: {
        readonly path: string;
    }) => void): void;
    dispose(callback: () => void): void;
}
declare global {
    interface Window {
        __threeBlocks: ThreeBlocksReadiness;
        __threeBlocksSmoke: ThreeBlocksSmokeState;
    }
}