/**
 * Environment-neutral contracts injected by `three-blocks/vite`.
 *
 * This file deliberately contains no Vite or Node imports. Browser and render-worker
 * code can consume these types without pulling the build plugin into either bundle.
 */
export declare const THREE_BLOCKS_VITE_SCHEMA_VERSION: 2;
export type ThreeBlocksViteCommand = 'serve' | 'build';
export type ThreeBlocksShaderState = 'fresh' | 'stale' | 'invalid' | 'missing' | 'not-observed';
export type ThreeBlocksTextState = 'disabled' | 'ready' | 'generating' | 'fallback' | 'stale' | 'invalid' | 'missing' | 'not-observed';
export interface ThreeBlocksDracoRuntime {
    readonly decoderPath: string;
    readonly files: readonly [
        'draco_decoder.js',
        'draco_decoder.wasm',
        'draco_wasm_wrapper.js'
    ];
}
export interface ThreeBlocksKtx2Runtime {
    readonly transcoderPath: string;
    readonly files: readonly [
        'basis_transcoder.js',
        'basis_transcoder.wasm'
    ];
}
export interface ThreeBlocksMeshoptRuntime {
    readonly strategy: 'lazy-module';
    readonly specifier: 'three/addons/libs/meshopt_decoder.module.js';
}
export interface ThreeBlocksCodecRuntimeConfig {
    readonly draco: false | ThreeBlocksDracoRuntime;
    readonly ktx2: false | ThreeBlocksKtx2Runtime;
    readonly meshopt: false | ThreeBlocksMeshoptRuntime;
}
export interface ThreeBlocksShaderTiming {
    readonly schemaVersion?: 3;
    readonly source: 'latest-local-capture' | 'committed-capture';
    readonly measuredAt: string;
    /** Receipt-matched NodeBuilder invocations represented by this timing. */
    readonly builds?: number;
    /** True when the A/B measured and subtracted precompiled setup and hydration. */
    readonly setupMeasured?: boolean;
    readonly liveBuildMs: number;
    readonly precompiledBuildMs: number;
    readonly avoidedBuildMs: number;
    readonly runs?: number;
    readonly spreadMs?: number;
    readonly adapter?: string;
    readonly platform?: string;
}
/** @deprecated Read-only/input compatibility for timing captured before schema version 3. */
export interface ThreeBlocksShaderVerification {
    readonly schemaVersion?: 1 | 2;
    readonly source: 'local-ab' | 'committed-ab';
    readonly measuredAt: string;
    readonly liveBuildMs: number;
    readonly precompiledBuildMs: number;
    readonly avoidedBuildMs: number;
    readonly runs?: number;
    readonly spreadMs?: number;
    readonly adapter?: string;
    readonly platform?: string;
}
export interface ThreeBlocksShaderSceneBuildConfig {
    readonly pipelines: number;
    /** UTF-8 bytes in the manifest's pooled WGSL or GLSL programs. */
    readonly moduleBytes?: number;
    readonly state?: Exclude<ThreeBlocksShaderState, 'not-observed'>;
    readonly changed?: readonly string[];
    /** Receipt-matched build timing from the latest successful browser capture. */
    readonly timing?: ThreeBlocksShaderTiming;
    /** @deprecated Use `timing`. Accepted as input but never emitted. */
    readonly verification?: ThreeBlocksShaderVerification;
}
export interface ThreeBlocksShaderCaptureBuildConfig {
    readonly available: boolean;
    readonly token?: string;
    readonly beginEndpoint: string;
    readonly captureEndpoint: string;
    readonly telemetryEndpoint: string;
    readonly sessionKey: string;
    readonly scenes: readonly string[];
    readonly settleFrames: number;
    readonly settleTimeoutMs: number;
    readonly readiness: {
        readonly selector?: string;
        readonly global?: string;
    };
    readonly transform: number;
    readonly command: string;
}
export interface ThreeBlocksShaderBuildConfig {
    /** False when shader inspection and precompile guidance are intentionally disabled. */
    readonly enabled: boolean;
    readonly state: ThreeBlocksShaderState;
    readonly mode: 'precompiled' | 'live';
    readonly strict: boolean;
    readonly pipelines: number;
    readonly changed: readonly string[];
    /** Optional per-scene detail lets the overlay report the route being viewed. */
    readonly scenes?: Readonly<Record<string, ThreeBlocksShaderSceneBuildConfig>>;
    /**
     * Set when this production bundle is captured after it closes. Its manifests are build
     * output served at `<base>three-blocks/shaders/<scene>.<backend>.json`, so the runtime
     * discovers them instead of trusting a receipt that cannot exist yet.
     */
    readonly built?: {
        readonly base: string;
    };
}
/** Resolve the receipt state for one active scene without collapsing sibling scenes. */
export declare function threeBlocksShaderStateForScene(shaders: ThreeBlocksShaderBuildConfig, scene: string, backend?: 'webgpu' | 'webgl'): ThreeBlocksShaderState;
/**
 * Page-level runtime switches. A worker sees its own script URL, never the page's,
 * so the page parses these once and the app shell relays them in the boot payload.
 */
export interface ThreeBlocksRuntimeFlags {
    /**
     * `?tbShaders=live|precompiled` user preference. Parity lanes keep their own
     * `threeBlocksShaderMode`, which additionally frame-locks the session.
     */
    readonly shaders?: 'live' | 'precompiled';
    /** `?webgl=1` forces the WebGL backend. */
    readonly webgl: boolean;
    /** `?scene=<key>`: the scene the page asks for, when it names one. */
    readonly scene?: string;
}
export declare function readThreeBlocksRuntimeFlags(search: string): ThreeBlocksRuntimeFlags;
export interface ThreeBlocksTextBuildConfig {
    readonly enabled: boolean;
    readonly state: ThreeBlocksTextState;
    readonly atlases: number;
    readonly glyphs: number;
    readonly missing: readonly number[];
}
export interface ThreeBlocksStatsBuildConfig {
    readonly enabled: boolean;
    readonly production: boolean;
}
export interface ThreeBlocksRendererReceipt {
    readonly owner: 'page' | 'worker';
    readonly api: 'WebGPU';
    readonly fallback: 'WebGL';
}
export interface ThreeBlocksAssetReceipt {
    readonly draco: 'ready' | 'disabled';
    readonly ktx2: 'ready' | 'disabled';
    readonly meshopt: 'lazy' | 'disabled';
}
export interface ThreeBlocksShaderReceipt {
    readonly enabled?: boolean;
    readonly state: ThreeBlocksShaderState;
    readonly mode: 'precompiled' | 'live';
    readonly pipelines: number;
    readonly timing?: ThreeBlocksShaderTiming;
    /** @deprecated Legacy receipts may contain this field; new receipts never emit it. */
    readonly verification?: ThreeBlocksShaderVerification;
}
export interface ThreeBlocksTextReceipt {
    readonly state: Exclude<ThreeBlocksTextState, 'disabled'>;
    readonly atlases: number;
    readonly glyphs: number;
}
/** Stable machine-readable state behind the terminal build receipt. */
export interface ThreeBlocksBuildReceipt {
    readonly schemaVersion: typeof THREE_BLOCKS_VITE_SCHEMA_VERSION;
    readonly renderer: ThreeBlocksRendererReceipt;
    readonly assets: ThreeBlocksAssetReceipt;
    readonly shaders: ThreeBlocksShaderReceipt;
    readonly text?: ThreeBlocksTextReceipt;
    readonly stats: ThreeBlocksStatsBuildConfig;
    readonly output: string;
    readonly threeVersion: string;
}
/** Optimized-asset brief surfaced by the dev overlay (mirrors `.three-blocks/assets/meta.json`). */
export interface ThreeBlocksAssetBuildConfig {
    readonly state: 'empty' | 'fresh' | 'stale' | 'invalid';
    readonly optimized: number;
    readonly stale: number;
    readonly candidates: number;
    readonly candidateBytes: number;
    readonly bytesIn: number;
    readonly bytesOut: number;
    /** Exact GPU allocation totals from the optimizer's per-mip block math. */
    readonly vramBytesIn: number;
    readonly vramBytesOut: number;
    /** Fresh entries per source kind, so the overlay can name what was compressed. */
    readonly kinds: Readonly<Record<'glb' | 'image' | 'hdr', number>>;
    readonly reason: string;
}
/** Compile-time state available to browser and worker modules. */
export interface ThreeBlocksClientConfig {
    readonly schemaVersion: typeof THREE_BLOCKS_VITE_SCHEMA_VERSION;
    readonly command: ThreeBlocksViteCommand;
    readonly mode: string;
    readonly development: boolean;
    readonly base: string;
    /** Opaque discriminator used only to namespace browser-local development preferences. */
    readonly project?: {
        readonly storageKey: string;
    };
    readonly threeVersion: string;
    readonly renderer: ThreeBlocksRendererReceipt;
    readonly codecs: ThreeBlocksCodecRuntimeConfig;
    readonly stats: ThreeBlocksStatsBuildConfig;
    readonly shaders: ThreeBlocksShaderBuildConfig;
    /** Development-only overlay capture transport. */
    readonly capture?: ThreeBlocksShaderCaptureBuildConfig;
    readonly text: ThreeBlocksTextBuildConfig;
    readonly assets: ThreeBlocksAssetBuildConfig;
    readonly receipt: ThreeBlocksBuildReceipt;
}
/**
 * Structural contract returned from Three.js' lazy Meshopt module.
 *
 * Keeping this public type structural avoids making consumers install a separate
 * declaration package merely to read the Vite config types.
 */
export interface ThreeBlocksMeshoptDecoder {
    readonly supported: boolean;
    readonly ready: Promise<void>;
    decodeVertexBuffer(target: Uint8Array, count: number, size: number, source: Uint8Array, filter?: string): void;
    decodeIndexBuffer(target: Uint8Array, count: number, size: number, source: Uint8Array): void;
    decodeIndexSequence(target: Uint8Array, count: number, size: number, source: Uint8Array): void;
    decodeGltfBuffer(target: Uint8Array, count: number, size: number, source: Uint8Array, mode: string, filter?: string): void;
    useWorkers(count: number): void;
    decodeGltfBufferAsync(count: number, size: number, source: Uint8Array, mode: string, filter?: string): Promise<Uint8Array>;
}