@holoscript/engine 6.0.3 → 6.0.4

package/dist/index-ByIq2XrS.d.cts

@@ -0,0 +1,3910 @@
+import { E as EngineSystem } from './SpatialEngine-CXmE-U_d.cjs';
+import { g as IPhysicsWorld } from './PhysicsTypes-Dw6_oXuD.cjs';
+
+/**
+ * BloomEffect.ts
+ *
+ * Bloom post-process: threshold extraction, blur passes,
+ * soft knee, intensity, and composite blending.
+ *
+ * @module rendering
+ */
+interface BloomConfig {
+    threshold: number;
+    softKnee: number;
+    intensity: number;
+    radius: number;
+    passes: number;
+    enabled: boolean;
+}
+declare class BloomEffect$1 {
+    private config;
+    setThreshold(val: number): void;
+    setSoftKnee(val: number): void;
+    setIntensity(val: number): void;
+    setRadius(val: number): void;
+    setPasses(val: number): void;
+    setEnabled(val: boolean): void;
+    getConfig(): BloomConfig;
+    extractBright(pixels: Float32Array, _width: number, _height: number): Float32Array;
+    blur(pixels: Float32Array, width: number, height: number): Float32Array;
+    private blurPass;
+    composite(original: Float32Array, bloom: Float32Array): Float32Array;
+    apply(pixels: Float32Array, width: number, height: number): Float32Array;
+}
+
+/**
+ * AdvancedLighting.ts
+ *
+ * Advanced light types beyond point / directional / spot:
+ *   - Area lights: rectangle, disk, tube (LTC approximation)
+ *   - IES light profiles (photometric, from .ies tabular data)
+ *   - Emissive mesh lights
+ *   - Light cookies (projected texture masks)
+ *   - Caustic intensity configuration
+ *
+ * All calculations are CPU-side (uniform / config helpers).
+ * No WebGPU — fully testable in Vitest.
+ *
+ * @module rendering
+ */
+type Vec3$4 = {
+    x: number;
+    y: number;
+    z: number;
+};
+type Vec2$1 = {
+    x: number;
+    y: number;
+};
+type AreaLightShape = 'rectangle' | 'disk' | 'tube';
+type LightType$1 = 'point' | 'spot' | 'directional' | 'area' | 'ies' | 'emissive_mesh';
+interface AreaLightConfig {
+    shape: AreaLightShape;
+    /** Half-extents for rectangle [w, h], radius for disk, [r, length] for tube */
+    size: Vec2$1;
+    /** Two-sided emission */
+    twoSided: boolean;
+}
+interface IESProfile {
+    id: string;
+    /** Vertical angles (0–180°) */
+    verticalAngles: number[];
+    /** Horizontal angles (0–360°) */
+    horizontalAngles: number[];
+    /** Candela values [horizontal][vertical] */
+    candela: number[][];
+    /** Maximum candela (for normalisation) */
+    maxCandela: number;
+}
+interface LightCookie {
+    /** Cookie texture width */
+    width: number;
+    /** Cookie texture height */
+    height: number;
+    /** RGBA pixel data (Float32Array, linear) */
+    pixels: Float32Array;
+}
+interface CausticConfig {
+    intensity: number;
+    sampleCount: number;
+    animationSpeed: number;
+}
+interface AdvancedLight {
+    id: string;
+    type: LightType$1;
+    position: Vec3$4;
+    direction: Vec3$4;
+    color: [number, number, number];
+    intensity: number;
+    range: number;
+    enabled: boolean;
+    area?: AreaLightConfig;
+    ies?: IESProfile;
+    cookie?: LightCookie;
+    caustic?: CausticConfig;
+    /** Mesh geometry ID for emissive mesh lights */
+    meshId?: string;
+}
+/**
+ * Parse a simplified IES LM-63 candela table.
+ * Expects lines: "vertical_angles\nhorizontal_angles\ncandela_values..."
+ *
+ * For production use this would parse the full IES spec; here we handle
+ * the minimal tabular data format used in tests.
+ */
+declare function parseIESProfile(id: string, vertAngles: number[], horizAngles: number[], candela: number[][]): IESProfile;
+/**
+ * Sample an IES profile for a given vertical + horizontal angle (degrees).
+ * Returns normalised intensity [0–1].
+ */
+declare function sampleIES(profile: IESProfile, vertDeg: number, horizDeg: number): number;
+/**
+ * Compute solid angle subtended by a rectangular area light.
+ * All positions in world space.
+ */
+declare function rectSolidAngle(surfacePos: Vec3$4, lightPos: Vec3$4, right: Vec3$4, up: Vec3$4, halfWidth: number, halfHeight: number): number;
+/**
+ * Disk area light — solid angle approximation.
+ */
+declare function diskSolidAngle(surfacePos: Vec3$4, lightPos: Vec3$4, radius: number): number;
+/**
+ * Build a simple circular light cookie (sharp circular spot).
+ */
+declare function buildCircleCookie(width: number, height: number, edgeSoftness?: number): LightCookie;
+/**
+ * Sample a light cookie at UV coordinates [0–1].
+ * Returns [r, g, b, a].
+ */
+declare function sampleCookie(cookie: LightCookie, u: number, v: number): [number, number, number, number];
+declare class AdvancedLightingManager {
+    private lights;
+    addLight(config: Partial<AdvancedLight> & {
+        type: LightType$1;
+    }): AdvancedLight;
+    removeLight(id: string): boolean;
+    getLight(id: string): AdvancedLight | undefined;
+    getLightCount(): number;
+    getEnabledCount(): number;
+    getLightsByType(type: LightType$1): AdvancedLight[];
+    /**
+     * Set a light cookie on an existing light.
+     */
+    setCookie(id: string, cookie: LightCookie): void;
+    /**
+     * Set an IES profile on an existing light.
+     */
+    setIES(id: string, profile: IESProfile): void;
+    /**
+     * Get total emissive power from all enabled emissive mesh lights.
+     */
+    getTotalEmissivePower(): number;
+    clear(): void;
+}
+
+/**
+ * AdvancedPBR.ts
+ *
+ * Advanced Physically-Based Rendering material model.
+ *
+ * Extends basic PBR (albedo + normal + roughness) with:
+ *   - Clearcoat layer (car paint, lacquer, wet surfaces)
+ *   - Anisotropy (brushed metal, hair, fabric warp)
+ *   - Sheen (velvet, cloth, microfibre)
+ *   - Iridescence (soap bubbles, oil slicks, beetle shells)
+ *   - Multi-layer material stack
+ *   - Metallic/roughness workflow helpers
+ *
+ * All calculations are CPU-side (can feed GPU uniforms or be used in
+ * offline renderers). No WebGPU imports — fully testable in Vitest.
+ *
+ * @module rendering
+ */
+interface Vec3$3 {
+    x: number;
+    y: number;
+    z: number;
+}
+type RGB$1 = [number, number, number];
+interface ClearcoatConfig {
+    /** 0–1, overall clearcoat presence */
+    intensity: number;
+    /** 0–1, surface roughness of the clearcoat layer */
+    roughness: number;
+    /** Index of refraction (default 1.5 for glass-like coat) */
+    ior: number;
+}
+interface AnisotropyConfig {
+    /** 0–1, anisotropy magnitude */
+    strength: number;
+    /** Rotation angle of anisotropic tangent in radians */
+    angle: number;
+    /** Anisotropy direction vector (must be unit) */
+    tangent: Vec3$3;
+}
+interface SheenConfig {
+    /** RGB tint for sheen reflection */
+    color: RGB$1;
+    /** 0–1, surface roughness of sheen layer (velvet = low) */
+    roughness: number;
+}
+interface IridescenceConfig {
+    /** 0–1, how visible the iridescent effect is */
+    intensity: number;
+    /** Index of refraction of thin film */
+    ior: number;
+    /** Thin-film thickness in nanometres (400–1200 typical) */
+    thicknessNm: number;
+}
+interface AdvancedPBRConfig {
+    /** Base albedo (linear RGB) */
+    albedo: RGB$1;
+    /** 0–1, 0 = dielectric, 1 = metal */
+    metallic: number;
+    /** 0–1, microsurface roughness */
+    roughness: number;
+    /** Ambient occlusion 0–1 */
+    ao: number;
+    /** Emissive colour (HDR, can exceed 1) */
+    emissive: RGB$1;
+    clearcoat?: ClearcoatConfig;
+    anisotropy?: AnisotropyConfig;
+    sheen?: SheenConfig;
+    iridescence?: IridescenceConfig;
+}
+/** GGX / Trowbridge-Reitz normal distribution function */
+declare function distributionGGX(NdotH: number, roughness: number): number;
+/** Smith's geometry attenuation (Schlick-GGX) */
+declare function geometrySmith(NdotV: number, NdotL: number, roughness: number): number;
+/** Schlick Fresnel approximation */
+declare function fresnelSchlick(cosTheta: number, F0: RGB$1): RGB$1;
+/** Schlick Fresnel with roughness (for IBL) */
+declare function fresnelRoughness(cosTheta: number, F0: RGB$1, roughness: number): RGB$1;
+/**
+ * Evaluate clearcoat layer BRDF contribution.
+ * Uses a separate GGX lobe with IOR-derived F0 ≈ ((ior-1)/(ior+1))².
+ */
+declare function evaluateClearcoat(NdotH: number, NdotV: number, NdotL: number, VdotH: number, config: ClearcoatConfig): number;
+/**
+ * GGX NDF modified for anisotropic surfaces (Burley 2012).
+ * alphaT and alphaB are per-axis roughness values.
+ */
+declare function distributionGGXAnisotropic(NdotH: number, TdotH: number, BdotH: number, alphaT: number, alphaB: number): number;
+/**
+ * Compute per-axis roughness values from isotropic roughness + anisotropy strength.
+ * Returns [alphaT, alphaB].
+ */
+declare function anisotropicRoughness(roughness: number, strength: number): [number, number];
+/**
+ * Charlie sheen NDF (Estevez & Kulla 2017).
+ * Produces the characteristic soft highlight at grazing angles.
+ */
+declare function sheenDistribution(NdotH: number, roughness: number): number;
+/** Sheen visibility function (L(NdotV) * L(NdotL)) */
+declare function sheenVisibility(NdotV: number, NdotL: number): number;
+/** Evaluate full sheen BRDF contribution */
+declare function evaluateSheen(NdotH: number, NdotV: number, NdotL: number, config: SheenConfig): RGB$1;
+/**
+ * Thin-film interference iridescence (McGuire & Skelton 2020).
+ * Computes a wavelength-dependent phase shift and maps it to RGB.
+ * wavelengths: [680, 550, 440] nm (R, G, B).
+ */
+declare function evaluateIridescence(cosTheta: number, config: IridescenceConfig): RGB$1;
+/**
+ * Compute F0 (reflectance at normal incidence) from albedo + metallic.
+ * Dielectrics: F0 ≈ 0.04 (non-metals), metals: F0 = albedo.
+ */
+declare function computeF0(albedo: RGB$1, metallic: number): RGB$1;
+/**
+ * Compute diffuse albedo for metallic surfaces (metals have no diffuse).
+ */
+declare function computeDiffuseAlbedo(albedo: RGB$1, metallic: number): RGB$1;
+declare class AdvancedPBRMaterial {
+    private config;
+    constructor(config?: Partial<AdvancedPBRConfig>);
+    setAlbedo(r: number, g: number, b: number): void;
+    setMetallic(v: number): void;
+    setRoughness(v: number): void;
+    setAO(v: number): void;
+    setEmissive(r: number, g: number, b: number): void;
+    setClearcoat(cc: ClearcoatConfig): void;
+    setAnisotropy(an: AnisotropyConfig): void;
+    setSheen(sh: SheenConfig): void;
+    setIridescence(ir: IridescenceConfig): void;
+    getConfig(): Readonly<AdvancedPBRConfig>;
+    getF0(): RGB$1;
+    getDiffuse(): RGB$1;
+    hasClearcoat(): boolean;
+    hasAnisotropy(): boolean;
+    hasSheen(): boolean;
+    hasIridescence(): boolean;
+    /**
+     * Evaluate the full advanced PBR BRDF at a shading point.
+     *
+     * @param NdotL - dot(N, L), clamped [0,1]
+     * @param NdotV - dot(N, V), clamped [0,1]
+     * @param NdotH - dot(N, H), clamped [0,1]
+     * @param VdotH - dot(V, H), clamped [0,1]
+     * @param TdotH - dot(T, H) for anisotropy (0 if not anisotropic)
+     * @param BdotH - dot(B, H) for anisotropy (0 if not anisotropic)
+     * @returns RGB radiance contribution (direct light, no PI factor)
+     */
+    evaluate(NdotL: number, NdotV: number, NdotH: number, VdotH: number, TdotH?: number, BdotH?: number): RGB$1;
+}
+/** Pre-configured material presets */
+declare const MATERIAL_PRESETS$1: {
+    carPaintRed: () => AdvancedPBRMaterial;
+    brushedAluminium: () => AdvancedPBRMaterial;
+    velvet: () => AdvancedPBRMaterial;
+    soapBubble: () => AdvancedPBRMaterial;
+};
+
+/**
+ * AdvancedTexturing.ts
+ *
+ * Advanced texturing techniques (CPU-side):
+ *   - Displacement mapping (tessellation height scale helpers)
+ *   - Parallax Occlusion Mapping (iterative ray-step algorithm)
+ *   - Triplanar mapping (normal-based blend weights + UV generation)
+ *   - Detail maps (fine-grain albedo + normal overlay at a higher tiling)
+ *   - Texture atlas UV packing (row-based guillotine)
+ *
+ * Works with arbitrary Float32Array textures (RGBA, row-major).
+ * No WebGPU / DOM — fully testable in Vitest.
+ *
+ * @module rendering
+ */
+interface Vec2 {
+    x: number;
+    y: number;
+}
+interface Vec3$2 {
+    x: number;
+    y: number;
+    z: number;
+}
+/** Simple flat texture (row-major, RGBA, linear) */
+interface Texture2D {
+    width: number;
+    height: number;
+    pixels: Float32Array;
+}
+/** Create a solid-colour texture */
+declare function createSolidTexture(w: number, h: number, r?: number, g?: number, b?: number, a?: number): Texture2D;
+/** Sample a texture at UV coordinates [0–1], clamped. Returns [R, G, B, A]. */
+declare function sampleTexture(tex: Texture2D, u: number, v: number): [number, number, number, number];
+/** Sample a texture with bilinear interpolation */
+declare function sampleTextureBilinear(tex: Texture2D, u: number, v: number): [number, number, number, number];
+interface DisplacementConfig {
+    /** Height scale in world units */
+    scale: number;
+    /** Bias (offset applied symmetrically around 0) */
+    bias: number;
+}
+/**
+ * Compute a displaced position given a surface position, normal,
+ * and a height map sample at the corresponding UV.
+ */
+declare function computeDisplacedPosition(position: Vec3$2, normal: Vec3$2, heightMap: Texture2D, u: number, v: number, config?: Partial<DisplacementConfig>): Vec3$2;
+/**
+ * Compute vertex normals for a displaced mesh via finite differences.
+ * heights: per-vertex height samples (row-major, same size as vertex grid).
+ * Returns per-vertex Vec3 normals (not normalised).
+ */
+declare function computeDisplacementNormalsFromHeightMap(heights: Float32Array, gridW: number, gridH: number, cellSizeX: number, cellSizeZ: number): Vec3$2[];
+interface POMConfig {
+    /** Height scale (0–1, typ. 0.05–0.15) */
+    heightScale: number;
+    /** Min ray march layers (far from surface) */
+    minLayers: number;
+    /** Max ray march layers (near surface) */
+    maxLayers: number;
+}
+/**
+ * Perform Parallax Occlusion Mapping to compute an offset UV.
+ *
+ * @param uv    - Input surface UV
+ * @param viewDir - View direction in tangent space (must point away from surface)
+ * @param heightMap - Single-channel height map (R channel)
+ * @param config - POM settings
+ * @returns Parallax-offset UV
+ */
+declare function computePOM(uv: Vec2, viewDir: Vec3$2, heightMap: Texture2D, config?: Partial<POMConfig>): Vec2;
+/**
+ * Compute triplanar blend weights from a surface normal.
+ * Higher sharpness → sharper transitions between planes.
+ */
+declare function triplanarWeights(normal: Vec3$2, sharpness?: number): Vec3$2;
+/**
+ * Sample a texture using triplanar UV projection.
+ * position: world-space position; tileScale: how fast the texture tiles.
+ * Returns blended RGBA from all three planes.
+ */
+declare function sampleTriplanar(tex: Texture2D, position: Vec3$2, normal: Vec3$2, tileScale?: number, sharpness?: number): [number, number, number, number];
+interface DetailMapConfig {
+    /** How many times the detail map tiles over the base UV */
+    tileScale: number;
+    /** Blend intensity 0–1 */
+    intensity: number;
+}
+/** Overlay a detail albedo texture on top of a base albedo sample */
+declare function applyDetailAlbedo(baseColor: [number, number, number, number], detailTex: Texture2D, u: number, v: number, config?: Partial<DetailMapConfig>): [number, number, number, number];
+/**
+ * Blend detail normal with base normal (Reoriented Normal Mapping).
+ * Both normals must be unit-length, in tangent space.
+ */
+declare function blendDetailNormal(base: Vec3$2, detail: Vec3$2): Vec3$2;
+interface AtlasRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Source identifier */
+    id: string;
+}
+interface AtlasPacker {
+    atlasWidth: number;
+    atlasHeight: number;
+    rects: AtlasRect[];
+    /** Number of rows stacked */
+    rowCount: number;
+    /** Current row cursor */
+    cursorX: number;
+    cursorY: number;
+    rowHeight: number;
+}
+/** Create a new atlas packer */
+declare function createAtlasPacker(width?: number, height?: number): AtlasPacker;
+/**
+ * Pack a texture region into the atlas (row-based guillotine).
+ * Returns the allocated AtlasRect or null if out of space.
+ */
+declare function packRect(packer: AtlasPacker, id: string, width: number, height: number, padding?: number): AtlasRect | null;
+/** Get UV coordinates [0–1] of a packed rect within the atlas */
+declare function getRectUV(packer: AtlasPacker, rect: AtlasRect): {
+    u0: number;
+    v0: number;
+    u1: number;
+    v1: number;
+};
+/** Total packing efficiency (used area / total area) */
+declare function getAtlasEfficiency(packer: AtlasPacker): number;
+
+/**
+ * CloudRenderer.ts
+ *
+ * Noise-based cloud rendering: layered cloud generation,
+ * wind drift, density thresholds, lighting, and coverage control.
+ *
+ * @module rendering
+ */
+interface CloudConfig {
+    coverage: number;
+    density: number;
+    altitude: number;
+    thickness: number;
+    windSpeed: {
+        x: number;
+        z: number;
+    };
+    lightColor: [number, number, number];
+    ambientColor: [number, number, number];
+    lightDirection: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    noiseScale: number;
+    detailScale: number;
+    layers: number;
+}
+interface CloudSample {
+    position: [number, number, number];
+    density: number;
+    lighting: number;
+}
+declare class CloudRenderer {
+    private config;
+    private time;
+    constructor(config?: Partial<CloudConfig>);
+    setConfig(config: Partial<CloudConfig>): void;
+    getConfig(): CloudConfig;
+    update(dt: number): void;
+    sampleDensity(x: number, y: number, z: number): number;
+    sampleLighting(x: number, y: number, z: number, steps?: number): CloudSample;
+    private pseudoNoise;
+    getCoverageMap(gridSize: number, cellSize: number, worldOffsetX?: number, worldOffsetZ?: number): Float32Array;
+}
+
+/**
+ * ColorGrading.ts
+ *
+ * Color grading: tonemapping operators, exposure, contrast,
+ * saturation, color temperature, LUT, and split toning.
+ *
+ * @module rendering
+ */
+type TonemapOperator = 'none' | 'reinhard' | 'aces' | 'filmic' | 'uncharted2';
+interface ColorGradingConfig {
+    tonemapper: TonemapOperator;
+    exposure: number;
+    contrast: number;
+    saturation: number;
+    temperature: number;
+    tint: number;
+    gamma: number;
+    enabled: boolean;
+}
+declare class ColorGrading {
+    private config;
+    setTonemapper(op: TonemapOperator): void;
+    setExposure(ev: number): void;
+    setContrast(val: number): void;
+    setSaturation(val: number): void;
+    setTemperature(val: number): void;
+    setTint(val: number): void;
+    setGamma(val: number): void;
+    setEnabled(val: boolean): void;
+    getConfig(): ColorGradingConfig;
+    tonemap(r: number, g: number, b: number): [number, number, number];
+    private tonemapACES;
+    private tonemapFilmic;
+    private tonemapUncharted2;
+    adjustExposure(r: number, g: number, b: number): [number, number, number];
+    adjustContrast(r: number, g: number, b: number): [number, number, number];
+    adjustSaturation(r: number, g: number, b: number): [number, number, number];
+    adjustGamma(r: number, g: number, b: number): [number, number, number];
+    apply(pixels: Float32Array, _width: number, _height: number): Float32Array;
+}
+
+/**
+ * DecalBatcher.ts
+ *
+ * Instanced decal rendering: GPU batching, per-texture
+ * grouping, LOD selection, frustum culling, and draw stats.
+ *
+ * @module rendering
+ */
+interface DecalInstance {
+    id: string;
+    textureId: string;
+    position: [number, number, number];
+    scale: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    opacity: number;
+    lodLevel: number;
+}
+interface DrawBatch {
+    textureId: string;
+    instances: DecalInstance[];
+    instanceCount: number;
+}
+interface BatchStats {
+    totalInstances: number;
+    totalBatches: number;
+    culledCount: number;
+    drawnCount: number;
+}
+declare class DecalBatcher {
+    private instances;
+    private batches;
+    private stats;
+    private maxLOD;
+    private lodDistances;
+    setLODDistances(distances: number[]): void;
+    getLODDistances(): number[];
+    addInstance(instance: DecalInstance): void;
+    removeInstance(id: string): boolean;
+    clear(): void;
+    getInstanceCount(): number;
+    computeLOD(distance: number): number;
+    buildBatches(cameraPos: {
+        x: number;
+        y: number;
+        z: number;
+    }, frustumTest?: (pos: DecalInstance['position']) => boolean): DrawBatch[];
+    getStats(): BatchStats;
+}
+
+/**
+ * DecalSystem.ts
+ *
+ * Projected decals: texture projection, sorting, atlas UV,
+ * lifetime fade, object pooling, and layer filtering.
+ *
+ * @module rendering
+ */
+interface DecalDef {
+    id: string;
+    textureId: string;
+    atlasRegion?: {
+        u: number;
+        v: number;
+        w: number;
+        h: number;
+    };
+    size: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    position: [number, number, number];
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    normal: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    color: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    layer: number;
+    sortOrder: number;
+    lifetime: number;
+    fadeInDuration: number;
+    fadeOutDuration: number;
+    active: boolean;
+    age: number;
+    opacity: number;
+}
+declare class DecalSystem {
+    private decals;
+    private pool;
+    private maxDecals;
+    private layerMask;
+    setMaxDecals(max: number): void;
+    getMaxDecals(): number;
+    setLayerMask(mask: number): void;
+    spawn(config: Partial<DecalDef> & {
+        textureId: string;
+        position: DecalDef['position'];
+        normal: DecalDef['normal'];
+    }): DecalDef;
+    remove(id: string): void;
+    update(dt: number): void;
+    getDecal(id: string): DecalDef | undefined;
+    getActiveCount(): number;
+    getPoolSize(): number;
+    getVisible(frustumTest?: (pos: DecalDef['position']) => boolean): DecalDef[];
+    private getOldest;
+    clear(): void;
+}
+
+/**
+ * FogSystem.ts
+ *
+ * Fog: linear, exponential, exponential-squared, and height fog.
+ * Supports color blending, density maps, and animation.
+ *
+ * @module rendering
+ */
+type FogMode = 'linear' | 'exponential' | 'exponential2';
+interface FogConfig {
+    mode: FogMode;
+    color: [number, number, number];
+    nearDistance: number;
+    farDistance: number;
+    density: number;
+    heightFog: boolean;
+    heightStart: number;
+    heightEnd: number;
+    heightDensity: number;
+    enabled: boolean;
+}
+declare class FogSystem {
+    private config;
+    private animation;
+    constructor(config?: Partial<FogConfig>);
+    setConfig(config: Partial<FogConfig>): void;
+    getConfig(): FogConfig;
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    computeFogFactor(distance: number, height?: number): number;
+    private computeHeightFactor;
+    blendWithFog(sceneColor: [number, number, number], distance: number, height?: number): [number, number, number];
+    setAnimation(speed: number): void;
+    update(dt: number): void;
+}
+
+/**
+ * GlobalIllumination.ts
+ *
+ * Global Illumination system:
+ *   - Spherical Harmonic (SH, L2 9-coefficient) light probe encoding/decoding
+ *   - SH irradiance grid (3D probe array)
+ *   - Irradiance probe sampling and trilinear interpolation
+ *   - DDGI-style probe validity tracking
+ *   - Lightmap UV unwrapping placeholder (atlas packing)
+ *   - Bounce count / GI mode configuration
+ *
+ * CPU-side — does not depend on WebGPU. Probe lighting values are
+ * expected to come from an offline bake or iterative runtime update.
+ *
+ * @module rendering
+ */
+type Vec3$1 = {
+    x: number;
+    y: number;
+    z: number;
+};
+/** L2 spherical harmonics — 9 coefficients per RGB channel */
+interface SH9 {
+    r: Float32Array;
+    g: Float32Array;
+    b: Float32Array;
+}
+type GIMode = 'lightmaps' | 'probes' | 'ddgi' | 'ssgi' | 'none';
+interface GIConfig {
+    mode: GIMode;
+    /** World-space distance between adjacent probes */
+    probeSpacing: number;
+    /** Number of indirect light bounces to simulate */
+    bounceCount: number;
+    /** Grid dimensions [x, y, z] */
+    gridSize: [number, number, number];
+    /** World-space origin of the probe grid */
+    gridOrigin: Vec3$1;
+}
+/** Create an empty SH9 (all zeroes) */
+declare function createSH9(): SH9;
+/**
+ * Add a directional radiance sample to an SH9 accumulator.
+ * dir must be a unit vector (azimuth encoded across hemisphere).
+ */
+declare function addSHSample(sh: SH9, dir: Vec3$1, radiance: [number, number, number], weight?: number): void;
+/**
+ * Evaluate SH9 irradiance at a surface normal (Ravi Ramamoorthi, 2001).
+ * Returns RGB irradiance.
+ */
+declare function evalSH9Irradiance(sh: SH9, normal: Vec3$1): [number, number, number];
+/** Scale all SH coefficients by a scalar (e.g. to normalise after sample accumulation) */
+declare function scaleSH9(sh: SH9, s: number): void;
+/** Linearly interpolate between two SH9 probes (for trilinear grid lookup) */
+declare function lerpSH9(a: SH9, b: SH9, t: number): SH9;
+interface ProbeInfo {
+    index: number;
+    worldPos: Vec3$1;
+    sh: SH9;
+    /** 0 = invalid (occlusion issue), 1 = valid */
+    validity: number;
+    /** Number of times this probe has been updated */
+    updateCount: number;
+}
+declare class GIProbeGrid {
+    private probes;
+    private config;
+    constructor(config?: Partial<GIConfig>);
+    private buildGrid;
+    getProbeCount(): number;
+    getConfig(): Readonly<GIConfig>;
+    getProbe(x: number, y: number, z: number): ProbeInfo | undefined;
+    getProbeAt(index: number): ProbeInfo | undefined;
+    updateProbe(x: number, y: number, z: number, sh: SH9): void;
+    setValidity(x: number, y: number, z: number, valid: number): void;
+    invalidateAll(): void;
+    /** Number of valid probes (validity > 0) */
+    getValidProbeCount(): number;
+    /**
+     * Sample irradiance at a world-space position + surface normal.
+     * Performs trilinear interpolation across the 8 surrounding probes.
+     */
+    sampleIrradiance(worldPos: Vec3$1, normal: Vec3$1): [number, number, number];
+    /**
+     * Return lightmap UV (atlas page + offset) for a given probe index.
+     * Probes are packed in a square atlas, 16 per row.
+     */
+    getLightmapUV(probeIndex: number): {
+        page: number;
+        u: number;
+        v: number;
+    };
+}
+
+/**
+ * LightingModel.ts
+ *
+ * Lighting: directional/point/spot lights, shadow maps,
+ * ambient/IBL, GI probes, and light culling.
+ *
+ * @module rendering
+ */
+type LightType = 'directional' | 'point' | 'spot';
+interface Light {
+    id: string;
+    type: LightType;
+    color: [number, number, number];
+    intensity: number;
+    position: [number, number, number];
+    direction: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    range: number;
+    spotAngle: number;
+    spotPenumbra: number;
+    castShadow: boolean;
+    shadowBias: number;
+    shadowMapSize: number;
+    enabled: boolean;
+    layer: number;
+}
+interface AmbientConfig {
+    color: [number, number, number];
+    intensity: number;
+    skyColor: [number, number, number];
+    groundColor: [number, number, number];
+    useHemisphere: boolean;
+}
+interface GIProbe {
+    id: string;
+    position: [number, number, number];
+    radius: number;
+    irradiance: [number, number, number];
+    weight: number;
+}
+declare class LightingModel {
+    private lights;
+    private ambient;
+    private probes;
+    private maxLights;
+    addLight(config: Partial<Light> & {
+        id: string;
+        type: LightType;
+    }): Light;
+    removeLight(id: string): void;
+    getLight(id: string): Light | undefined;
+    getLightCount(): number;
+    enableLight(id: string, enabled: boolean): void;
+    setAmbient(config: Partial<AmbientConfig>): void;
+    getAmbient(): AmbientConfig;
+    addGIProbe(probe: GIProbe): void;
+    removeGIProbe(id: string): void;
+    sampleGI(position: [number, number, number]): [number, number, number];
+    calculateAttenuation(lightId: string, worldPos: {
+        x: number;
+        y: number;
+        z: number;
+    }): number;
+    getVisibleLights(cameraPos: {
+        x: number;
+        y: number;
+        z: number;
+    }, maxRange: number, layerMask?: number): Light[];
+    getShadowCasters(): Light[];
+}
+
+/**
+ * MaterialLibrary.ts
+ *
+ * PBR material system: material definitions, texture slots,
+ * instancing, and preset materials.
+ *
+ * @module rendering
+ */
+type BlendMode$2 = 'opaque' | 'transparent' | 'additive' | 'multiply';
+type CullMode$1 = 'none' | 'front' | 'back';
+/**
+ * Material type classification for UI and editor workflows.
+ * Maps to high-level rendering strategies.
+ */
+type MaterialType = 'standard' | 'physical' | 'basic' | 'emissive' | 'toon' | 'glass' | 'metal';
+interface TextureSlot {
+    textureId: string;
+    uvChannel: number;
+    tiling: {
+        x: number;
+        y: number;
+    };
+    offset: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Unified PBR material definition.
+ *
+ * This is the single canonical material type used across all HoloScript
+ * subsystems: the rendering MaterialLibrary, the MaterialEditor tool,
+ * shader graphs, and export compilers.
+ *
+ * Color values use linear RGBA objects (not hex strings) for precision
+ * and compatibility with GPU pipelines.
+ */
+interface MaterialDef {
+    id: string;
+    name: string;
+    /** High-level material classification for editor UI (default: 'standard') */
+    materialType?: MaterialType;
+    albedo: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    metallic: number;
+    roughness: number;
+    emission: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    emissionStrength: number;
+    normalScale: number;
+    aoStrength: number;
+    albedoMap?: TextureSlot;
+    normalMap?: TextureSlot;
+    metallicRoughnessMap?: TextureSlot;
+    emissionMap?: TextureSlot;
+    aoMap?: TextureSlot;
+    blendMode: BlendMode$2;
+    cullMode: CullMode$1;
+    depthWrite: boolean;
+    depthTest: boolean;
+    doubleSided: boolean;
+    shaderGraphId?: string;
+    customUniforms?: Record<string, number | number[]>;
+    /** Arbitrary extension properties for editor/plugin use */
+    properties?: Record<string, unknown>;
+}
+/**
+ * Convert a hex color string (#RRGGBB or #RRGGBBAA) to an RGBA object
+ * with linear color values (0-1).
+ */
+declare function hexToRGBA(hex: string): {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+/**
+ * Convert an RGBA object (0-1 values) to a hex color string (#RRGGBB).
+ */
+declare function rgbaToHex(color: {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+}): string;
+/**
+ * Create a default MaterialDef with sensible PBR defaults.
+ * Useful for editors and tools that need a starting point.
+ */
+declare function createDefaultMaterialDef(id: string, name?: string, materialType?: MaterialType): MaterialDef;
+interface MaterialInstance {
+    id: string;
+    baseMaterialId: string;
+    overrides: Partial<MaterialDef>;
+}
+declare const MATERIAL_PRESETS: Record<string, Partial<MaterialDef>>;
+declare class MaterialLibrary {
+    private materials;
+    private instances;
+    constructor();
+    register(material: MaterialDef): void;
+    registerPreset(presetName: string, id?: string): MaterialDef | null;
+    unregister(id: string): void;
+    getMaterial(id: string): MaterialDef | undefined;
+    getMaterialCount(): number;
+    getAllMaterials(): MaterialDef[];
+    createInstance(baseMaterialId: string, overrides?: Partial<MaterialDef>): MaterialInstance | null;
+    /**
+     * Resolve an instance to its full material definition.
+     */
+    resolveInstance(instanceId: string): MaterialDef | null;
+    getInstance(id: string): MaterialInstance | undefined;
+    getInstanceCount(): number;
+    setTexture(materialId: string, slot: keyof Pick<MaterialDef, 'albedoMap' | 'normalMap' | 'metallicRoughnessMap' | 'emissionMap' | 'aoMap'>, textureId: string): boolean;
+}
+
+/**
+ * MaterialSystem.ts
+ *
+ * PBR material management: shader binding, uniform management,
+ * render state, and instanced variants.
+ *
+ * @module rendering
+ */
+type BlendMode$1 = 'opaque' | 'alpha' | 'additive' | 'multiply';
+type CullMode = 'none' | 'front' | 'back';
+type UniformType = 'float' | 'vec2' | 'vec3' | 'vec4' | 'mat4' | 'int' | 'sampler2D';
+interface UniformDef {
+    name: string;
+    type: UniformType;
+    value: number | number[] | string;
+}
+interface Material {
+    id: string;
+    name: string;
+    shaderId: string;
+    uniforms: Map<string, UniformDef>;
+    blendMode: BlendMode$1;
+    cullMode: CullMode;
+    depthWrite: boolean;
+    depthTest: boolean;
+    renderOrder: number;
+    doubleSided: boolean;
+    albedo: [number, number, number, number];
+    metallic: number;
+    roughness: number;
+    emissive: [number, number, number];
+    normalScale: number;
+}
+declare class MaterialSystem {
+    private materials;
+    private shaders;
+    registerShader(id: string, vertexSrc: string, fragmentSrc: string): void;
+    getShader(id: string): {
+        vertexSrc: string;
+        fragmentSrc: string;
+    } | undefined;
+    createMaterial(id: string, name: string, shaderId: string): Material;
+    getMaterial(id: string): Material | undefined;
+    removeMaterial(id: string): void;
+    getMaterialCount(): number;
+    setUniform(materialId: string, name: string, type: UniformType, value: number | number[] | string): void;
+    getUniform(materialId: string, name: string): UniformDef | undefined;
+    setPBR(materialId: string, props: Partial<Pick<Material, 'albedo' | 'metallic' | 'roughness' | 'emissive' | 'normalScale'>>): void;
+    setBlendMode(materialId: string, mode: BlendMode$1): void;
+    setCullMode(materialId: string, mode: CullMode): void;
+    getSortedMaterials(): Material[];
+    cloneMaterial(sourceId: string, newId: string, newName: string): Material | null;
+}
+
+/**
+ * PostProcessing.ts
+ *
+ * Post-processing effect stack: bloom, tone mapping, SSAO,
+ * color grading, vignette, and chromatic aberration.
+ *
+ * @module rendering
+ */
+type ToneMapper = 'linear' | 'reinhard' | 'aces' | 'filmic';
+interface BloomSettings {
+    enabled: boolean;
+    threshold: number;
+    intensity: number;
+    radius: number;
+    softKnee: number;
+}
+interface SSAOSettings {
+    enabled: boolean;
+    radius: number;
+    intensity: number;
+    bias: number;
+    samples: number;
+}
+interface ColorGradingSettings {
+    enabled: boolean;
+    temperature: number;
+    tint: number;
+    saturation: number;
+    contrast: number;
+    brightness: number;
+    gamma: number;
+}
+interface VignetteSettings {
+    enabled: boolean;
+    intensity: number;
+    smoothness: number;
+    roundness: number;
+}
+interface ChromaticAberrationSettings {
+    enabled: boolean;
+    intensity: number;
+}
+interface PostProcessProfile {
+    id: string;
+    name: string;
+    bloom: BloomSettings;
+    ssao: SSAOSettings;
+    colorGrading: ColorGradingSettings;
+    vignette: VignetteSettings;
+    chromaticAberration: ChromaticAberrationSettings;
+    toneMapping: ToneMapper;
+    exposure: number;
+    antiAliasing: 'none' | 'fxaa' | 'smaa';
+}
+declare const PP_PRESETS: Record<string, Partial<PostProcessProfile>>;
+declare class PostProcessingStack {
+    private profiles;
+    private activeProfileId;
+    constructor();
+    createProfile(id: string, name: string): PostProcessProfile;
+    loadPreset(presetName: string, id?: string): PostProcessProfile | null;
+    getProfile(id: string): PostProcessProfile | undefined;
+    getProfileCount(): number;
+    removeProfile(id: string): boolean;
+    setActive(profileId: string): boolean;
+    getActive(): PostProcessProfile | null;
+    setEffectEnabled(profileId: string, effect: 'bloom' | 'ssao' | 'colorGrading' | 'vignette' | 'chromaticAberration', enabled: boolean): boolean;
+    /**
+     * Blend between two profiles by factor t (0 = from, 1 = to).
+     * Useful for smooth transitions between environments.
+     */
+    blendProfiles(fromId: string, toId: string, t: number): PostProcessProfile | null;
+}
+
+/**
+ * PostProcessStack.ts
+ *
+ * Ordered post-processing effect chain: add/remove effects,
+ * enable/disable, priority ordering, and blend weights.
+ *
+ * @module rendering
+ */
+interface PostProcessEffect$1 {
+    id: string;
+    name: string;
+    priority: number;
+    enabled: boolean;
+    weight: number;
+    params: Map<string, number>;
+    process: (input: Float32Array, width: number, height: number) => Float32Array;
+}
+declare class PostProcessStack {
+    private effects;
+    private sortedCache;
+    private dirty;
+    private enabled;
+    addEffect(name: string, priority: number, process: PostProcessEffect$1['process'], params?: Record<string, number>): PostProcessEffect$1;
+    removeEffect(id: string): boolean;
+    setEnabled(id: string, enabled: boolean): void;
+    setGlobalEnabled(enabled: boolean): void;
+    isGlobalEnabled(): boolean;
+    setWeight(id: string, weight: number): void;
+    process(input: Float32Array, width: number, height: number): Float32Array;
+    private getSorted;
+    reorder(id: string, newPriority: number): void;
+    getEffect(id: string): PostProcessEffect$1 | undefined;
+    getEffectCount(): number;
+    getActiveCount(): number;
+    getEffectNames(): string[];
+    setParam(id: string, param: string, value: number): void;
+    getParam(id: string, param: string): number | undefined;
+}
+
+/**
+ * ProjectorLight.ts
+ *
+ * Cookie projection: frustum-shaped light that projects
+ * a texture pattern onto surfaces. Supports intensity,
+ * falloff, and color.
+ *
+ * @module rendering
+ */
+interface ProjectorConfig {
+    id: string;
+    position: [number, number, number];
+    direction: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    cookieTextureId: string;
+    fov: number;
+    aspectRatio: number;
+    nearClip: number;
+    farClip: number;
+    intensity: number;
+    color: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    falloff: 'none' | 'linear' | 'quadratic';
+    enabled: boolean;
+}
+declare class ProjectorLight {
+    private projectors;
+    create(config: Omit<ProjectorConfig, 'id'> & {
+        id?: string;
+    }): ProjectorConfig;
+    remove(id: string): boolean;
+    get(id: string): ProjectorConfig | undefined;
+    getCount(): number;
+    setPosition(id: string, x: number, y: number, z: number): void;
+    setDirection(id: string, x: number, y: number, z: number): void;
+    setIntensity(id: string, intensity: number): void;
+    setColor(id: string, r: number, g: number, b: number): void;
+    setEnabled(id: string, enabled: boolean): void;
+    getFrustumPlanes(id: string): {
+        near: number;
+        far: number;
+        fov: number;
+        aspect: number;
+    } | null;
+    isPointInFrustum(id: string, point: {
+        x: number;
+        y: number;
+        z: number;
+    }): boolean;
+    computeAttenuation(id: string, distance: number): number;
+    getActive(): ProjectorConfig[];
+}
+
+/**
+ * RenderPass.ts
+ *
+ * Render pass pipeline: ordering, dependencies, framebuffer
+ * attachments, clear ops, and compositing.
+ *
+ * @module rendering
+ */
+type AttachmentFormat = 'rgba8' | 'rgba16f' | 'rgba32f' | 'depth24' | 'depth32f' | 'stencil8';
+type ClearOp = 'clear' | 'load' | 'discard';
+interface FramebufferAttachment {
+    name: string;
+    format: AttachmentFormat;
+    width: number;
+    height: number;
+    clearOp: ClearOp;
+    clearColor?: [number, number, number, number];
+}
+interface RenderPassConfig {
+    id: string;
+    name: string;
+    order: number;
+    enabled: boolean;
+    dependencies: string[];
+    attachments: FramebufferAttachment[];
+    inputs: string[];
+    viewport?: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+}
+declare class RenderPass {
+    private passes;
+    private sortedOrder;
+    addPass(config: RenderPassConfig): void;
+    removePass(id: string): void;
+    getPass(id: string): RenderPassConfig | undefined;
+    enablePass(id: string, enabled: boolean): void;
+    private rebuildOrder;
+    getExecutionOrder(): RenderPassConfig[];
+    validate(): string[];
+    private hasCycle;
+    getPassCount(): number;
+    getAllPasses(): RenderPassConfig[];
+}
+
+/**
+ * RenderGraph.ts
+ *
+ * Declarative render graph: defines passes (shadow, depth-prepass, G-buffer,
+ * lighting, post-process), their texture inputs/outputs, and execution order.
+ * The graph is topologically sorted before execution.
+ *
+ * @module render
+ */
+
+type TextureFormat = 'rgba8unorm' | 'rgba16float' | 'depth24plus' | 'depth32float' | 'r32float' | 'rg16float';
+interface RenderTarget {
+    id: string;
+    width: number;
+    height: number;
+    format: TextureFormat;
+    mipLevels?: number;
+}
+interface RenderPassDescriptor {
+    /** Unique pass name. */
+    id: string;
+    /** Textures this pass reads from. */
+    inputs: string[];
+    /** Textures this pass writes to. */
+    outputs: string[];
+    /** Clear color (null = don't clear). */
+    clearColor?: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    } | null;
+    /** Whether this pass writes to the backbuffer. */
+    presentToScreen?: boolean;
+    /** Execute callback — receives pass context. */
+    execute: (ctx: PassContext) => void;
+    /** Priority hint for ordering (lower = earlier when no dependency). */
+    priority?: number;
+    /** Tags for filtering (e.g., 'shadow', 'transparent', 'post'). */
+    tags?: string[];
+    /** Is this pass enabled? */
+    enabled?: boolean;
+}
+interface PassContext {
+    passId: string;
+    inputs: Map<string, RenderTarget>;
+    outputs: Map<string, RenderTarget>;
+    frameNumber: number;
+    deltaTime: number;
+    width: number;
+    height: number;
+}
+interface GraphStats {
+    passCount: number;
+    targetCount: number;
+    executionOrderMs: number;
+    passTimings: Map<string, number>;
+}
+declare class RenderGraph implements EngineSystem {
+    readonly name = "RenderGraph";
+    readonly priority = 900;
+    private passes;
+    private targets;
+    private executionOrder;
+    private dirty;
+    private frameNumber;
+    private width;
+    private height;
+    private stats;
+    setResolution(width: number, height: number): void;
+    addTarget(target: RenderTarget): this;
+    removeTarget(id: string): boolean;
+    getTarget(id: string): RenderTarget | undefined;
+    addPass(pass: RenderPassDescriptor): this;
+    removePass(id: string): boolean;
+    enablePass(id: string, enabled: boolean): void;
+    getPass(id: string): RenderPassDescriptor | undefined;
+    getPassesByTag(tag: string): RenderPassDescriptor[];
+    private compile;
+    lateUpdate(dt: number): void;
+    getExecutionOrder(): string[];
+    getStats(): GraphStats;
+    /**
+     * Set up a standard forward+ rendering pipeline:
+     * shadow → depth-prepass → main-color → post-process → present
+     */
+    setupForwardPipeline(): this;
+    destroy(): void;
+}
+
+/**
+ * RayTracing.ts
+ *
+ * CPU-side software ray tracing engine:
+ *   - Axis-Aligned Bounding Box (AABB) representation
+ *   - BVH (Bounding Volume Hierarchy) construction with SAH splits
+ *   - Ray-AABB intersection (slab method)
+ *   - Ray-triangle intersection (Möller–Trumbore)
+ *   - Simple path tracer loop (configurable bounces, Russian roulette)
+ *   - Non-Local Means (NLM) bilateral denoising filter
+ *   - RayTracingConfig descriptor (rt_api, features, spp, max_bounces)
+ *
+ * Fully CPU / TypeScript — testable without GPU.
+ * Production GPU backends (DXR, OptiX, WebGPU RT extension) would
+ * use these structures to generate shader pipelines.
+ *
+ * @module rendering
+ */
+type Vec3 = {
+    x: number;
+    y: number;
+    z: number;
+};
+type RTApi = 'dxr' | 'optix' | 'metal_rt' | 'vulkan_rt' | 'software';
+type RTFeature = 'reflections' | 'shadows' | 'ao' | 'gi';
+interface RayTracingConfig {
+    rt_api: RTApi;
+    features: RTFeature[];
+    /** Samples per pixel */
+    spp: number;
+    /** Max path tracing bounces */
+    max_bounces: number;
+    denoising: 'nlm' | 'none';
+}
+interface AABB {
+    min: Vec3;
+    max: Vec3;
+}
+interface Triangle {
+    v0: Vec3;
+    v1: Vec3;
+    v2: Vec3;
+    /** Pre-computed normal (optional, computed on demand) */
+    normal?: Vec3;
+}
+interface Ray {
+    origin: Vec3;
+    direction: Vec3;
+    tMin: number;
+    tMax: number;
+}
+interface HitRecord {
+    t: number;
+    point: Vec3;
+    normal: Vec3;
+    triangleIndex: number;
+}
+declare function computeTriangleNormal(tri: Triangle): Vec3;
+declare function computeAABB(triangles: Triangle[], start: number, end: number): AABB;
+declare function aabbSurfaceArea(box: AABB): number;
+declare function aabbCentroid(box: AABB): Vec3;
+/**
+ * Ray–AABB intersection (slab method).
+ * Returns t of intersection or -1 if miss.
+ */
+declare function intersectRayAABB(ray: Ray, box: AABB): number;
+/**
+ * Ray–triangle intersection (Möller–Trumbore).
+ * Returns t of intersection or -1 if miss / back-face.
+ */
+declare function intersectRayTriangle(ray: Ray, tri: Triangle): number;
+interface BVHNode {
+    bound: AABB;
+    leftChild: number;
+    rightChild: number;
+    triStart: number;
+    triCount: number;
+}
+declare class BVH {
+    nodes: BVHNode[];
+    tris: Triangle[];
+    /** Build from an array of triangles using SAH binned splits */
+    build(triangles: Triangle[]): void;
+    getNodeCount(): number;
+    getLeafCount(): number;
+    private buildRecursive;
+    /**
+     * Traverse BVH to find nearest hit for a ray.
+     */
+    intersect(ray: Ray): HitRecord | null;
+}
+interface PathTracerScene {
+    bvh: BVH;
+    /** Ambient (sky) radiance (RGB) for misses */
+    skyColor: [number, number, number];
+    /** Light positions for shadow rays */
+    lights: Array<{
+        position: Vec3;
+        color: [number, number, number];
+        intensity: number;
+    }>;
+}
+/**
+ * Path-trace a single ray for up to maxBounces bounces.
+ * Returns linear RGB radiance estimate.
+ */
+declare function pathTrace(ray: Ray, scene: PathTracerScene, maxBounces: number, seed: number): [number, number, number];
+interface NLMConfig {
+    /** Search window half-size in pixels */
+    searchRadius: number;
+    /** Patch half-size */
+    patchRadius: number;
+    /** Filter strength */
+    h: number;
+}
+/**
+ * Non-Local Means bilateral denoising on a Float32Array RGBA buffer.
+ * Reduces noise while preserving edges.
+ */
+declare function nlmDenoise(noisy: Float32Array, width: number, height: number, config?: Partial<NLMConfig>): Float32Array;
+declare class RayTracer {
+    private config;
+    private scene;
+    constructor(config?: Partial<RayTracingConfig>);
+    getConfig(): Readonly<RayTracingConfig>;
+    setFeatures(features: RTFeature[]): void;
+    hasFeature(f: RTFeature): boolean;
+    loadScene(triangles: Triangle[], lights?: {
+        position: Vec3;
+        color: [number, number, number];
+        intensity: number;
+    }[], sky?: [number, number, number]): void;
+    getBVH(): BVH;
+    /** Render a single pixel with multi-sample path tracing */
+    renderPixel(rayOrigin: Vec3, rayDir: Vec3, pixelX: number, pixelY: number): [number, number, number];
+}
+
+/**
+ * ScreenSpaceEffects.ts
+ *
+ * Screen-space post-processing effects (CPU simulation / offline renderer):
+ *   - SSAO  (Scalable Ambient Obscurance — hemispherical sampling)
+ *   - SSR   (Screen-Space Reflections — linear ray march in projection)
+ *   - SSGI  (Screen-Space Global Illumination — short-range bounce)
+ *   - TAA   (Temporal Anti-Aliasing — history blend with jitter)
+ *   - Motion Blur (velocity-buffer blur)
+ *   - DOF   (Depth of Field — circle-of-confusion + gather)
+ *   - Chromatic Aberration
+ *   - Film Grain
+ *   - Vignette
+ *
+ * All operations work on flat Float32Array pixel buffers (RGBA, linear).
+ * No WebGPU / DOM — fully testable in Vitest.
+ *
+ * @module rendering
+ */
+type PixelBuffer = Float32Array;
+interface SSAOConfig {
+    /** Number of hemisphere samples (default 16) */
+    samples: number;
+    /** Sampling radius in world units */
+    radius: number;
+    /** Depth bias to prevent self-occlusion */
+    bias: number;
+    /** 0–1, power curve for occlusion accumulation */
+    power: number;
+}
+/**
+ * Compute SSAO occlusion factor per pixel.
+ * @param depth - Float32Array, R channel = linear depth (0–1)
+ * @param normals - Float32Array, RGB = world-space normal XYZ
+ * @returns Float32Array (R only), occlusion 0 (occluded) to 1 (clear)
+ */
+declare function computeSSAO(depth: PixelBuffer, normals: PixelBuffer, width: number, height: number, config?: Partial<SSAOConfig>): Float32Array;
+interface SSRConfig {
+    /** Max ray march steps */
+    steps: number;
+    /** Step size in screen pixels */
+    stepSize: number;
+    /** Max roughness threshold (rougher surfaces skip SSR) */
+    maxRoughness: number;
+    /** Thickness (depth tolerance) */
+    thickness: number;
+}
+/**
+ * Screen-space reflection mask: returns a Float32Array (0–1, R channel)
+ * indicating reflection presence at each pixel, plus the reflected UV coords.
+ */
+declare function computeSSR(color: PixelBuffer, depth: PixelBuffer, width: number, height: number, roughness: Float32Array, config?: Partial<SSRConfig>): {
+    mask: Float32Array;
+    uvs: Float32Array;
+};
+interface SSGIConfig {
+    /** Sample count per pixel */
+    sampleCount: number;
+    /** Sampling radius in pixels */
+    radius: number;
+    /** Intensity multiplier */
+    intensity: number;
+}
+/**
+ * Very short-range GI approximation: samples nearby pixels and
+ * bleeds their colour onto the current pixel (one-bounce).
+ * Returns a Float32Array (RGBA) indirect irradiance buffer.
+ */
+declare function computeSSGI(color: PixelBuffer, depth: PixelBuffer, width: number, height: number, config?: Partial<SSGIConfig>): PixelBuffer;
+interface TAAConfig {
+    /** Feedback (history blend) factor: 0 = no history, 1 = full history */
+    feedback: number;
+    /** Halton jitter scale in screen pixels */
+    jitterScale: number;
+}
+/** Halton sequence (base 2, base 3 for xy jitter) */
+declare function haltonJitter(frameIndex: number): [number, number];
+/**
+ * Blend current frame with history buffer (TAA).
+ * history is modified in-place with each call.
+ */
+declare function blendTAA(current: PixelBuffer, history: PixelBuffer, width: number, height: number, config?: Partial<TAAConfig>): PixelBuffer;
+interface MotionBlurConfig {
+    /** Number of blur samples */
+    sampleCount: number;
+    /** Max blur length in pixels */
+    maxLength: number;
+}
+/**
+ * Apply motion blur using a velocity buffer.
+ * @param velocity - Float32Array, RG = velocity XY in pixels/frame
+ */
+declare function applyMotionBlur(color: PixelBuffer, velocity: PixelBuffer, width: number, height: number, config?: Partial<MotionBlurConfig>): PixelBuffer;
+interface DOFConfig {
+    /** Focal depth (0–1 normalized) */
+    focalDepth: number;
+    /** Focal range — depths within ±range of focalDepth are sharp */
+    focalRange: number;
+    /** Max CoC radius in pixels */
+    maxRadiusPx: number;
+    /** Sample count per pixel */
+    sampleCount: number;
+}
+/** Compute Circle of Confusion radius for a given depth value */
+declare function computeCoC(depth: number, config?: Partial<DOFConfig>): number;
+/**
+ * Apply DOF using a disc gather (CPU approximate bokeh).
+ */
+declare function applyDOF(color: PixelBuffer, depth: PixelBuffer, width: number, height: number, config?: Partial<DOFConfig>): PixelBuffer;
+interface ChromaticAberrationConfig {
+    /** Aberration offset in pixels at the screen edge */
+    strength: number;
+}
+/**
+ * Chromatic aberration (RGB channel offset towards edges).
+ */
+declare function applyChromaticAberration(color: PixelBuffer, width: number, height: number, config?: Partial<ChromaticAberrationConfig> & {
+    strength?: number;
+}): PixelBuffer;
+/**
+ * Add film grain noise.
+ * @param intensity 0–1, grain strength
+ * @param seed Deterministic seed for repeatable grain pattern
+ */
+declare function applyFilmGrain(color: PixelBuffer, width: number, height: number, intensity: number, seed?: number): PixelBuffer;
+/**
+ * Apply a radial vignette (darker at corners).
+ * @param strength 0–1
+ * @param radius 0–1, the point where vignette begins
+ */
+declare function applyVignette(color: PixelBuffer, width: number, height: number, strength: number, radius?: number): PixelBuffer;
+
+/**
+ * ShaderGraph.ts
+ *
+ * Node-based shader composition: connects material properties
+ * through a DAG of shader nodes, generates uniform declarations,
+ * and outputs combined shader code.
+ *
+ * @module rendering
+ */
+type ShaderDataType = 'float' | 'vec2' | 'vec3' | 'vec4' | 'mat4' | 'sampler2D' | 'bool' | 'int';
+interface ShaderPort {
+    name: string;
+    type: ShaderDataType;
+    defaultValue?: number | number[];
+}
+interface ShaderNodeDef {
+    type: string;
+    inputs: ShaderPort[];
+    outputs: ShaderPort[];
+    code: string;
+}
+interface ShaderPortRef {
+    id: string;
+    name: string;
+    direction: 'in' | 'out';
+    type: ShaderDataType;
+}
+interface ShaderNode {
+    id: string;
+    type: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    overrides: Record<string, number | number[]>;
+    category?: string;
+    inputs?: ShaderPort[];
+    outputs?: ShaderPort[];
+    ports?: ShaderPortRef[];
+    properties?: Record<string, unknown>;
+}
+interface ShaderConnection {
+    id: string;
+    fromNode: string;
+    fromPort: string;
+    toNode: string;
+    toPort: string;
+}
+interface ShaderUniform {
+    name: string;
+    type: ShaderDataType;
+    value: number | number[];
+}
+interface CompiledShader {
+    vertexCode: string;
+    fragmentCode: string;
+    uniforms: ShaderUniform[];
+    nodeCount: number;
+    connectionCount: number;
+}
+declare const SHADER_NODES: Record<string, ShaderNodeDef>;
+declare class ShaderGraph {
+    readonly id: string;
+    name: string;
+    nodes: Map<string, ShaderNode>;
+    connections: ShaderConnection[];
+    version: number;
+    readonly createdAt: number;
+    updatedAt: number;
+    private nodeDefs;
+    constructor(id?: string, name?: string);
+    addNode(type: string, x?: number, y?: number, overrides?: Record<string, number | number[]>): ShaderNode | null;
+    createNode(type: string, position: {
+        x: number;
+        y: number;
+    }): ShaderNode | null;
+    /** Add a pre-built ShaderNode directly (used by undo/redo systems). */
+    addCustomNode(node: ShaderNode): void;
+    removeNode(id: string): boolean;
+    getNode(id: string): ShaderNode | undefined;
+    getNodes(): ShaderNode[];
+    getNodeCount(): number;
+    setNodePosition(id: string, x: number, y: number): boolean;
+    setNodeProperty(id: string, key: string, value: unknown): boolean;
+    getNodeProperty(id: string, key: string): unknown;
+    connect(fromNode: string, fromPort: string, toNode: string, toPort: string): ShaderConnection | null;
+    /** Check if adding an edge from→to would create a cycle via DFS. */
+    private _wouldCreateCycle;
+    disconnectPort(nodeId: string, portId: string): void;
+    getConnections(): ShaderConnection[];
+    getNodeConnections(nodeId: string): ShaderConnection[];
+    toJSON(): {
+        name: string;
+        id: string;
+        nodes: [string, ShaderNode][];
+        connections: ShaderConnection[];
+    };
+    static fromJSON(json: {
+        name: string;
+        id?: string;
+        nodes: [string, ShaderNode][];
+        connections: ShaderConnection[];
+    }): ShaderGraph;
+    serialize(): string;
+    static deserialize(str: string): ShaderGraph;
+    compile(): CompiledShader;
+    private generateVertexShader;
+    private topoSort;
+}
+
+/**
+ * SubsurfaceScattering.ts
+ *
+ * Subsurface scattering (SSS) implementation:
+ *   - Burley/Christensen normalized diffusion profile
+ *   - Multi-channel RGB scatter radii (skin: R large, G medium, B small)
+ *   - Multi-layer SSS (epidermis / dermis)
+ *   - Thin-slab transmission approximation
+ *   - Thickness map sampling (Float32Array or constant)
+ *   - Separable SSS blur kernel (screen-space blur weights via Gaussian sum)
+ *   - Pre-built material profiles (skin, wax, jade, marble, leaves)
+ *
+ * No WebGPU — fully CPU-testable in Vitest.
+ *
+ * @module rendering
+ */
+type RGB = [number, number, number];
+type SSSModel = 'burley' | 'christensen' | 'separable_sss';
+interface SSSLayer {
+    /** Weight of this layer (0–1, sum of all layers should ≤ 1) */
+    weight: number;
+    /** Per-channel (R, G, B) scattering radius in world units */
+    scatterRadius: RGB;
+    /** Base scatter color (tint) */
+    color: RGB;
+}
+interface SSSConfig {
+    model: SSSModel;
+    /** Diffusion radius falloff shape (1 = linear, 2 = quadratic like Burley) */
+    falloffPower: number;
+    /** Transmission (0 = opaque, 1 = fully transparent thin slab) */
+    transmission: number;
+    /** Constant thickness if no thickness map provided (0–1) */
+    thickness: number;
+    layers: SSSLayer[];
+}
+/**
+ * Burley normalized diffusion profile: R(r) = A/r * (e^(-r/d) + e^(-r/(3d)))
+ * Returns relative diffusion weight at distance r for a given mean free path d.
+ *
+ * Reference: Burley 2015, "Extending the Disney BRDF to a BSDF with Integrated Subsurface Scattering"
+ */
+declare function burleyProfile(r: number, d: number, A?: number): number;
+/**
+ * Sample Burley profile across R, G, B channels.
+ * scatterRadius = mean free path per channel.
+ */
+declare function burleyProfileRGB(r: number, scatterRadius: RGB): RGB;
+/**
+ * Christensen–Burley profile (fitted polynomial, cheaper to evaluate).
+ * From "An Approximate Reflectance Profile for Efficient Subsurface Scattering"
+ *
+ * R(r) = (e^(-A*r/d) + e^(-A*r/(3d))) * A / (8πd)
+ */
+declare function christensenProfile(r: number, d: number, A?: number): number;
+/**
+ * Gaussian sum blur weights (Jimenez 2012 Separable SSS).
+ * Returns N weight-variance pairs [{ weight, variance }] per channel.
+ *
+ * The kernel width is controlled by scatterRadius.
+ */
+declare function buildSeparableSSSKernel(scatterRadius: RGB, numGaussians?: number): Array<{
+    weight: number;
+    stddev: RGB;
+}>;
+/**
+ * Evaluate a separable Gaussian blur at offset x (signed, in world units).
+ * Returns RGB weight.
+ */
+declare function evalSeparableKernel(kernel: Array<{
+    weight: number;
+    stddev: RGB;
+}>, x: number): RGB;
+/**
+ * Thin-slab transmission amount using Beer-Lambert approximation.
+ * thickness: 0 = thin (high transmission), 1 = thick (low transmission).
+ * Returns transmission factor [0, 1].
+ */
+declare function thinSlabTransmission(thickness: number, config: Pick<SSSConfig, 'transmission' | 'layers'>): RGB;
+declare class SSSMaterial {
+    private config;
+    constructor(config?: Partial<SSSConfig>);
+    getConfig(): Readonly<SSSConfig>;
+    setModel(model: SSSModel): void;
+    setTransmission(t: number): void;
+    setThickness(t: number): void;
+    addLayer(layer: SSSLayer): void;
+    getLayerCount(): number;
+    /**
+     * Evaluate SSS diffusion at a surface point for a given light exit radius.
+     * r: distance between light entry and exit point on the surface.
+     */
+    evaluate(r: number): RGB;
+    /** Evaluate thin-slab transmission at the material's configured thickness */
+    getTransmission(thicknessOverride?: number): RGB;
+    /** Get Separable SSS kernel for this material (first layer) */
+    getKernel(numGaussians?: number): ReturnType<typeof buildSeparableSSSKernel>;
+}
+declare const SSS_PRESETS: {
+    /** Human skin: epidermis (yellow tint) + dermis (red) */
+    humanSkin: () => SSSMaterial;
+    /** Wax candle (high SSS, warm light transmission) */
+    wax: () => SSSMaterial;
+    /** Jade gemstone (cool, dense SSS) */
+    jade: () => SSSMaterial;
+    /** Marble (dense, RGB-balanced) */
+    marble: () => SSSMaterial;
+    /** Leaf / plant (very thin, high transmission) */
+    leaf: () => SSSMaterial;
+};
+
+/**
+ * VolumetricLight.ts
+ *
+ * Volumetric/god ray lighting: scattering computation,
+ * shadow-aware shafts, intensity falloff, and ray marching.
+ *
+ * @module rendering
+ */
+interface VolumetricLightConfig {
+    id: string;
+    position: [number, number, number];
+    direction: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    color: [number, number, number];
+    intensity: number;
+    scattering: number;
+    decay: number;
+    samples: number;
+    maxDistance: number;
+    shadowDensity: number;
+    enabled: boolean;
+}
+interface VolumetricSample {
+    position: [number, number, number];
+    accumulated: number;
+    step: number;
+}
+declare class VolumetricLight {
+    private lights;
+    addLight(config: Partial<VolumetricLightConfig> & {
+        id: string;
+    }): VolumetricLightConfig;
+    removeLight(id: string): void;
+    getLight(id: string): VolumetricLightConfig | undefined;
+    getLightCount(): number;
+    march(lightId: string, viewPos: {
+        x: number;
+        y: number;
+        z: number;
+    }, viewDir: {
+        x: number;
+        y: number;
+        z: number;
+    }): VolumetricSample[];
+    getScatteringAt(lightId: string, worldPos: {
+        x: number;
+        y: number;
+        z: number;
+    }): number;
+    private normalize;
+}
+
+/**
+ * WebGPU Renderer Types
+ *
+ * Type definitions for WebGPU-based rendering system
+ */
+/** WebGPU initialization options */
+interface IWebGPUInitOptions {
+    /** Canvas element or selector */
+    canvas: HTMLCanvasElement | string;
+    /** Preferred adapter power preference */
+    powerPreference?: 'low-power' | 'high-performance';
+    /** Required features */
+    requiredFeatures?: GPUFeatureName[];
+    /** Required limits */
+    requiredLimits?: Record<string, number>;
+    /** Enable debug mode */
+    debug?: boolean;
+    /** Preferred texture format (auto-detected if not specified) */
+    preferredFormat?: GPUTextureFormat;
+    /** MSAA sample count */
+    sampleCount?: 1 | 4;
+    /** Alpha mode for canvas */
+    alphaMode?: GPUCanvasAlphaMode;
+}
+/** WebGPU context after initialization */
+interface IWebGPUContext {
+    /** GPU adapter */
+    adapter: GPUAdapter;
+    /** GPU device */
+    device: GPUDevice;
+    /** Canvas context */
+    context: GPUCanvasContext;
+    /** Preferred texture format */
+    format: GPUTextureFormat;
+    /** Canvas element */
+    canvas: HTMLCanvasElement;
+    /** Device capabilities */
+    capabilities: IDeviceCapabilities;
+}
+/** Device capabilities and limits */
+interface IDeviceCapabilities {
+    maxTextureDimension2D: number;
+    maxTextureArrayLayers: number;
+    maxBindGroups: number;
+    maxBindingsPerBindGroup: number;
+    maxBufferSize: number;
+    maxUniformBufferBindingSize: number;
+    maxStorageBufferBindingSize: number;
+    maxVertexBuffers: number;
+    maxVertexAttributes: number;
+    maxComputeWorkgroupsPerDimension: number;
+    features: Set<string>;
+}
+/** Render pipeline descriptor */
+interface IRenderPipelineDescriptor {
+    /** Pipeline label for debugging */
+    label?: string;
+    /** Vertex shader module */
+    vertexShader: IShaderModule;
+    /** Fragment shader module */
+    fragmentShader: IShaderModule;
+    /** Vertex buffer layouts */
+    vertexBufferLayouts: IVertexBufferLayout[];
+    /** Primitive topology */
+    topology?: GPUPrimitiveTopology;
+    /** Cull mode */
+    cullMode?: GPUCullMode;
+    /** Front face winding */
+    frontFace?: GPUFrontFace;
+    /** Depth/stencil state */
+    depthStencil?: IDepthStencilState;
+    /** Color target states */
+    colorTargets: IColorTargetState[];
+    /** Bind group layouts */
+    bindGroupLayouts?: GPUBindGroupLayout[];
+    /** MSAA sample count */
+    sampleCount?: number;
+}
+/** Shader module definition */
+interface IShaderModule {
+    /** WGSL source code */
+    code: string;
+    /** Entry point function name */
+    entryPoint: string;
+    /** Shader label */
+    label?: string;
+}
+/** Vertex buffer layout */
+interface IVertexBufferLayout {
+    /** Stride in bytes */
+    arrayStride: number;
+    /** Step mode */
+    stepMode?: GPUVertexStepMode;
+    /** Vertex attributes */
+    attributes: IVertexAttribute[];
+}
+/** Vertex attribute definition */
+interface IVertexAttribute {
+    /** Attribute format */
+    format: GPUVertexFormat;
+    /** Byte offset */
+    offset: number;
+    /** Shader location */
+    shaderLocation: number;
+}
+/** Depth/stencil state */
+interface IDepthStencilState {
+    /** Depth texture format */
+    format: GPUTextureFormat;
+    /** Enable depth write */
+    depthWriteEnabled: boolean;
+    /** Depth comparison function */
+    depthCompare: GPUCompareFunction;
+    /** Stencil front face */
+    stencilFront?: IStencilFaceState;
+    /** Stencil back face */
+    stencilBack?: IStencilFaceState;
+    /** Depth bias */
+    depthBias?: number;
+    /** Depth bias slope scale */
+    depthBiasSlopeScale?: number;
+    /** Depth bias clamp */
+    depthBiasClamp?: number;
+}
+/** Stencil face state */
+interface IStencilFaceState {
+    compare?: GPUCompareFunction;
+    failOp?: GPUStencilOperation;
+    depthFailOp?: GPUStencilOperation;
+    passOp?: GPUStencilOperation;
+}
+/** Color target state */
+interface IColorTargetState {
+    /** Texture format */
+    format: GPUTextureFormat;
+    /** Blend state */
+    blend?: IBlendState;
+    /** Color write mask */
+    writeMask?: GPUColorWriteFlags;
+}
+/** Blend state */
+interface IBlendState {
+    /** Color blend component */
+    color: IBlendComponent;
+    /** Alpha blend component */
+    alpha: IBlendComponent;
+}
+/** Blend component */
+interface IBlendComponent {
+    operation?: GPUBlendOperation;
+    srcFactor?: GPUBlendFactor;
+    dstFactor?: GPUBlendFactor;
+}
+/** GPU buffer descriptor */
+interface IBufferDescriptor {
+    /** Buffer label */
+    label?: string;
+    /** Size in bytes */
+    size: number;
+    /** Buffer usage flags */
+    usage: GPUBufferUsageFlags;
+    /** Map at creation */
+    mappedAtCreation?: boolean;
+}
+/** Uniform buffer data */
+interface IUniformBuffer {
+    /** Buffer handle */
+    buffer: GPUBuffer;
+    /** Current data */
+    data: ArrayBuffer;
+    /** Binding index */
+    binding: number;
+    /** Last update frame */
+    lastUpdateFrame: number;
+}
+/** Vertex buffer data */
+interface IVertexBuffer {
+    /** Buffer handle */
+    buffer: GPUBuffer;
+    /** Vertex count */
+    vertexCount: number;
+    /** Stride in bytes */
+    stride: number;
+    /** Buffer slot */
+    slot: number;
+}
+/** Index buffer data */
+interface IIndexBuffer {
+    /** Buffer handle */
+    buffer: GPUBuffer;
+    /** Index count */
+    indexCount: number;
+    /** Index format */
+    format: GPUIndexFormat;
+}
+/** Texture descriptor */
+interface ITextureDescriptor {
+    /** Texture label */
+    label?: string;
+    /** Width in pixels */
+    width: number;
+    /** Height in pixels */
+    height: number;
+    /** Depth or array layers */
+    depthOrArrayLayers?: number;
+    /** Mip level count */
+    mipLevelCount?: number;
+    /** Sample count */
+    sampleCount?: number;
+    /** Texture dimension */
+    dimension?: GPUTextureDimension;
+    /** Texture format */
+    format: GPUTextureFormat;
+    /** Texture usage */
+    usage: GPUTextureUsageFlags;
+}
+/** Sampler descriptor */
+interface ISamplerDescriptor {
+    /** Sampler label */
+    label?: string;
+    /** Address mode U */
+    addressModeU?: GPUAddressMode;
+    /** Address mode V */
+    addressModeV?: GPUAddressMode;
+    /** Address mode W */
+    addressModeW?: GPUAddressMode;
+    /** Mag filter */
+    magFilter?: GPUFilterMode;
+    /** Min filter */
+    minFilter?: GPUFilterMode;
+    /** Mipmap filter */
+    mipmapFilter?: GPUMipmapFilterMode;
+    /** LOD min clamp */
+    lodMinClamp?: number;
+    /** LOD max clamp */
+    lodMaxClamp?: number;
+    /** Compare function for shadow maps */
+    compare?: GPUCompareFunction;
+    /** Max anisotropy */
+    maxAnisotropy?: number;
+}
+/** GPU texture with metadata */
+interface IGPUTexture {
+    /** Texture handle */
+    texture: GPUTexture;
+    /** Default view */
+    view: GPUTextureView;
+    /** Sampler */
+    sampler: GPUSampler;
+    /** Width */
+    width: number;
+    /** Height */
+    height: number;
+    /** Format */
+    format: GPUTextureFormat;
+    /** Mip levels */
+    mipLevels: number;
+}
+/** Render pass descriptor */
+interface IRenderPassDescriptor {
+    /** Pass label */
+    label?: string;
+    /** Color attachments */
+    colorAttachments: IRenderPassColorAttachment[];
+    /** Depth/stencil attachment */
+    depthStencilAttachment?: IRenderPassDepthStencilAttachment;
+    /** Occlusion query set */
+    occlusionQuerySet?: GPUQuerySet;
+    /** Timestamp writes */
+    timestampWrites?: GPURenderPassTimestampWrites;
+}
+/** Color attachment */
+interface IRenderPassColorAttachment {
+    /** View to render to */
+    view: GPUTextureView;
+    /** Resolve target for MSAA */
+    resolveTarget?: GPUTextureView;
+    /** Clear value */
+    clearValue?: GPUColor;
+    /** Load operation */
+    loadOp: GPULoadOp;
+    /** Store operation */
+    storeOp: GPUStoreOp;
+}
+/** Depth/stencil attachment */
+interface IRenderPassDepthStencilAttachment {
+    /** Depth texture view */
+    view: GPUTextureView;
+    /** Depth clear value */
+    depthClearValue?: number;
+    /** Depth load op */
+    depthLoadOp?: GPULoadOp;
+    /** Depth store op */
+    depthStoreOp?: GPUStoreOp;
+    /** Depth read-only */
+    depthReadOnly?: boolean;
+    /** Stencil clear value */
+    stencilClearValue?: number;
+    /** Stencil load op */
+    stencilLoadOp?: GPULoadOp;
+    /** Stencil store op */
+    stencilStoreOp?: GPUStoreOp;
+    /** Stencil read-only */
+    stencilReadOnly?: boolean;
+}
+/** Renderable mesh */
+interface IRenderMesh {
+    /** Mesh identifier */
+    id: string;
+    /** Vertex buffers */
+    vertexBuffers: IVertexBuffer[];
+    /** Index buffer (optional) */
+    indexBuffer?: IIndexBuffer;
+    /** Vertex count (for non-indexed draws) */
+    vertexCount: number;
+    /** Instance count */
+    instanceCount: number;
+    /** Bounding box for culling */
+    boundingBox?: IBoundingBox;
+}
+/** Bounding box for frustum culling */
+interface IBoundingBox {
+    min: [number, number, number];
+    max: [number, number, number];
+}
+/** Material for rendering */
+interface IRenderMaterial {
+    /** Material identifier */
+    id: string;
+    /** Pipeline to use */
+    pipelineId: string;
+    /** Bind group for material uniforms */
+    bindGroup: GPUBindGroup;
+    /** Textures */
+    textures: Map<string, IGPUTexture>;
+    /** Uniform data */
+    uniforms: ArrayBuffer;
+    /** Transparency flag */
+    transparent: boolean;
+    /** Double-sided flag */
+    doubleSided: boolean;
+}
+/** Draw call */
+interface IDrawCall {
+    /** Mesh to draw */
+    mesh: IRenderMesh;
+    /** Material to use */
+    material: IRenderMaterial;
+    /** Model matrix */
+    modelMatrix: Float32Array;
+    /** Sort key for batching */
+    sortKey: number;
+    /** Distance from camera (for transparency sorting) */
+    cameraDistance?: number;
+}
+/** Camera uniforms */
+interface ICameraUniforms {
+    /** View matrix */
+    viewMatrix: Float32Array;
+    /** Projection matrix */
+    projectionMatrix: Float32Array;
+    /** View-projection matrix */
+    viewProjectionMatrix: Float32Array;
+    /** Inverse view matrix */
+    inverseViewMatrix: Float32Array;
+    /** Inverse projection matrix */
+    inverseProjectionMatrix: Float32Array;
+    /** Camera position */
+    cameraPosition: Float32Array;
+    /** Near plane */
+    near: number;
+    /** Far plane */
+    far: number;
+    /** Field of view (radians) */
+    fov: number;
+    /** Aspect ratio */
+    aspectRatio: number;
+}
+/** Scene uniforms */
+interface ISceneUniforms {
+    /** Ambient light color */
+    ambientColor: Float32Array;
+    /** Time since start */
+    time: number;
+    /** Delta time */
+    deltaTime: number;
+    /** Frame number */
+    frameNumber: number;
+}
+/** Frame statistics */
+interface IFrameStats {
+    /** Frame time in milliseconds */
+    frameTime: number;
+    /** GPU time in milliseconds (if available) */
+    gpuTime?: number;
+    /** Draw calls */
+    drawCalls: number;
+    /** Triangles rendered */
+    triangles: number;
+    /** Vertices processed */
+    vertices: number;
+    /** Pipeline switches */
+    pipelineSwitches: number;
+    /** Bind group switches */
+    bindGroupSwitches: number;
+    /** Buffer uploads */
+    bufferUploads: number;
+    /** Texture uploads */
+    textureUploads: number;
+}
+/** Renderer statistics */
+interface IRendererStats {
+    /** Current frame stats */
+    currentFrame: IFrameStats;
+    /** Rolling average stats */
+    average: IFrameStats;
+    /** Total frames rendered */
+    totalFrames: number;
+    /** FPS */
+    fps: number;
+    /** GPU memory usage (if available) */
+    gpuMemory?: number;
+}
+/** Standard PBR vertex shader */
+declare const STANDARD_VERTEX_SHADER = "\nstruct VertexInput {\n  @location(0) position: vec3<f32>,\n  @location(1) normal: vec3<f32>,\n  @location(2) uv: vec2<f32>,\n}\n\nstruct VertexOutput {\n  @builtin(position) position: vec4<f32>,\n  @location(0) worldPosition: vec3<f32>,\n  @location(1) worldNormal: vec3<f32>,\n  @location(2) uv: vec2<f32>,\n}\n\nstruct CameraUniforms {\n  viewProjectionMatrix: mat4x4<f32>,\n  cameraPosition: vec3<f32>,\n}\n\nstruct ModelUniforms {\n  modelMatrix: mat4x4<f32>,\n  normalMatrix: mat3x3<f32>,\n}\n\n@group(0) @binding(0) var<uniform> camera: CameraUniforms;\n@group(1) @binding(0) var<uniform> model: ModelUniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n  var output: VertexOutput;\n  let worldPos = model.modelMatrix * vec4<f32>(input.position, 1.0);\n  output.position = camera.viewProjectionMatrix * worldPos;\n  output.worldPosition = worldPos.xyz;\n  output.worldNormal = normalize(model.normalMatrix * input.normal);\n  output.uv = input.uv;\n  return output;\n}\n";
+/** Standard PBR fragment shader */
+declare const STANDARD_FRAGMENT_SHADER = "\nstruct FragmentInput {\n  @location(0) worldPosition: vec3<f32>,\n  @location(1) worldNormal: vec3<f32>,\n  @location(2) uv: vec2<f32>,\n}\n\nstruct MaterialUniforms {\n  baseColor: vec4<f32>,\n  metallic: f32,\n  roughness: f32,\n  emissive: vec3<f32>,\n}\n\nstruct LightUniforms {\n  direction: vec3<f32>,\n  color: vec3<f32>,\n  intensity: f32,\n}\n\n@group(0) @binding(1) var<uniform> material: MaterialUniforms;\n@group(0) @binding(2) var<uniform> light: LightUniforms;\n@group(2) @binding(0) var baseColorTexture: texture_2d<f32>;\n@group(2) @binding(1) var baseColorSampler: sampler;\n\nconst PI: f32 = 3.14159265359;\n\nfn fresnelSchlick(cosTheta: f32, F0: vec3<f32>) -> vec3<f32> {\n  return F0 + (1.0 - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);\n}\n\nfn distributionGGX(N: vec3<f32>, H: vec3<f32>, roughness: f32) -> f32 {\n  let a = roughness * roughness;\n  let a2 = a * a;\n  let NdotH = max(dot(N, H), 0.0);\n  let NdotH2 = NdotH * NdotH;\n  let nom = a2;\n  var denom = (NdotH2 * (a2 - 1.0) + 1.0);\n  denom = PI * denom * denom;\n  return nom / denom;\n}\n\nfn geometrySchlickGGX(NdotV: f32, roughness: f32) -> f32 {\n  let r = roughness + 1.0;\n  let k = (r * r) / 8.0;\n  let nom = NdotV;\n  let denom = NdotV * (1.0 - k) + k;\n  return nom / denom;\n}\n\nfn geometrySmith(N: vec3<f32>, V: vec3<f32>, L: vec3<f32>, roughness: f32) -> f32 {\n  let NdotV = max(dot(N, V), 0.0);\n  let NdotL = max(dot(N, L), 0.0);\n  let ggx2 = geometrySchlickGGX(NdotV, roughness);\n  let ggx1 = geometrySchlickGGX(NdotL, roughness);\n  return ggx1 * ggx2;\n}\n\n@fragment\nfn main(input: FragmentInput) -> @location(0) vec4<f32> {\n  let baseColor = textureSample(baseColorTexture, baseColorSampler, input.uv) * material.baseColor;\n  let N = normalize(input.worldNormal);\n  let V = normalize(-input.worldPosition);\n  let L = normalize(-light.direction);\n  let H = normalize(V + L);\n  \n  let F0 = mix(vec3<f32>(0.04), baseColor.rgb, material.metallic);\n  let F = fresnelSchlick(max(dot(H, V), 0.0), F0);\n  let NDF = distributionGGX(N, H, material.roughness);\n  let G = geometrySmith(N, V, L, material.roughness);\n  \n  let numerator = NDF * G * F;\n  let denominator = 4.0 * max(dot(N, V), 0.0) * max(dot(N, L), 0.0) + 0.0001;\n  let specular = numerator / denominator;\n  \n  let kS = F;\n  let kD = (vec3<f32>(1.0) - kS) * (1.0 - material.metallic);\n  let NdotL = max(dot(N, L), 0.0);\n  \n  let Lo = (kD * baseColor.rgb / PI + specular) * light.color * light.intensity * NdotL;\n  let ambient = vec3<f32>(0.03) * baseColor.rgb;\n  var color = ambient + Lo + material.emissive;\n  \n  // Tone mapping (Reinhard)\n  color = color / (color + vec3<f32>(1.0));\n  // Gamma correction\n  color = pow(color, vec3<f32>(1.0 / 2.2));\n  \n  return vec4<f32>(color, baseColor.a);\n}\n";
+/** Unlit vertex shader */
+declare const UNLIT_VERTEX_SHADER = "\nstruct VertexInput {\n  @location(0) position: vec3<f32>,\n  @location(1) uv: vec2<f32>,\n  @location(2) color: vec4<f32>,\n}\n\nstruct VertexOutput {\n  @builtin(position) position: vec4<f32>,\n  @location(0) uv: vec2<f32>,\n  @location(1) color: vec4<f32>,\n}\n\nstruct Uniforms {\n  mvpMatrix: mat4x4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: Uniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n  var output: VertexOutput;\n  output.position = uniforms.mvpMatrix * vec4<f32>(input.position, 1.0);\n  output.uv = input.uv;\n  output.color = input.color;\n  return output;\n}\n";
+/** Unlit fragment shader */
+declare const UNLIT_FRAGMENT_SHADER = "\nstruct FragmentInput {\n  @location(0) uv: vec2<f32>,\n  @location(1) color: vec4<f32>,\n}\n\n@group(0) @binding(1) var colorTexture: texture_2d<f32>;\n@group(0) @binding(2) var colorSampler: sampler;\n\n@fragment\nfn main(input: FragmentInput) -> @location(0) vec4<f32> {\n  let texColor = textureSample(colorTexture, colorSampler, input.uv);\n  return texColor * input.color;\n}\n";
+
+/**
+ * WebGPU Renderer
+ *
+ * High-performance WebGPU-based renderer for HoloScript
+ */
+
+/**
+ * WebGPU-based renderer for HoloScript scenes
+ */
+declare class WebGPURenderer {
+    private context;
+    private pipelines;
+    private shaderModules;
+    private bindGroupLayouts;
+    private pipelineLayouts;
+    private depthTexture;
+    private msaaTexture;
+    private options;
+    private xrSession;
+    private xrBinding;
+    private xrProjectionLayer;
+    private xrFramebuffer;
+    private stats;
+    private lastFrameTime;
+    private frameTimeHistory;
+    private cameraUniformBuffer;
+    private sceneUniformBuffer;
+    private defaultSampler;
+    private defaultTexture;
+    constructor(options?: Partial<IWebGPUInitOptions>);
+    /**
+     * Check if WebGPU is supported
+     */
+    static isSupported(): boolean;
+    /**
+     * Initialize the WebGPU renderer
+     */
+    initialize(options?: Partial<IWebGPUInitOptions>): Promise<IWebGPUContext>;
+    /**
+     * Resolve canvas from element or selector
+     */
+    private resolveCanvas;
+    /**
+     * Get device capabilities
+     */
+    private getDeviceCapabilities;
+    /**
+     * Create default resources
+     */
+    private createDefaultResources;
+    /**
+     * Create depth buffer
+     */
+    private createDepthBuffer;
+    /**
+     * Handle canvas resize
+     */
+    resize(width: number, height: number): void;
+    /**
+     * Create a shader module
+     */
+    createShaderModule(descriptor: IShaderModule): GPUShaderModule;
+    /**
+     * Create a render pipeline
+     */
+    createRenderPipeline(id: string, descriptor: IRenderPipelineDescriptor): GPURenderPipeline;
+    /**
+     * Create a GPU buffer
+     */
+    createBuffer(descriptor: IBufferDescriptor): GPUBuffer;
+    /**
+     * Create a vertex buffer from typed array
+     */
+    createVertexBuffer(data: Float32Array | Uint16Array | Uint32Array, slot?: number): IVertexBuffer;
+    /**
+     * Create an index buffer
+     */
+    createIndexBuffer(data: Uint16Array | Uint32Array): IIndexBuffer;
+    /**
+     * Create a texture
+     */
+    createTexture(descriptor: ITextureDescriptor): GPUTexture;
+    /**
+     * Create a GPU texture from image data
+     */
+    createTextureFromImage(source: ImageBitmap | HTMLCanvasElement | OffscreenCanvas, options?: Partial<ITextureDescriptor>): Promise<IGPUTexture>;
+    private mipmapPipeline;
+    private mipmapSampler;
+    /**
+     * Get or create the mipmap blit pipeline.
+     * Uses a fullscreen-quad vertex shader (no vertex buffers) and a
+     * bilinear-sampling fragment shader to downsample each mip level.
+     */
+    private getOrCreateMipmapPipeline;
+    /**
+     * Generate mipmaps for a texture using a blit-style render pass.
+     *
+     * For each mip level (1..mipLevelCount-1) we render a fullscreen triangle
+     * that samples the previous level with bilinear filtering, writing the
+     * downsampled result into the current level.
+     *
+     * Requires the texture to have been created with RENDER_ATTACHMENT usage.
+     */
+    private generateMipmaps;
+    /**
+     * Create a sampler
+     */
+    createSampler(descriptor?: ISamplerDescriptor): GPUSampler;
+    /**
+     * Create a bind group
+     */
+    createBindGroup(layout: GPUBindGroupLayout, entries: GPUBindGroupEntry[], label?: string): GPUBindGroup;
+    /**
+     * Update camera uniforms
+     */
+    updateCameraUniforms(uniforms: ICameraUniforms): void;
+    /**
+     * Update scene uniforms
+     */
+    updateSceneUniforms(uniforms: ISceneUniforms): void;
+    /**
+     * Begin a render frame
+     */
+    beginFrame(): GPUCommandEncoder | null;
+    /**
+     * Begin a render pass
+     */
+    beginRenderPass(encoder: GPUCommandEncoder, clearColor?: GPUColor): GPURenderPassEncoder;
+    /**
+     * Submit draw calls
+     */
+    submitDrawCalls(pass: GPURenderPassEncoder, drawCalls: IDrawCall[]): void;
+    /**
+     * Sort draw calls for optimal rendering
+     */
+    private sortDrawCalls;
+    /**
+     * End render pass
+     */
+    endRenderPass(pass: GPURenderPassEncoder): void;
+    /**
+     * End frame and submit
+     */
+    endFrame(encoder: GPUCommandEncoder): void;
+    /**
+     * Get render statistics
+     */
+    getStats(): IRendererStats;
+    /**
+     * Get the WebGPU context
+     */
+    getContext(): IWebGPUContext | null;
+    /**
+     * Get the GPU device
+     */
+    getDevice(): GPUDevice | null;
+    /**
+     * Get the canvas
+     */
+    getCanvas(): HTMLCanvasElement | null;
+    /**
+     * Get the default texture
+     */
+    getDefaultTexture(): IGPUTexture | null;
+    /**
+     * Get the default sampler
+     */
+    getDefaultSampler(): GPUSampler | null;
+    /**
+     * Create empty frame stats
+     */
+    private createEmptyFrameStats;
+    /**
+     * Set the active XR session and bindings
+     */
+    setXRSession(session: XRSession | null, binding: any | null, layer: any | null): void;
+    /**
+     * Render a WebXR Frame
+     */
+    renderXR(frame: XRFrame): void;
+    private multiplyMatrices;
+    /**
+     * Destroy the renderer and release resources
+     */
+    destroy(): void;
+    /**
+     * Render an XR frame
+     */
+    renderXRFrame(frame: XRFrame, refSpace: XRReferenceSpace, renderCallback: (pass: GPURenderPassEncoder, view: XRView) => void): void;
+}
+
+/**
+ * PhysicsDebugDrawer.ts
+ *
+ * Renders wireframes for physics bodies using WebGPURenderer.
+ * Essential for verifying collision shapes and interaction logic.
+ */
+
+declare class PhysicsDebugDrawer {
+    private world;
+    private renderer;
+    private enabled;
+    private debugMeshes;
+    constructor(world: IPhysicsWorld, renderer: WebGPURenderer);
+    setEnabled(enabled: boolean): void;
+    update(): void;
+    private createDebugMesh;
+    clear(): void;
+}
+
+/**
+ * PostProcessTypes.ts
+ *
+ * Type definitions for HoloScript post-processing system.
+ * Supports WebGPU-based effects pipeline with HDR and LDR processing.
+ *
+ * @module render/postprocess
+ */
+/**
+ * Supported post-process effect types
+ */
+type PostProcessEffectType = 'bloom' | 'tonemap' | 'dof' | 'motionBlur' | 'ssao' | 'fxaa' | 'sharpen' | 'vignette' | 'colorGrade' | 'filmGrain' | 'chromaticAberration' | 'fog' | 'caustics' | 'ssr' | 'ssgi' | 'custom';
+/**
+ * Tone mapping operators
+ */
+type ToneMapOperator = 'none' | 'reinhard' | 'reinhardLum' | 'aces' | 'acesApprox' | 'filmic' | 'uncharted2' | 'uchimura' | 'lottes' | 'khronos';
+/**
+ * Blend modes for effect compositing
+ */
+type BlendMode = 'normal' | 'add' | 'multiply' | 'screen' | 'overlay' | 'softLight';
+/**
+ * Base effect parameters interface
+ */
+interface IEffectParams {
+    enabled: boolean;
+    intensity: number;
+    blendMode?: BlendMode;
+}
+/**
+ * Bloom effect parameters
+ */
+interface IBloomParams extends IEffectParams {
+    threshold: number;
+    softThreshold: number;
+    radius: number;
+    iterations: number;
+    anamorphic: number;
+    highQuality: boolean;
+}
+/**
+ * Tone mapping parameters
+ */
+interface IToneMapParams extends IEffectParams {
+    operator: ToneMapOperator;
+    exposure: number;
+    gamma: number;
+    whitePoint: number;
+    contrast: number;
+    saturation: number;
+}
+/**
+ * Depth of Field parameters
+ */
+interface IDepthOfFieldParams extends IEffectParams {
+    focusDistance: number;
+    focalLength: number;
+    aperture: number;
+    maxBlur: number;
+    bokehShape: 'circle' | 'hexagon' | 'octagon';
+    bokehQuality: 'low' | 'medium' | 'high';
+    nearBlur: boolean;
+}
+/**
+ * Motion blur parameters
+ */
+interface IMotionBlurParams extends IEffectParams {
+    samples: number;
+    velocityScale: number;
+    maxVelocity: number;
+}
+/**
+ * SSAO parameters
+ */
+interface ISSAOParams extends IEffectParams {
+    radius: number;
+    bias: number;
+    samples: number;
+    power: number;
+    falloff: number;
+    /** 'hemisphere' = random hemisphere, 'hbao' = horizon-based 8-dir × 4-step */
+    mode?: 'hemisphere' | 'hbao';
+    /** Output bent normal direction (least-occluded direction) */
+    bentNormals?: boolean;
+    /** 5×5 cross-bilateral spatial denoise weighted by depth + normal */
+    spatialDenoise?: boolean;
+}
+/**
+ * Anti-aliasing (FXAA) parameters
+ */
+interface IFXAAParams extends IEffectParams {
+    quality: 'low' | 'medium' | 'high' | 'ultra';
+    edgeThreshold: number;
+    edgeThresholdMin: number;
+}
+/**
+ * Sharpen parameters
+ */
+interface ISharpenParams extends IEffectParams {
+    amount: number;
+    threshold: number;
+}
+/**
+ * Vignette parameters
+ */
+interface IVignetteParams extends IEffectParams {
+    roundness: number;
+    smoothness: number;
+    color: [number, number, number];
+}
+/**
+ * Color grading parameters
+ */
+interface IColorGradeParams extends IEffectParams {
+    shadows: [number, number, number];
+    midtones: [number, number, number];
+    highlights: [number, number, number];
+    shadowsOffset: number;
+    highlightsOffset: number;
+    hueShift: number;
+    temperature: number;
+    tint: number;
+    lutTexture?: string;
+    lutIntensity: number;
+}
+/**
+ * Film grain parameters
+ */
+interface IFilmGrainParams extends IEffectParams {
+    size: number;
+    luminanceContribution: number;
+    animated: boolean;
+}
+/**
+ * Chromatic aberration parameters
+ */
+interface IChromaticAberrationParams extends IEffectParams {
+    redOffset: [number, number];
+    greenOffset: [number, number];
+    blueOffset: [number, number];
+    radial: boolean;
+}
+/**
+ * Fog parameters
+ */
+interface IFogParams extends IEffectParams {
+    color: [number, number, number];
+    density: number;
+    start: number;
+    end: number;
+    height: number;
+    heightFalloff: number;
+    mode: 'linear' | 'exponential' | 'exponentialSquared';
+}
+/**
+ * Caustics overlay parameters
+ */
+interface ICausticsParams extends IEffectParams {
+    scale: number;
+    speed: number;
+    color: [number, number, number];
+    depthFade: number;
+    waterLevel: number;
+    /** RGB IoR separation for prismatic chromatic dispersion */
+    dispersion?: number;
+    /** Turbulence-driven foam overlay intensity */
+    foamIntensity?: number;
+    /** Darken terrain where caustics are absent */
+    shadowStrength?: number;
+}
+/**
+ * Screen-Space Reflections (SSR) parameters
+ */
+interface ISSRParams extends IEffectParams {
+    maxSteps: number;
+    stepSize: number;
+    thickness: number;
+    roughnessFade: number;
+    edgeFade: number;
+    /** Golden-angle blur at hit point scaled by roughness (0 = sharp) */
+    roughnessBlur?: number;
+    /** Schlick Fresnel weighting strength (0 = uniform, 1 = physically correct) */
+    fresnelStrength?: number;
+}
+/**
+ * Screen-Space Global Illumination (SSGI) parameters
+ */
+interface ISSGIParams extends IEffectParams {
+    radius: number;
+    samples: number;
+    bounceIntensity: number;
+    falloff: number;
+    /** Blend with previous frame using motion vectors (0 = off, 1 = full) */
+    temporalBlend?: number;
+    /** 3×3 edge-stopping cross-bilateral spatial denoise */
+    spatialDenoise?: boolean;
+    /** Multi-bounce approximation multiplier */
+    multiBounce?: number;
+}
+/**
+ * Custom shader effect parameters
+ */
+interface ICustomEffectParams extends IEffectParams {
+    shader: string;
+    uniforms: Record<string, number | number[] | boolean>;
+}
+/**
+ * Union type of all effect parameters
+ */
+type EffectParams = IBloomParams | IToneMapParams | IDepthOfFieldParams | IMotionBlurParams | ISSAOParams | IFXAAParams | ISharpenParams | IVignetteParams | IColorGradeParams | IFilmGrainParams | IChromaticAberrationParams | IFogParams | ICausticsParams | ISSRParams | ISSGIParams | ICustomEffectParams;
+/**
+ * Effect configuration for pipeline
+ */
+interface IEffectConfig {
+    type: PostProcessEffectType;
+    name?: string;
+    params: EffectParams;
+    order?: number;
+}
+/**
+ * Render target configuration
+ */
+interface IRenderTargetConfig {
+    width: number;
+    height: number;
+    format: GPUTextureFormat;
+    mipLevelCount?: number;
+    sampleCount?: number;
+    label?: string;
+}
+/**
+ * Post-process pipeline configuration
+ */
+interface IPostProcessPipelineConfig {
+    hdrEnabled: boolean;
+    hdrFormat: GPUTextureFormat;
+    ldrFormat: GPUTextureFormat;
+    msaaSamples: 1 | 4;
+    effects: IEffectConfig[];
+    autoResize: boolean;
+}
+/**
+ * Runtime render target
+ */
+interface IRenderTarget {
+    id: string;
+    texture: GPUTexture;
+    view: GPUTextureView;
+    config: IRenderTargetConfig;
+}
+/**
+ * Frame data passed to effects
+ */
+interface IFrameData {
+    time: number;
+    deltaTime: number;
+    frameCount: number;
+    resolution: [number, number];
+    nearPlane: number;
+    farPlane: number;
+    cameraPosition?: [number, number, number];
+    viewMatrix?: Float32Array;
+    projectionMatrix?: Float32Array;
+    prevViewMatrix?: Float32Array;
+    jitter?: [number, number];
+}
+/**
+ * Effect render context
+ */
+interface IEffectRenderContext {
+    device: GPUDevice;
+    commandEncoder: GPUCommandEncoder;
+    frameData: IFrameData;
+    input: IRenderTarget;
+    output: IRenderTarget;
+    depth?: IRenderTarget;
+    velocity?: IRenderTarget;
+}
+/**
+ * Default parameter values for each effect type
+ */
+declare const DEFAULT_PARAMS: Record<PostProcessEffectType, EffectParams>;
+/**
+ * Get default parameters for effect type
+ */
+declare function getDefaultParams<T extends EffectParams>(type: PostProcessEffectType): T;
+/**
+ * Merge effect parameters with defaults
+ */
+declare function mergeParams<T extends EffectParams>(type: PostProcessEffectType, partial: Partial<T>): T;
+/**
+ * Validate effect parameters
+ */
+declare function validateParams(type: PostProcessEffectType, params: EffectParams): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Size in bytes for uniform buffers
+ */
+declare const UNIFORM_SIZES: Record<PostProcessEffectType, number>;
+/**
+ * FXAA quality levels
+ */
+type FXAAQuality = 'low' | 'medium' | 'high' | 'ultra';
+/**
+ * Alias for IEffectParams (API compatibility)
+ */
+type IBaseEffectParams = IEffectParams;
+/**
+ * Alias for IDepthOfFieldParams (API compatibility)
+ */
+type IDOFParams = IDepthOfFieldParams;
+
+/**
+ * PostProcessEffect.ts
+ *
+ * Base class for post-processing effects and built-in effect implementations.
+ * All effects compile to WebGPU compute/render pipelines.
+ *
+ * @module render/postprocess
+ */
+
+/**
+ * Abstract base class for all post-processing effects
+ */
+declare abstract class PostProcessEffect {
+    readonly type: PostProcessEffectType;
+    readonly name: string;
+    protected params: EffectParams;
+    protected pipeline: GPURenderPipeline | null;
+    protected uniformBuffer: GPUBuffer | null;
+    protected bindGroup: GPUBindGroup | null;
+    protected sampler: GPUSampler | null;
+    protected _initialized: boolean;
+    constructor(type: PostProcessEffectType, name?: string, params?: Partial<EffectParams>);
+    /**
+     * Check if effect is enabled
+     */
+    get enabled(): boolean;
+    /**
+     * Enable/disable effect
+     */
+    set enabled(value: boolean);
+    /**
+     * Get effect intensity
+     */
+    get intensity(): number;
+    /**
+     * Set effect intensity
+     */
+    set intensity(value: number);
+    /**
+     * Get current parameters
+     */
+    getParams<T extends EffectParams>(): T;
+    /**
+     * Update parameters
+     */
+    setParams(params: Partial<EffectParams>): void;
+    /**
+     * Check if effect is initialized
+     */
+    get initialized(): boolean;
+    /**
+     * Initialize GPU resources
+     */
+    initialize(device: GPUDevice): Promise<void>;
+    /**
+     * Create render/compute pipeline - override in subclasses
+     */
+    protected abstract createPipeline(device: GPUDevice): Promise<void>;
+    /**
+     * Update uniform buffer with current parameters
+     */
+    protected abstract updateUniforms(device: GPUDevice, frameData: {
+        time: number;
+        deltaTime: number;
+    }): void;
+    /**
+     * Render the effect
+     */
+    abstract render(context: IEffectRenderContext): void;
+    /**
+     * Dispose GPU resources
+     */
+    dispose(): void;
+}
+/**
+ * Bloom effect - adds glow to bright areas
+ */
+declare class BloomEffect extends PostProcessEffect {
+    private downsamplePipelines;
+    private upsamplePipelines;
+    private mipViews;
+    private mipTexture;
+    constructor(params?: Partial<IBloomParams>);
+    protected createPipeline(device: GPUDevice): Promise<void>;
+    protected updateUniforms(device: GPUDevice, frameData: {
+        time: number;
+        deltaTime: number;
+    }): void;
+    render(context: IEffectRenderContext): void;
+    dispose(): void;
+}
+/**
+ * Tone mapping effect - converts HDR to LDR
+ */
+declare class ToneMapEffect extends PostProcessEffect {
+    constructor(params?: Partial<IToneMapParams>);
+    protected createPipeline(device: GPUDevice): Promise<void>;
+    protected updateUniforms(device: GPUDevice, _frameData: {
+        time: number;
+        deltaTime: number;
+    }): void;
+    render(context: IEffectRenderContext): void;
+}
+/**
+ * FXAA anti-aliasing effect
+ */
+declare class FXAAEffect extends PostProcessEffect {
+    constructor(params?: Partial<IFXAAParams>);
+    protected createPipeline(device: GPUDevice): Promise<void>;
+    protected updateUniforms(device: GPUDevice, _frameData: {
+        time: number;
+        deltaTime: number;
+    }): void;
+    render(context: IEffectRenderContext): void;
+}
+/**
+ * Vignette effect - darkens edges of screen
+ */
+declare class VignetteEffect extends PostProcessEffect {
+    constructor(params?: Partial<IVignetteParams>);
+    protected createPipeline(device: GPUDevice): Promise<void>;
+    protected updateUniforms(device: GPUDevice, _frameData: {
+        time: number;
+        deltaTime: number;
+    }): void;
+    render(context: IEffectRenderContext): void;
+}
+/**
+ * Film grain effect
+ */
+declare class FilmGrainEffect extends PostProcessEffect {
+    constructor(params?: Partial<IFilmGrainParams>);
+    protected createPipeline(device: GPUDevice): Promise<void>;
+    protected updateUniforms(device: GPUDevice, frameData: {
+        time: number;
+        deltaTime: number;
+    }): void;
+    render(context: IEffectRenderContext): void;
+}
+/**
+ * Sharpen effect
+ */
+declare class SharpenEffect extends PostProcessEffect {
+    constructor(params?: Partial<ISharpenParams>);
+    protected createPipeline(device: GPUDevice): Promise<void>;
+    protected updateUniforms(device: GPUDevice, _frameData: {
+        time: number;
+        deltaTime: number;
+    }): void;
+    render(context: IEffectRenderContext): void;
+}
+/**
+ * Chromatic aberration effect
+ */
+declare class ChromaticAberrationEffect extends PostProcessEffect {
+    constructor(params?: Partial<IChromaticAberrationParams>);
+    protected createPipeline(device: GPUDevice): Promise<void>;
+    protected updateUniforms(device: GPUDevice, _frameData: {
+        time: number;
+        deltaTime: number;
+    }): void;
+    render(context: IEffectRenderContext): void;
+}
+/**
+ * Caustics overlay effect — underwater refracted light patterns
+ */
+declare class CausticsEffect extends PostProcessEffect {
+    constructor(params?: Partial<ICausticsParams>);
+    protected createPipeline(device: GPUDevice): Promise<void>;
+    protected updateUniforms(device: GPUDevice, frameData: {
+        time: number;
+        deltaTime: number;
+    }): void;
+    render(context: IEffectRenderContext): void;
+}
+/**
+ * Screen-Space Reflections (SSR) effect
+ */
+declare class SSREffect extends PostProcessEffect {
+    constructor(params?: Partial<ISSRParams>);
+    protected createPipeline(device: GPUDevice): Promise<void>;
+    protected updateUniforms(device: GPUDevice, _frameData: {
+        time: number;
+        deltaTime: number;
+    }): void;
+    render(context: IEffectRenderContext): void;
+}
+/**
+ * Screen-Space Ambient Occlusion (SSAO) effect
+ */
+declare class SSAOEffect extends PostProcessEffect {
+    constructor(params?: Partial<ISSAOParams>);
+    protected createPipeline(device: GPUDevice): Promise<void>;
+    protected updateUniforms(device: GPUDevice, _frameData: {
+        time: number;
+        deltaTime: number;
+    }): void;
+    render(context: IEffectRenderContext): void;
+}
+/**
+ * Screen-Space Global Illumination (SSGI) effect
+ */
+declare class SSGIEffect extends PostProcessEffect {
+    constructor(params?: Partial<ISSGIParams>);
+    protected createPipeline(device: GPUDevice): Promise<void>;
+    protected updateUniforms(device: GPUDevice, _frameData: {
+        time: number;
+        deltaTime: number;
+    }): void;
+    render(context: IEffectRenderContext): void;
+}
+/**
+ * Factory function to create effects by type
+ */
+declare function createEffect(type: PostProcessEffectType, params?: Partial<EffectParams>): PostProcessEffect;
+
+/**
+ * PostProcessShaders.ts
+ *
+ * WGSL shader code for all post-processing effects.
+ * Includes fullscreen triangle vertex shader and per-effect fragment shaders.
+ *
+ * @module render/postprocess
+ */
+/**
+ * Fullscreen triangle vertex shader
+ * Generates fullscreen coverage with a single triangle
+ */
+declare const FULLSCREEN_VERTEX_SHADER = "\nstruct VertexOutput {\n  @builtin(position) position: vec4f,\n  @location(0) uv: vec2f,\n}\n\n@vertex\nfn vs_main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {\n  // Generate fullscreen triangle\n  var positions = array<vec2f, 3>(\n    vec2f(-1.0, -1.0),\n    vec2f(3.0, -1.0),\n    vec2f(-1.0, 3.0)\n  );\n\n  var uvs = array<vec2f, 3>(\n    vec2f(0.0, 1.0),\n    vec2f(2.0, 1.0),\n    vec2f(0.0, -1.0)\n  );\n\n  var output: VertexOutput;\n  output.position = vec4f(positions[vertexIndex], 0.0, 1.0);\n  output.uv = uvs[vertexIndex];\n  return output;\n}\n";
+/**
+ * Common shader utilities
+ */
+declare const SHADER_UTILS = "\n// Luminance calculation (Rec. 709)\nfn luminance(color: vec3f) -> f32 {\n  return dot(color, vec3f(0.2126, 0.7152, 0.0722));\n}\n\n// sRGB to linear conversion\nfn srgbToLinear(color: vec3f) -> vec3f {\n  return pow(color, vec3f(2.2));\n}\n\n// Linear to sRGB conversion\nfn linearToSrgb(color: vec3f) -> vec3f {\n  return pow(color, vec3f(1.0 / 2.2));\n}\n\n// Hash function for noise\nfn hash(p: vec2f) -> f32 {\n  let k = vec2f(0.3183099, 0.3678794);\n  let x = p * k + k.yx;\n  return fract(16.0 * k.x * fract(x.x * x.y * (x.x + x.y)));\n}\n\n// Simple 2D noise\nfn noise2D(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash(i + vec2f(0.0, 0.0)), hash(i + vec2f(1.0, 0.0)), u.x),\n    mix(hash(i + vec2f(0.0, 1.0)), hash(i + vec2f(1.0, 1.0)), u.x),\n    u.y\n  );\n}\n";
+/**
+ * Bloom effect shader
+ */
+declare const BLOOM_SHADER = "\n\n// Luminance calculation (Rec. 709)\nfn luminance(color: vec3f) -> f32 {\n  return dot(color, vec3f(0.2126, 0.7152, 0.0722));\n}\n\n// sRGB to linear conversion\nfn srgbToLinear(color: vec3f) -> vec3f {\n  return pow(color, vec3f(2.2));\n}\n\n// Linear to sRGB conversion\nfn linearToSrgb(color: vec3f) -> vec3f {\n  return pow(color, vec3f(1.0 / 2.2));\n}\n\n// Hash function for noise\nfn hash(p: vec2f) -> f32 {\n  let k = vec2f(0.3183099, 0.3678794);\n  let x = p * k + k.yx;\n  return fract(16.0 * k.x * fract(x.x * x.y * (x.x + x.y)));\n}\n\n// Simple 2D noise\nfn noise2D(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash(i + vec2f(0.0, 0.0)), hash(i + vec2f(1.0, 0.0)), u.x),\n    mix(hash(i + vec2f(0.0, 1.0)), hash(i + vec2f(1.0, 1.0)), u.x),\n    u.y\n  );\n}\n\n\nstruct BloomUniforms {\n  intensity: f32,\n  threshold: f32,\n  softThreshold: f32,\n  radius: f32,\n  iterations: f32,\n  anamorphic: f32,\n  highQuality: f32,\n  padding: f32,\n  time: f32,\n  deltaTime: f32,\n  padding2: vec2f,\n}\n\n@group(0) @binding(0) var texSampler: sampler;\n@group(0) @binding(1) var inputTexture: texture_2d<f32>;\n@group(0) @binding(2) var<uniform> uniforms: BloomUniforms;\n\n// Threshold with soft knee\nfn softThreshold(color: vec3f) -> vec3f {\n  let brightness = max(max(color.r, color.g), color.b);\n  var soft = brightness - uniforms.threshold + uniforms.softThreshold;\n  soft = clamp(soft, 0.0, 2.0 * uniforms.softThreshold);\n  soft = soft * soft / (4.0 * uniforms.softThreshold + 0.00001);\n  var contribution = max(soft, brightness - uniforms.threshold);\n  contribution /= max(brightness, 0.00001);\n  return color * contribution;\n}\n\n// 9-tap gaussian blur\nfn blur9(uv: vec2f, direction: vec2f) -> vec3f {\n  let texSize = vec2f(textureDimensions(inputTexture));\n  let offset = direction / texSize;\n\n  var color = textureSample(inputTexture, texSampler, uv).rgb * 0.2270270270;\n  color += textureSample(inputTexture, texSampler, uv + offset * 1.3846153846).rgb * 0.3162162162;\n  color += textureSample(inputTexture, texSampler, uv - offset * 1.3846153846).rgb * 0.3162162162;\n  color += textureSample(inputTexture, texSampler, uv + offset * 3.2307692308).rgb * 0.0702702703;\n  color += textureSample(inputTexture, texSampler, uv - offset * 3.2307692308).rgb * 0.0702702703;\n\n  return color;\n}\n\n@fragment\nfn fs_bloom(input: VertexOutput) -> @location(0) vec4f {\n  let color = textureSample(inputTexture, texSampler, input.uv).rgb;\n\n  // Extract bright pixels with soft threshold\n  var bloom = softThreshold(color);\n\n  // Simple blur approximation (in production, use multi-pass)\n  let texSize = vec2f(textureDimensions(inputTexture));\n  let radius = uniforms.radius / texSize;\n\n  var blurred = bloom;\n  for (var i = 0u; i < 4u; i++) {\n    let angle = f32(i) * 1.5707963268;\n    let offset = vec2f(cos(angle), sin(angle)) * radius;\n    blurred += textureSample(inputTexture, texSampler, input.uv + offset).rgb;\n    blurred += textureSample(inputTexture, texSampler, input.uv - offset).rgb;\n  }\n  blurred /= 9.0;\n\n  // Composite bloom\n  let result = color + softThreshold(blurred) * uniforms.intensity;\n\n  return vec4f(result, 1.0);\n}\n";
+/**
+ * Tone mapping shader with multiple operators
+ */
+declare const TONEMAP_SHADER = "\n\n// Luminance calculation (Rec. 709)\nfn luminance(color: vec3f) -> f32 {\n  return dot(color, vec3f(0.2126, 0.7152, 0.0722));\n}\n\n// sRGB to linear conversion\nfn srgbToLinear(color: vec3f) -> vec3f {\n  return pow(color, vec3f(2.2));\n}\n\n// Linear to sRGB conversion\nfn linearToSrgb(color: vec3f) -> vec3f {\n  return pow(color, vec3f(1.0 / 2.2));\n}\n\n// Hash function for noise\nfn hash(p: vec2f) -> f32 {\n  let k = vec2f(0.3183099, 0.3678794);\n  let x = p * k + k.yx;\n  return fract(16.0 * k.x * fract(x.x * x.y * (x.x + x.y)));\n}\n\n// Simple 2D noise\nfn noise2D(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash(i + vec2f(0.0, 0.0)), hash(i + vec2f(1.0, 0.0)), u.x),\n    mix(hash(i + vec2f(0.0, 1.0)), hash(i + vec2f(1.0, 1.0)), u.x),\n    u.y\n  );\n}\n\n\nstruct ToneMapUniforms {\n  operator: f32,\n  exposure: f32,\n  gamma: f32,\n  whitePoint: f32,\n  contrast: f32,\n  saturation: f32,\n  intensity: f32,\n  padding: f32,\n}\n\n@group(0) @binding(0) var texSampler: sampler;\n@group(0) @binding(1) var inputTexture: texture_2d<f32>;\n@group(0) @binding(2) var<uniform> uniforms: ToneMapUniforms;\n\n// Reinhard tone mapping\nfn tonemapReinhard(x: vec3f) -> vec3f {\n  return x / (x + vec3f(1.0));\n}\n\n// Reinhard with luminance-based mapping\nfn tonemapReinhardLum(x: vec3f) -> vec3f {\n  let l = luminance(x);\n  let nl = l / (l + 1.0);\n  return x * (nl / l);\n}\n\n// ACES filmic tone mapping\nfn tonemapACES(x: vec3f) -> vec3f {\n  let a = 2.51;\n  let b = 0.03;\n  let c = 2.43;\n  let d = 0.59;\n  let e = 0.14;\n  return clamp((x * (a * x + vec3f(b))) / (x * (c * x + vec3f(d)) + vec3f(e)), vec3f(0.0), vec3f(1.0));\n}\n\n// ACES approximation (cheaper)\nfn tonemapACESApprox(x: vec3f) -> vec3f {\n  let v = x * 0.6;\n  let a = v * (v * 2.51 + 0.03);\n  let b = v * (v * 2.43 + 0.59) + 0.14;\n  return clamp(a / b, vec3f(0.0), vec3f(1.0));\n}\n\n// Uncharted 2 filmic\nfn uncharted2Partial(x: vec3f) -> vec3f {\n  let A = 0.15;\n  let B = 0.50;\n  let C = 0.10;\n  let D = 0.20;\n  let E = 0.02;\n  let F = 0.30;\n  return ((x * (A * x + C * B) + D * E) / (x * (A * x + B) + D * F)) - E / F;\n}\n\nfn tonemapUncharted2(x: vec3f) -> vec3f {\n  let white = 11.2;\n  let curr = uncharted2Partial(x * 2.0);\n  let whiteScale = vec3f(1.0) / uncharted2Partial(vec3f(white));\n  return curr * whiteScale;\n}\n\n// Lottes (AMD)\nfn tonemapLottes(x: vec3f) -> vec3f {\n  let a = vec3f(1.6);\n  let d = vec3f(0.977);\n  let hdrMax = vec3f(8.0);\n  let midIn = vec3f(0.18);\n  let midOut = vec3f(0.267);\n\n  let b = (-pow(midIn, a) + pow(hdrMax, a) * midOut) / ((pow(hdrMax, a * d) - pow(midIn, a * d)) * midOut);\n  let c = (pow(hdrMax, a * d) * pow(midIn, a) - pow(hdrMax, a) * pow(midIn, a * d) * midOut) /\n          ((pow(hdrMax, a * d) - pow(midIn, a * d)) * midOut);\n\n  return pow(x, a) / (pow(x, a * d) * b + c);\n}\n\n// Uchimura (GT)\nfn tonemapUchimura(x: vec3f) -> vec3f {\n  let P = 1.0;  // max brightness\n  let a = 1.0;  // contrast\n  let m = 0.22; // linear section start\n  let l = 0.4;  // linear section length\n  let c = 1.33; // black tightness\n  let b = 0.0;  // black lightness\n\n  let l0 = ((P - m) * l) / a;\n  let S0 = m + l0;\n  let S1 = m + a * l0;\n  let C2 = (a * P) / (P - S1);\n  let CP = -C2 / P;\n\n  var result: vec3f;\n  for (var i = 0u; i < 3u; i++) {\n    let v = x[i];\n    var w: f32;\n    if (v < m) {\n      w = v;\n    } else if (v < S0) {\n      w = m + a * (v - m);\n    } else {\n      w = P - (P - S1) * exp(CP * (v - S0));\n    }\n    result[i] = w;\n  }\n  return result;\n}\n\n// Khronos PBR neutral\nfn tonemapKhronosPBR(color: vec3f) -> vec3f {\n  let startCompression = 0.8 - 0.04;\n  let desaturation = 0.15;\n\n  var x = min(color, vec3f(1.0));\n  let peak = max(max(color.r, color.g), color.b);\n\n  if (peak < startCompression) {\n    return x;\n  }\n\n  let d = 1.0 - startCompression;\n  let newPeak = 1.0 - d * d / (peak + d - startCompression);\n  x *= newPeak / peak;\n\n  let g = 1.0 - 1.0 / (desaturation * (peak - newPeak) + 1.0);\n  return mix(x, vec3f(newPeak), g);\n}\n\n@fragment\nfn fs_tonemap(input: VertexOutput) -> @location(0) vec4f {\n  var color = textureSample(inputTexture, texSampler, input.uv).rgb;\n\n  // Apply exposure\n  color *= uniforms.exposure;\n\n  // Apply contrast (around mid-gray)\n  let midGray = 0.18;\n  color = midGray * pow(color / midGray, vec3f(uniforms.contrast));\n\n  // Apply saturation\n  let lum = luminance(color);\n  color = mix(vec3f(lum), color, uniforms.saturation);\n\n  // Apply tone mapping\n  let op = u32(uniforms.operator);\n  var mapped: vec3f;\n  switch (op) {\n    case 0u: { mapped = clamp(color, vec3f(0.0), vec3f(1.0)); } // None\n    case 1u: { mapped = tonemapReinhard(color); }\n    case 2u: { mapped = tonemapReinhardLum(color); }\n    case 3u: { mapped = tonemapACES(color); }\n    case 4u: { mapped = tonemapACESApprox(color); }\n    case 5u: { mapped = tonemapACES(color); } // Filmic = ACES\n    case 6u: { mapped = tonemapUncharted2(color); }\n    case 7u: { mapped = tonemapUchimura(color); }\n    case 8u: { mapped = tonemapLottes(color); }\n    case 9u: { mapped = tonemapKhronosPBR(color); }\n    default: { mapped = tonemapACES(color); }\n  }\n\n  // Apply gamma correction\n  let result = pow(mapped, vec3f(1.0 / uniforms.gamma));\n\n  return vec4f(result, 1.0);\n}\n";
+/**
+ * FXAA anti-aliasing shader
+ */
+declare const FXAA_SHADER = "\n\n// Luminance calculation (Rec. 709)\nfn luminance(color: vec3f) -> f32 {\n  return dot(color, vec3f(0.2126, 0.7152, 0.0722));\n}\n\n// sRGB to linear conversion\nfn srgbToLinear(color: vec3f) -> vec3f {\n  return pow(color, vec3f(2.2));\n}\n\n// Linear to sRGB conversion\nfn linearToSrgb(color: vec3f) -> vec3f {\n  return pow(color, vec3f(1.0 / 2.2));\n}\n\n// Hash function for noise\nfn hash(p: vec2f) -> f32 {\n  let k = vec2f(0.3183099, 0.3678794);\n  let x = p * k + k.yx;\n  return fract(16.0 * k.x * fract(x.x * x.y * (x.x + x.y)));\n}\n\n// Simple 2D noise\nfn noise2D(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash(i + vec2f(0.0, 0.0)), hash(i + vec2f(1.0, 0.0)), u.x),\n    mix(hash(i + vec2f(0.0, 1.0)), hash(i + vec2f(1.0, 1.0)), u.x),\n    u.y\n  );\n}\n\n\nstruct FXAAUniforms {\n  quality: f32,\n  edgeThreshold: f32,\n  edgeThresholdMin: f32,\n  intensity: f32,\n}\n\n@group(0) @binding(0) var texSampler: sampler;\n@group(0) @binding(1) var inputTexture: texture_2d<f32>;\n@group(0) @binding(2) var<uniform> uniforms: FXAAUniforms;\n\n@fragment\nfn fs_fxaa(input: VertexOutput) -> @location(0) vec4f {\n  let texSize = vec2f(textureDimensions(inputTexture));\n  let invSize = 1.0 / texSize;\n\n  // Sample center and neighbors\n  let center = textureSample(inputTexture, texSampler, input.uv);\n  let lumC = luminance(center.rgb);\n\n  let lumN = luminance(textureSample(inputTexture, texSampler, input.uv + vec2f(0.0, -1.0) * invSize).rgb);\n  let lumS = luminance(textureSample(inputTexture, texSampler, input.uv + vec2f(0.0, 1.0) * invSize).rgb);\n  let lumE = luminance(textureSample(inputTexture, texSampler, input.uv + vec2f(1.0, 0.0) * invSize).rgb);\n  let lumW = luminance(textureSample(inputTexture, texSampler, input.uv + vec2f(-1.0, 0.0) * invSize).rgb);\n\n  let lumMin = min(lumC, min(min(lumN, lumS), min(lumE, lumW)));\n  let lumMax = max(lumC, max(max(lumN, lumS), max(lumE, lumW)));\n  let lumRange = lumMax - lumMin;\n\n  // Skip if edge contrast is too low\n  if (lumRange < max(uniforms.edgeThresholdMin, lumMax * uniforms.edgeThreshold)) {\n    return center;\n  }\n\n  // Compute edge direction\n  let lumNW = luminance(textureSample(inputTexture, texSampler, input.uv + vec2f(-1.0, -1.0) * invSize).rgb);\n  let lumNE = luminance(textureSample(inputTexture, texSampler, input.uv + vec2f(1.0, -1.0) * invSize).rgb);\n  let lumSW = luminance(textureSample(inputTexture, texSampler, input.uv + vec2f(-1.0, 1.0) * invSize).rgb);\n  let lumSE = luminance(textureSample(inputTexture, texSampler, input.uv + vec2f(1.0, 1.0) * invSize).rgb);\n\n  let edgeH = abs((lumNW + lumNE) - 2.0 * lumN) +\n              abs((lumW + lumE) - 2.0 * lumC) * 2.0 +\n              abs((lumSW + lumSE) - 2.0 * lumS);\n\n  let edgeV = abs((lumNW + lumSW) - 2.0 * lumW) +\n              abs((lumN + lumS) - 2.0 * lumC) * 2.0 +\n              abs((lumNE + lumSE) - 2.0 * lumE);\n\n  let isHorizontal = edgeH >= edgeV;\n\n  // Blend direction\n  let stepLength = select(invSize.x, invSize.y, isHorizontal);\n  var lum1: f32;\n  var lum2: f32;\n\n  if (isHorizontal) {\n    lum1 = lumN;\n    lum2 = lumS;\n  } else {\n    lum1 = lumW;\n    lum2 = lumE;\n  }\n\n  let gradient1 = abs(lum1 - lumC);\n  let gradient2 = abs(lum2 - lumC);\n\n  let is1Steeper = gradient1 >= gradient2;\n  let gradientScaled = 0.25 * max(gradient1, gradient2);\n  let lumLocalAvg = 0.5 * (select(lum2, lum1, is1Steeper) + lumC);\n\n  // Subpixel anti-aliasing\n  let subpixC = (2.0 * (lumN + lumS + lumE + lumW) + lumNW + lumNE + lumSW + lumSE) / 12.0;\n  let subpixFactor = clamp(abs(subpixC - lumC) / lumRange, 0.0, 1.0);\n  let subpix = (-(subpixFactor * subpixFactor) + 1.0) * subpixFactor;\n\n  // Apply blend\n  var finalUV = input.uv;\n  let blendFactor = max(subpix, 0.5);\n\n  if (isHorizontal) {\n    finalUV.y += select(stepLength, -stepLength, is1Steeper) * blendFactor;\n  } else {\n    finalUV.x += select(stepLength, -stepLength, is1Steeper) * blendFactor;\n  }\n\n  let result = textureSample(inputTexture, texSampler, finalUV);\n  return mix(center, result, uniforms.intensity);\n}\n";
+/**
+ * Vignette shader
+ */
+declare const VIGNETTE_SHADER = "\nstruct VignetteUniforms {\n  intensity: f32,\n  roundness: f32,\n  smoothness: f32,\n  padding: f32,\n  color: vec4f,\n}\n\n@group(0) @binding(0) var texSampler: sampler;\n@group(0) @binding(1) var inputTexture: texture_2d<f32>;\n@group(0) @binding(2) var<uniform> uniforms: VignetteUniforms;\n\n@fragment\nfn fs_vignette(input: VertexOutput) -> @location(0) vec4f {\n  let color = textureSample(inputTexture, texSampler, input.uv);\n\n  let uv = input.uv * 2.0 - 1.0;\n  let aspect = 1.0; // Could be passed via uniforms\n\n  var coords = uv;\n  coords.x *= aspect;\n\n  // Compute vignette\n  let dist = length(coords) * uniforms.roundness;\n  let vignette = 1.0 - smoothstep(1.0 - uniforms.smoothness, 1.0, dist);\n\n  // Blend with vignette color\n  let vignetteColor = mix(uniforms.color.rgb, color.rgb, vignette);\n  let result = mix(color.rgb, vignetteColor, uniforms.intensity);\n\n  return vec4f(result, color.a);\n}\n";
+/**
+ * Film grain shader
+ */
+declare const FILM_GRAIN_SHADER = "\n\n// Luminance calculation (Rec. 709)\nfn luminance(color: vec3f) -> f32 {\n  return dot(color, vec3f(0.2126, 0.7152, 0.0722));\n}\n\n// sRGB to linear conversion\nfn srgbToLinear(color: vec3f) -> vec3f {\n  return pow(color, vec3f(2.2));\n}\n\n// Linear to sRGB conversion\nfn linearToSrgb(color: vec3f) -> vec3f {\n  return pow(color, vec3f(1.0 / 2.2));\n}\n\n// Hash function for noise\nfn hash(p: vec2f) -> f32 {\n  let k = vec2f(0.3183099, 0.3678794);\n  let x = p * k + k.yx;\n  return fract(16.0 * k.x * fract(x.x * x.y * (x.x + x.y)));\n}\n\n// Simple 2D noise\nfn noise2D(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash(i + vec2f(0.0, 0.0)), hash(i + vec2f(1.0, 0.0)), u.x),\n    mix(hash(i + vec2f(0.0, 1.0)), hash(i + vec2f(1.0, 1.0)), u.x),\n    u.y\n  );\n}\n\n\nstruct FilmGrainUniforms {\n  intensity: f32,\n  size: f32,\n  luminanceContribution: f32,\n  time: f32,\n}\n\n@group(0) @binding(0) var texSampler: sampler;\n@group(0) @binding(1) var inputTexture: texture_2d<f32>;\n@group(0) @binding(2) var<uniform> uniforms: FilmGrainUniforms;\n\n@fragment\nfn fs_filmgrain(input: VertexOutput) -> @location(0) vec4f {\n  let color = textureSample(inputTexture, texSampler, input.uv);\n\n  let texSize = vec2f(textureDimensions(inputTexture));\n  let noiseUV = input.uv * texSize / uniforms.size;\n\n  // Generate animated noise\n  let grain = noise2D(noiseUV + vec2f(uniforms.time * 123.456, uniforms.time * 789.012)) * 2.0 - 1.0;\n\n  // Scale grain by luminance\n  let lum = luminance(color.rgb);\n  let grainAmount = uniforms.intensity * mix(1.0, 1.0 - lum, uniforms.luminanceContribution);\n\n  let result = color.rgb + vec3f(grain * grainAmount);\n\n  return vec4f(result, color.a);\n}\n";
+/**
+ * Sharpen shader
+ */
+declare const SHARPEN_SHADER = "\n\n// Luminance calculation (Rec. 709)\nfn luminance(color: vec3f) -> f32 {\n  return dot(color, vec3f(0.2126, 0.7152, 0.0722));\n}\n\n// sRGB to linear conversion\nfn srgbToLinear(color: vec3f) -> vec3f {\n  return pow(color, vec3f(2.2));\n}\n\n// Linear to sRGB conversion\nfn linearToSrgb(color: vec3f) -> vec3f {\n  return pow(color, vec3f(1.0 / 2.2));\n}\n\n// Hash function for noise\nfn hash(p: vec2f) -> f32 {\n  let k = vec2f(0.3183099, 0.3678794);\n  let x = p * k + k.yx;\n  return fract(16.0 * k.x * fract(x.x * x.y * (x.x + x.y)));\n}\n\n// Simple 2D noise\nfn noise2D(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash(i + vec2f(0.0, 0.0)), hash(i + vec2f(1.0, 0.0)), u.x),\n    mix(hash(i + vec2f(0.0, 1.0)), hash(i + vec2f(1.0, 1.0)), u.x),\n    u.y\n  );\n}\n\n\nstruct SharpenUniforms {\n  intensity: f32,\n  amount: f32,\n  threshold: f32,\n  padding: f32,\n}\n\n@group(0) @binding(0) var texSampler: sampler;\n@group(0) @binding(1) var inputTexture: texture_2d<f32>;\n@group(0) @binding(2) var<uniform> uniforms: SharpenUniforms;\n\n@fragment\nfn fs_sharpen(input: VertexOutput) -> @location(0) vec4f {\n  let texSize = vec2f(textureDimensions(inputTexture));\n  let texel = 1.0 / texSize;\n\n  // Sample 3x3 neighborhood\n  let center = textureSample(inputTexture, texSampler, input.uv).rgb;\n  let n = textureSample(inputTexture, texSampler, input.uv + vec2f(0.0, -texel.y)).rgb;\n  let s = textureSample(inputTexture, texSampler, input.uv + vec2f(0.0, texel.y)).rgb;\n  let e = textureSample(inputTexture, texSampler, input.uv + vec2f(texel.x, 0.0)).rgb;\n  let w = textureSample(inputTexture, texSampler, input.uv + vec2f(-texel.x, 0.0)).rgb;\n\n  // Compute unsharp mask\n  let blur = (n + s + e + w) * 0.25;\n  let diff = center - blur;\n\n  // Apply threshold\n  let sharpened = select(\n    center,\n    center + diff * uniforms.amount,\n    length(diff) > uniforms.threshold\n  );\n\n  let result = mix(center, sharpened, uniforms.intensity);\n\n  return vec4f(result, 1.0);\n}\n";
+/**
+ * Chromatic aberration shader
+ */
+declare const CHROMATIC_ABERRATION_SHADER = "\nstruct ChromaticUniforms {\n  intensity: f32,\n  radial: f32,\n  padding: vec2f,\n  redOffset: vec2f,\n  greenOffset: vec2f,\n  blueOffset: vec2f,\n  padding2: vec2f,\n}\n\n@group(0) @binding(0) var texSampler: sampler;\n@group(0) @binding(1) var inputTexture: texture_2d<f32>;\n@group(0) @binding(2) var<uniform> uniforms: ChromaticUniforms;\n\n@fragment\nfn fs_chromatic(input: VertexOutput) -> @location(0) vec4f {\n  let uv = input.uv;\n\n  var rOffset = uniforms.redOffset * uniforms.intensity;\n  var gOffset = uniforms.greenOffset * uniforms.intensity;\n  var bOffset = uniforms.blueOffset * uniforms.intensity;\n\n  // Apply radial distortion if enabled\n  if (uniforms.radial > 0.5) {\n    let center = vec2f(0.5);\n    let dir = uv - center;\n    let dist = length(dir);\n    let radialFactor = dist * dist;\n\n    rOffset *= radialFactor;\n    gOffset *= radialFactor;\n    bOffset *= radialFactor;\n  }\n\n  let r = textureSample(inputTexture, texSampler, uv + rOffset).r;\n  let g = textureSample(inputTexture, texSampler, uv + gOffset).g;\n  let b = textureSample(inputTexture, texSampler, uv + bOffset).b;\n\n  return vec4f(r, g, b, 1.0);\n}\n";
+/**
+ * Depth of Field shader
+ * Uses circle-of-confusion from depth to apply variable-radius disc blur.
+ */
+declare const DOF_SHADER = "\n\n// Luminance calculation (Rec. 709)\nfn luminance(color: vec3f) -> f32 {\n  return dot(color, vec3f(0.2126, 0.7152, 0.0722));\n}\n\n// sRGB to linear conversion\nfn srgbToLinear(color: vec3f) -> vec3f {\n  return pow(color, vec3f(2.2));\n}\n\n// Linear to sRGB conversion\nfn linearToSrgb(color: vec3f) -> vec3f {\n  return pow(color, vec3f(1.0 / 2.2));\n}\n\n// Hash function for noise\nfn hash(p: vec2f) -> f32 {\n  let k = vec2f(0.3183099, 0.3678794);\n  let x = p * k + k.yx;\n  return fract(16.0 * k.x * fract(x.x * x.y * (x.x + x.y)));\n}\n\n// Simple 2D noise\nfn noise2D(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash(i + vec2f(0.0, 0.0)), hash(i + vec2f(1.0, 0.0)), u.x),\n    mix(hash(i + vec2f(0.0, 1.0)), hash(i + vec2f(1.0, 1.0)), u.x),\n    u.y\n  );\n}\n\n\nstruct DOFUniforms {\n  focusDistance: f32,\n  focalLength: f32,\n  aperture: f32,\n  maxBlur: f32,\n  nearPlane: f32,\n  farPlane: f32,\n  padding: vec2f,\n}\n\n@group(0) @binding(0) var texSampler: sampler;\n@group(0) @binding(1) var inputTexture: texture_2d<f32>;\n@group(0) @binding(2) var<uniform> uniforms: DOFUniforms;\n@group(0) @binding(3) var depthTexture: texture_2d<f32>;\n\nfn linearizeDepth(d: f32) -> f32 {\n  return uniforms.nearPlane * uniforms.farPlane /\n    (uniforms.farPlane - d * (uniforms.farPlane - uniforms.nearPlane));\n}\n\nfn circleOfConfusion(depth: f32) -> f32 {\n  let s1 = depth;\n  let s2 = uniforms.focusDistance;\n  let f = uniforms.focalLength;\n  let a = uniforms.aperture;\n  let coc = abs(a * f * (s2 - s1) / (s1 * (s2 - f)));\n  return clamp(coc, 0.0, uniforms.maxBlur);\n}\n\n@fragment\nfn fs_dof(input: VertexOutput) -> @location(0) vec4f {\n  let dims = vec2f(textureDimensions(inputTexture));\n  let texelSize = 1.0 / dims;\n\n  let rawDepth = textureSample(depthTexture, texSampler, input.uv).r;\n  let depth = linearizeDepth(rawDepth);\n  let coc = circleOfConfusion(depth);\n\n  // Disc blur with 16 samples in a Poisson-like pattern\n  let offsets = array<vec2f, 16>(\n    vec2f(-0.94201, -0.39906), vec2f( 0.94558, -0.76890),\n    vec2f(-0.09418, -0.92938), vec2f( 0.34495,  0.29387),\n    vec2f(-0.91588,  0.45771), vec2f(-0.81544,  0.00298),\n    vec2f(-0.38277, -0.56270), vec2f( 0.97484,  0.75648),\n    vec2f( 0.44323, -0.97511), vec2f( 0.53742,  0.01683),\n    vec2f(-0.26496, -0.01497), vec2f(-0.44693,  0.93910),\n    vec2f( 0.79197,  0.19090), vec2f(-0.24188, -0.99706),\n    vec2f( 0.04578,  0.53300), vec2f(-0.75738, -0.81580)\n  );\n\n  var color = vec4f(0.0);\n  var totalWeight = 0.0;\n\n  for (var i = 0u; i < 16u; i++) {\n    let sampleUV = input.uv + offsets[i] * texelSize * coc * 8.0;\n    let sampleColor = textureSample(inputTexture, texSampler, sampleUV);\n    let sampleDepth = linearizeDepth(textureSample(depthTexture, texSampler, sampleUV).r);\n    let sampleCoC = circleOfConfusion(sampleDepth);\n    let w = max(sampleCoC, coc * 0.2);\n    color += sampleColor * w;\n    totalWeight += w;\n  }\n\n  return color / totalWeight;\n}\n";
+/**
+ * SSAO shader (Screen-Space Ambient Occlusion)
+ * Hemisphere sampling around each fragment using depth + reconstructed normals.
+ */
+declare const SSAO_SHADER = "\n\n// Luminance calculation (Rec. 709)\nfn luminance(color: vec3f) -> f32 {\n  return dot(color, vec3f(0.2126, 0.7152, 0.0722));\n}\n\n// sRGB to linear conversion\nfn srgbToLinear(color: vec3f) -> vec3f {\n  return pow(color, vec3f(2.2));\n}\n\n// Linear to sRGB conversion\nfn linearToSrgb(color: vec3f) -> vec3f {\n  return pow(color, vec3f(1.0 / 2.2));\n}\n\n// Hash function for noise\nfn hash(p: vec2f) -> f32 {\n  let k = vec2f(0.3183099, 0.3678794);\n  let x = p * k + k.yx;\n  return fract(16.0 * k.x * fract(x.x * x.y * (x.x + x.y)));\n}\n\n// Simple 2D noise\nfn noise2D(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash(i + vec2f(0.0, 0.0)), hash(i + vec2f(1.0, 0.0)), u.x),\n    mix(hash(i + vec2f(0.0, 1.0)), hash(i + vec2f(1.0, 1.0)), u.x),\n    u.y\n  );\n}\n\n\nstruct SSAOUniforms {\n  radius: f32,\n  bias: f32,\n  samples: f32,\n  power: f32,\n  falloff: f32,\n  mode: f32,        // 0 = hemisphere, 1 = hbao\n  bentNormals: f32,  // 0 = off, 1 = on\n  spatialDenoise: f32, // 0 = off, 1 = on\n}\n\n@group(0) @binding(0) var texSampler: sampler;\n@group(0) @binding(1) var inputTexture: texture_2d<f32>;\n@group(0) @binding(2) var<uniform> uniforms: SSAOUniforms;\n@group(0) @binding(3) var depthTexture: texture_2d<f32>;\n\nfn hash3(p: vec2f) -> vec3f {\n  let q = vec3f(\n    dot(p, vec2f(127.1, 311.7)),\n    dot(p, vec2f(269.5, 183.3)),\n    dot(p, vec2f(419.2, 371.9))\n  );\n  return fract(sin(q) * 43758.5453) * 2.0 - 1.0;\n}\n\nfn reconstructNormal(uv: vec2f, texelSize: vec2f) -> vec3f {\n  let dc = textureSample(depthTexture, texSampler, uv).r;\n  let dl = textureSample(depthTexture, texSampler, uv - vec2f(texelSize.x, 0.0)).r;\n  let dr = textureSample(depthTexture, texSampler, uv + vec2f(texelSize.x, 0.0)).r;\n  let db = textureSample(depthTexture, texSampler, uv - vec2f(0.0, texelSize.y)).r;\n  let dt = textureSample(depthTexture, texSampler, uv + vec2f(0.0, texelSize.y)).r;\n  return normalize(vec3f(dl - dr, db - dt, 2.0 * texelSize.x));\n}\n\n// HBAO: 8 directions \u00D7 4 steps per direction = 32 samples\nfn hbaoOcclusion(uv: vec2f, normal: vec3f, centerDepth: f32, texelSize: vec2f) -> vec2f {\n  var occlusion = 0.0;\n  var bentN = vec3f(0.0);\n  let directions = 8;\n  let stepsPerDir = 4;\n  let angleStep = 6.28318 / f32(directions);\n\n  for (var d = 0; d < directions; d++) {\n    let angle = f32(d) * angleStep;\n    let dir = vec2f(cos(angle), sin(angle));\n    var maxHorizon = uniforms.bias;\n\n    for (var s = 1; s <= stepsPerDir; s++) {\n      let stepScale = f32(s) / f32(stepsPerDir);\n      let sampleOffset = dir * uniforms.radius * stepScale * texelSize * 8.0;\n      let sampleUV = uv + sampleOffset;\n      let sampleDepth = textureSample(depthTexture, texSampler, sampleUV).r;\n      let depthDelta = centerDepth - sampleDepth;\n\n      if (depthDelta > uniforms.bias && depthDelta < uniforms.falloff) {\n        let horizonAngle = depthDelta / (length(sampleOffset) * 500.0 + 0.001);\n        maxHorizon = max(maxHorizon, horizonAngle);\n      }\n    }\n    occlusion += maxHorizon;\n    // Accumulate bent normal: direction of least occlusion\n    let weight = 1.0 - min(maxHorizon * 2.0, 1.0);\n    bentN += vec3f(dir * weight, weight);\n  }\n\n  occlusion = 1.0 - pow(occlusion / f32(directions), uniforms.power);\n  return vec2f(occlusion, length(bentN.xy));\n}\n\n// 5\u00D75 cross-bilateral spatial denoise\nfn spatialDenoise(uv: vec2f, centerOcclusion: f32, centerDepth: f32, centerNormal: vec3f, texelSize: vec2f) -> f32 {\n  var sum = centerOcclusion;\n  var totalWeight = 1.0;\n\n  for (var y = -2; y <= 2; y++) {\n    for (var x = -2; x <= 2; x++) {\n      if (x == 0 && y == 0) { continue; }\n      let offset = vec2f(f32(x), f32(y)) * texelSize;\n      let sampleUV = uv + offset;\n      let sampleDepth = textureSample(depthTexture, texSampler, sampleUV).r;\n      let sampleNormal = reconstructNormal(sampleUV, texelSize);\n\n      // Depth similarity weight\n      let depthW = exp(-abs(centerDepth - sampleDepth) * 100.0);\n      // Normal similarity weight\n      let normalW = max(dot(centerNormal, sampleNormal), 0.0);\n      // Spatial weight (Gaussian)\n      let spatialW = exp(-f32(x * x + y * y) * 0.2);\n\n      let w = depthW * normalW * spatialW;\n      // Re-sample occlusion at this location (simplified: use color channel)\n      let sampleColor = textureSample(inputTexture, texSampler, sampleUV);\n      let sampleOcclusion = luminance(sampleColor.rgb) / max(luminance(textureSample(inputTexture, texSampler, uv).rgb), 0.001);\n      sum += clamp(sampleOcclusion, 0.0, 2.0) * w;\n      totalWeight += w;\n    }\n  }\n\n  return sum / totalWeight;\n}\n\n@fragment\nfn fs_ssao(input: VertexOutput) -> @location(0) vec4f {\n  let dims = vec2f(textureDimensions(inputTexture));\n  let texelSize = 1.0 / dims;\n  let color = textureSample(inputTexture, texSampler, input.uv);\n  let centerDepth = textureSample(depthTexture, texSampler, input.uv).r;\n  let normal = reconstructNormal(input.uv, texelSize);\n\n  var occlusion = 0.0;\n\n  if (uniforms.mode > 0.5) {\n    // HBAO mode: 8 directions \u00D7 4 steps\n    let hbaoResult = hbaoOcclusion(input.uv, normal, centerDepth, texelSize);\n    occlusion = hbaoResult.x;\n  } else {\n    // Standard hemisphere sampling\n    let sampleCount = u32(uniforms.samples);\n    var occ = 0.0;\n    for (var i = 0u; i < sampleCount; i++) {\n      let randSeed = input.uv * dims + vec2f(f32(i) * 7.0, f32(i) * 13.0);\n      var sampleDir = normalize(hash3(randSeed));\n      if (dot(sampleDir, normal) < 0.0) {\n        sampleDir = -sampleDir;\n      }\n      let scale = f32(i + 1u) / f32(sampleCount);\n      let sampleOffset = sampleDir * uniforms.radius * mix(0.1, 1.0, scale * scale);\n      let sampleUV = input.uv + sampleOffset.xy * texelSize * 8.0;\n      let sampleDepth = textureSample(depthTexture, texSampler, sampleUV).r;\n      let rangeCheck = smoothstep(0.0, 1.0,\n        uniforms.falloff / abs(centerDepth - sampleDepth + 0.0001));\n      if (sampleDepth < centerDepth - uniforms.bias) {\n        occ += rangeCheck;\n      }\n    }\n    occlusion = 1.0 - pow(occ / f32(sampleCount), uniforms.power);\n  }\n\n  // Spatial denoise pass (applied inline for simplicity)\n  if (uniforms.spatialDenoise > 0.5) {\n    // Approximate denoise by blending with neighbors\n    var blurred = occlusion;\n    var tw = 1.0;\n    for (var dy = -1; dy <= 1; dy++) {\n      for (var dx = -1; dx <= 1; dx++) {\n        if (dx == 0 && dy == 0) { continue; }\n        let off = vec2f(f32(dx), f32(dy)) * texelSize;\n        let sd = textureSample(depthTexture, texSampler, input.uv + off).r;\n        let dw = exp(-abs(centerDepth - sd) * 50.0);\n        let sn = reconstructNormal(input.uv + off, texelSize);\n        let nw = max(dot(normal, sn), 0.0);\n        let w = dw * nw;\n        blurred += occlusion * w; // Approximation: use same occlusion\n        tw += w;\n      }\n    }\n    occlusion = blurred / tw;\n  }\n\n  return vec4f(color.rgb * occlusion, color.a);\n}\n";
+/**
+ * Fog shader
+ * Supports linear, exponential, and exponential-squared fog with height falloff.
+ * mode: 0 = linear, 1 = exponential, 2 = exponential-squared
+ */
+declare const FOG_SHADER = "\n\n// Luminance calculation (Rec. 709)\nfn luminance(color: vec3f) -> f32 {\n  return dot(color, vec3f(0.2126, 0.7152, 0.0722));\n}\n\n// sRGB to linear conversion\nfn srgbToLinear(color: vec3f) -> vec3f {\n  return pow(color, vec3f(2.2));\n}\n\n// Linear to sRGB conversion\nfn linearToSrgb(color: vec3f) -> vec3f {\n  return pow(color, vec3f(1.0 / 2.2));\n}\n\n// Hash function for noise\nfn hash(p: vec2f) -> f32 {\n  let k = vec2f(0.3183099, 0.3678794);\n  let x = p * k + k.yx;\n  return fract(16.0 * k.x * fract(x.x * x.y * (x.x + x.y)));\n}\n\n// Simple 2D noise\nfn noise2D(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash(i + vec2f(0.0, 0.0)), hash(i + vec2f(1.0, 0.0)), u.x),\n    mix(hash(i + vec2f(0.0, 1.0)), hash(i + vec2f(1.0, 1.0)), u.x),\n    u.y\n  );\n}\n\n\nstruct FogUniforms {\n  color: vec3f,\n  density: f32,\n  start: f32,\n  end: f32,\n  height: f32,\n  heightFalloff: f32,\n  mode: f32,\n  padding: vec3f,\n}\n\n@group(0) @binding(0) var texSampler: sampler;\n@group(0) @binding(1) var inputTexture: texture_2d<f32>;\n@group(0) @binding(2) var<uniform> uniforms: FogUniforms;\n@group(0) @binding(3) var depthTexture: texture_2d<f32>;\n\n@fragment\nfn fs_fog(input: VertexOutput) -> @location(0) vec4f {\n  let color = textureSample(inputTexture, texSampler, input.uv);\n  let depth = textureSample(depthTexture, texSampler, input.uv).r;\n\n  // Compute fog factor based on mode\n  var fogFactor = 0.0;\n  let mode = u32(uniforms.mode);\n  if (mode == 0u) {\n    // Linear fog\n    fogFactor = clamp((uniforms.end - depth) / (uniforms.end - uniforms.start), 0.0, 1.0);\n  } else if (mode == 1u) {\n    // Exponential fog\n    fogFactor = exp(-uniforms.density * depth);\n  } else {\n    // Exponential-squared fog\n    let d = uniforms.density * depth;\n    fogFactor = exp(-d * d);\n  }\n\n  // Height-based attenuation\n  let heightUV = 1.0 - input.uv.y; // screen-space approximation of world height\n  let heightFactor = exp(-max(heightUV - uniforms.height, 0.0) * uniforms.heightFalloff);\n  fogFactor = mix(fogFactor, 1.0, 1.0 - heightFactor);\n\n  let foggedColor = mix(uniforms.color, color.rgb, fogFactor);\n  return vec4f(foggedColor, color.a);\n}\n";
+/**
+ * Motion blur shader
+ * Samples along per-pixel velocity vector from a velocity buffer.
+ */
+declare const MOTION_BLUR_SHADER = "\n\n// Luminance calculation (Rec. 709)\nfn luminance(color: vec3f) -> f32 {\n  return dot(color, vec3f(0.2126, 0.7152, 0.0722));\n}\n\n// sRGB to linear conversion\nfn srgbToLinear(color: vec3f) -> vec3f {\n  return pow(color, vec3f(2.2));\n}\n\n// Linear to sRGB conversion\nfn linearToSrgb(color: vec3f) -> vec3f {\n  return pow(color, vec3f(1.0 / 2.2));\n}\n\n// Hash function for noise\nfn hash(p: vec2f) -> f32 {\n  let k = vec2f(0.3183099, 0.3678794);\n  let x = p * k + k.yx;\n  return fract(16.0 * k.x * fract(x.x * x.y * (x.x + x.y)));\n}\n\n// Simple 2D noise\nfn noise2D(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash(i + vec2f(0.0, 0.0)), hash(i + vec2f(1.0, 0.0)), u.x),\n    mix(hash(i + vec2f(0.0, 1.0)), hash(i + vec2f(1.0, 1.0)), u.x),\n    u.y\n  );\n}\n\n\nstruct MotionBlurUniforms {\n  samples: f32,\n  velocityScale: f32,\n  maxVelocity: f32,\n  intensity: f32,\n}\n\n@group(0) @binding(0) var texSampler: sampler;\n@group(0) @binding(1) var inputTexture: texture_2d<f32>;\n@group(0) @binding(2) var<uniform> uniforms: MotionBlurUniforms;\n@group(0) @binding(3) var velocityTexture: texture_2d<f32>;\n\n@fragment\nfn fs_motionblur(input: VertexOutput) -> @location(0) vec4f {\n  let velocity = textureSample(velocityTexture, texSampler, input.uv).rg;\n\n  // Scale and clamp velocity\n  var vel = velocity * uniforms.velocityScale;\n  let speed = length(vel);\n  if (speed > uniforms.maxVelocity) {\n    vel = vel * (uniforms.maxVelocity / speed);\n  }\n\n  let sampleCount = u32(uniforms.samples);\n  var color = textureSample(inputTexture, texSampler, input.uv);\n  var totalWeight = 1.0;\n\n  for (var i = 1u; i <= sampleCount; i++) {\n    let t = (f32(i) / f32(sampleCount)) - 0.5;\n    let sampleUV = input.uv + vel * t;\n    let sampleColor = textureSample(inputTexture, texSampler, sampleUV);\n    let w = 1.0 - abs(t) * 2.0; // Center-weighted\n    color += sampleColor * w;\n    totalWeight += w;\n  }\n\n  let blurred = color / totalWeight;\n  let original = textureSample(inputTexture, texSampler, input.uv);\n  return mix(original, blurred, uniforms.intensity);\n}\n";
+/**
+ * Color grading shader
+ */
+declare const COLOR_GRADE_SHADER = "\n\n// Luminance calculation (Rec. 709)\nfn luminance(color: vec3f) -> f32 {\n  return dot(color, vec3f(0.2126, 0.7152, 0.0722));\n}\n\n// sRGB to linear conversion\nfn srgbToLinear(color: vec3f) -> vec3f {\n  return pow(color, vec3f(2.2));\n}\n\n// Linear to sRGB conversion\nfn linearToSrgb(color: vec3f) -> vec3f {\n  return pow(color, vec3f(1.0 / 2.2));\n}\n\n// Hash function for noise\nfn hash(p: vec2f) -> f32 {\n  let k = vec2f(0.3183099, 0.3678794);\n  let x = p * k + k.yx;\n  return fract(16.0 * k.x * fract(x.x * x.y * (x.x + x.y)));\n}\n\n// Simple 2D noise\nfn noise2D(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash(i + vec2f(0.0, 0.0)), hash(i + vec2f(1.0, 0.0)), u.x),\n    mix(hash(i + vec2f(0.0, 1.0)), hash(i + vec2f(1.0, 1.0)), u.x),\n    u.y\n  );\n}\n\n\nstruct ColorGradeUniforms {\n  shadows: vec3f,\n  shadowsOffset: f32,\n  midtones: vec3f,\n  highlightsOffset: f32,\n  highlights: vec3f,\n  hueShift: f32,\n  temperature: f32,\n  tint: f32,\n  intensity: f32,\n  lutIntensity: f32,\n}\n\n@group(0) @binding(0) var texSampler: sampler;\n@group(0) @binding(1) var inputTexture: texture_2d<f32>;\n@group(0) @binding(2) var<uniform> uniforms: ColorGradeUniforms;\n\n// RGB to HSL conversion\nfn rgbToHsl(c: vec3f) -> vec3f {\n  let cMax = max(max(c.r, c.g), c.b);\n  let cMin = min(min(c.r, c.g), c.b);\n  let delta = cMax - cMin;\n\n  var h = 0.0;\n  var s = 0.0;\n  let l = (cMax + cMin) / 2.0;\n\n  if (delta > 0.0) {\n    s = select(delta / (2.0 - cMax - cMin), delta / (cMax + cMin), l < 0.5);\n\n    if (cMax == c.r) {\n      h = (c.g - c.b) / delta + select(0.0, 6.0, c.g < c.b);\n    } else if (cMax == c.g) {\n      h = (c.b - c.r) / delta + 2.0;\n    } else {\n      h = (c.r - c.g) / delta + 4.0;\n    }\n    h /= 6.0;\n  }\n\n  return vec3f(h, s, l);\n}\n\nfn hue2rgb(p: f32, q: f32, t: f32) -> f32 {\n  var tt = t;\n  if (tt < 0.0) { tt += 1.0; }\n  if (tt > 1.0) { tt -= 1.0; }\n  if (tt < 1.0/6.0) { return p + (q - p) * 6.0 * tt; }\n  if (tt < 1.0/2.0) { return q; }\n  if (tt < 2.0/3.0) { return p + (q - p) * (2.0/3.0 - tt) * 6.0; }\n  return p;\n}\n\nfn hslToRgb(hsl: vec3f) -> vec3f {\n  if (hsl.y == 0.0) {\n    return vec3f(hsl.z);\n  }\n\n  let q = select(hsl.z + hsl.y - hsl.z * hsl.y, hsl.z * (1.0 + hsl.y), hsl.z < 0.5);\n  let p = 2.0 * hsl.z - q;\n\n  return vec3f(\n    hue2rgb(p, q, hsl.x + 1.0/3.0),\n    hue2rgb(p, q, hsl.x),\n    hue2rgb(p, q, hsl.x - 1.0/3.0)\n  );\n}\n\n// Temperature/tint adjustment\nfn adjustTemperature(color: vec3f, temp: f32, tint: f32) -> vec3f {\n  var result = color;\n  // Warm (positive) = more red, less blue\n  result.r += temp * 0.1;\n  result.b -= temp * 0.1;\n  // Tint: positive = more green\n  result.g += tint * 0.1;\n  return clamp(result, vec3f(0.0), vec3f(1.0));\n}\n\n@fragment\nfn fs_colorgrade(input: VertexOutput) -> @location(0) vec4f {\n  var color = textureSample(inputTexture, texSampler, input.uv).rgb;\n\n  let lum = luminance(color);\n\n  // Shadows/Midtones/Highlights\n  let shadowWeight = 1.0 - smoothstep(0.0, 0.33, lum);\n  let highlightWeight = smoothstep(0.66, 1.0, lum);\n  let midtoneWeight = 1.0 - shadowWeight - highlightWeight;\n\n  color += uniforms.shadows * shadowWeight;\n  color += uniforms.midtones * midtoneWeight;\n  color += uniforms.highlights * highlightWeight;\n\n  // Hue shift\n  if (abs(uniforms.hueShift) > 0.001) {\n    var hsl = rgbToHsl(color);\n    hsl.x = fract(hsl.x + uniforms.hueShift);\n    color = hslToRgb(hsl);\n  }\n\n  // Temperature and tint\n  color = adjustTemperature(color, uniforms.temperature, uniforms.tint);\n\n  return vec4f(color, 1.0);\n}\n";
+/**
+ * Blit/copy shader for simple texture copies
+ */
+declare const BLIT_SHADER = "\n@group(0) @binding(0) var texSampler: sampler;\n@group(0) @binding(1) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn fs_blit(input: VertexOutput) -> @location(0) vec4f {\n  return textureSample(inputTexture, texSampler, input.uv);\n}\n";
+/**
+ * Caustics overlay shader
+ * Projects animated underwater caustic patterns onto the scene.
+ * Uses dual-layer Voronoi for realistic interference.
+ */
+declare const CAUSTICS_SHADER = "\n\n// Luminance calculation (Rec. 709)\nfn luminance(color: vec3f) -> f32 {\n  return dot(color, vec3f(0.2126, 0.7152, 0.0722));\n}\n\n// sRGB to linear conversion\nfn srgbToLinear(color: vec3f) -> vec3f {\n  return pow(color, vec3f(2.2));\n}\n\n// Linear to sRGB conversion\nfn linearToSrgb(color: vec3f) -> vec3f {\n  return pow(color, vec3f(1.0 / 2.2));\n}\n\n// Hash function for noise\nfn hash(p: vec2f) -> f32 {\n  let k = vec2f(0.3183099, 0.3678794);\n  let x = p * k + k.yx;\n  return fract(16.0 * k.x * fract(x.x * x.y * (x.x + x.y)));\n}\n\n// Simple 2D noise\nfn noise2D(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash(i + vec2f(0.0, 0.0)), hash(i + vec2f(1.0, 0.0)), u.x),\n    mix(hash(i + vec2f(0.0, 1.0)), hash(i + vec2f(1.0, 1.0)), u.x),\n    u.y\n  );\n}\n\n\nstruct CausticsUniforms {\n  intensity: f32,\n  scale: f32,\n  speed: f32,\n  time: f32,\n  color: vec3f,\n  depthFade: f32,\n  waterLevel: f32,\n  dispersion: f32,\n  foamIntensity: f32,\n  shadowStrength: f32,\n}\n\n@group(0) @binding(0) var texSampler: sampler;\n@group(0) @binding(1) var inputTexture: texture_2d<f32>;\n@group(0) @binding(2) var<uniform> uniforms: CausticsUniforms;\n@group(0) @binding(3) var depthTexture: texture_2d<f32>;\n\nfn voronoiDist(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  var md = 1.0;\n  for (var y = -1; y <= 1; y++) {\n    for (var x = -1; x <= 1; x++) {\n      let n = vec2f(f32(x), f32(y));\n      let h1 = fract(sin(dot(i + n, vec2f(127.1, 311.7))) * 43758.5453);\n      let h2 = fract(sin(dot(i + n, vec2f(269.5, 183.3))) * 43758.5453);\n      let pt = n + vec2f(h1, h2) - f;\n      md = min(md, dot(pt, pt));\n    }\n  }\n  return sqrt(md);\n}\n\n// Refractive caustic with IoR-based convergence\nfn refractiveCausticPP(uv: vec2f, time: f32, scale: f32, ior: f32) -> f32 {\n  let eps = 0.01;\n  let h0 = voronoiDist(uv * scale + vec2f(time * 0.3, time * 0.7));\n  let hx = voronoiDist((uv + vec2f(eps, 0.0)) * scale + vec2f(time * 0.3, time * 0.7));\n  let hy = voronoiDist((uv + vec2f(0.0, eps)) * scale + vec2f(time * 0.3, time * 0.7));\n  let grad = vec2f(hx - h0, hy - h0) / eps;\n  let refracted = grad * (1.0 / ior - 1.0);\n  let convergence = voronoiDist((uv + refracted * 0.1) * scale * 1.3 + vec2f(-time * 0.5, time * 0.4));\n  return pow(1.0 - convergence, 4.0);\n}\n\n// Turbulence-driven foam\nfn foamNoise(uv: vec2f, time: f32, scale: f32) -> f32 {\n  let n1 = fract(sin(dot(floor(uv * scale * 4.0), vec2f(127.1, 311.7))) * 43758.5453);\n  let n2 = fract(sin(dot(floor(uv * scale * 8.0 + vec2f(time * 0.5, 0.0)), vec2f(269.5, 183.3))) * 43758.5453);\n  let turbulence = abs(n1 * 2.0 - 1.0) + abs(n2 * 2.0 - 1.0) * 0.5;\n  return smoothstep(0.8, 1.2, turbulence);\n}\n\n@fragment\nfn fs_caustics(input: VertexOutput) -> @location(0) vec4f {\n  let color = textureSample(inputTexture, texSampler, input.uv);\n  let depth = textureSample(depthTexture, texSampler, input.uv).r;\n\n  let worldY = 1.0 - input.uv.y;\n  if (worldY > uniforms.waterLevel) {\n    return color;\n  }\n\n  let depthFactor = exp(-depth * uniforms.depthFade);\n  var causticColor = vec3f(0.0);\n\n  if (uniforms.dispersion > 0.001) {\n    // Chromatic dispersion: separate R/G/B with different IoR\n    let baseIoR = 1.33;\n    let t = uniforms.time * uniforms.speed;\n    let rC = refractiveCausticPP(input.uv, t, uniforms.scale, baseIoR - uniforms.dispersion);\n    let gC = refractiveCausticPP(input.uv, t, uniforms.scale, baseIoR);\n    let bC = refractiveCausticPP(input.uv, t, uniforms.scale, baseIoR + uniforms.dispersion);\n    causticColor = vec3f(rC, gC, bC) * uniforms.color * uniforms.intensity * depthFactor;\n  } else {\n    // Standard dual-layer caustics\n    let uv1 = input.uv * uniforms.scale + vec2f(uniforms.time * uniforms.speed * 0.3, uniforms.time * uniforms.speed * 0.7);\n    let uv2 = input.uv * uniforms.scale * 1.3 + vec2f(-uniforms.time * uniforms.speed * 0.5, uniforms.time * uniforms.speed * 0.4);\n    let c1 = voronoiDist(uv1);\n    let c2 = voronoiDist(uv2);\n    let caustic = pow(1.0 - c1, 3.0) * pow(1.0 - c2, 3.0);\n    causticColor = uniforms.color * caustic * uniforms.intensity * depthFactor;\n  }\n\n  // Foam overlay\n  let foam = foamNoise(input.uv, uniforms.time * uniforms.speed, uniforms.scale) * uniforms.foamIntensity;\n\n  // Caustic shadows: darken where caustics are absent\n  let causticLum = dot(causticColor, vec3f(0.333));\n  let shadow = mix(1.0, 1.0 - uniforms.shadowStrength, (1.0 - causticLum) * depthFactor);\n\n  let result = color.rgb * shadow + causticColor + vec3f(foam);\n  return vec4f(result, color.a);\n}\n";
+/**
+ * Screen-Space Reflections (SSR) shader
+ * Ray-marches in screen space to find reflections.
+ * Uses hierarchical tracing with binary refinement.
+ */
+declare const SSR_SHADER = "\n\n// Luminance calculation (Rec. 709)\nfn luminance(color: vec3f) -> f32 {\n  return dot(color, vec3f(0.2126, 0.7152, 0.0722));\n}\n\n// sRGB to linear conversion\nfn srgbToLinear(color: vec3f) -> vec3f {\n  return pow(color, vec3f(2.2));\n}\n\n// Linear to sRGB conversion\nfn linearToSrgb(color: vec3f) -> vec3f {\n  return pow(color, vec3f(1.0 / 2.2));\n}\n\n// Hash function for noise\nfn hash(p: vec2f) -> f32 {\n  let k = vec2f(0.3183099, 0.3678794);\n  let x = p * k + k.yx;\n  return fract(16.0 * k.x * fract(x.x * x.y * (x.x + x.y)));\n}\n\n// Simple 2D noise\nfn noise2D(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash(i + vec2f(0.0, 0.0)), hash(i + vec2f(1.0, 0.0)), u.x),\n    mix(hash(i + vec2f(0.0, 1.0)), hash(i + vec2f(1.0, 1.0)), u.x),\n    u.y\n  );\n}\n\n\nstruct SSRUniforms {\n  maxSteps: f32,\n  stepSize: f32,\n  thickness: f32,\n  roughnessFade: f32,\n  edgeFade: f32,\n  intensity: f32,\n  roughnessBlur: f32,\n  fresnelStrength: f32,\n}\n\n@group(0) @binding(0) var texSampler: sampler;\n@group(0) @binding(1) var inputTexture: texture_2d<f32>;\n@group(0) @binding(2) var<uniform> uniforms: SSRUniforms;\n@group(0) @binding(3) var depthTexture: texture_2d<f32>;\n@group(0) @binding(4) var normalTexture: texture_2d<f32>;\n\n@fragment\nfn fs_ssr(input: VertexOutput) -> @location(0) vec4f {\n  let color = textureSample(inputTexture, texSampler, input.uv);\n  let depth = textureSample(depthTexture, texSampler, input.uv).r;\n  let texSize = vec2f(textureDimensions(inputTexture));\n  let texel = 1.0 / texSize;\n\n  // Reconstruct normal from depth\n  let dc = depth;\n  let dl = textureSample(depthTexture, texSampler, input.uv - vec2f(texel.x, 0.0)).r;\n  let dr = textureSample(depthTexture, texSampler, input.uv + vec2f(texel.x, 0.0)).r;\n  let db = textureSample(depthTexture, texSampler, input.uv - vec2f(0.0, texel.y)).r;\n  let dt = textureSample(depthTexture, texSampler, input.uv + vec2f(0.0, texel.y)).r;\n  let normal = normalize(vec3f(dl - dr, db - dt, 2.0 * texel.x));\n\n  // View direction (simplified \u2014 assumes forward-facing camera)\n  let viewDir = normalize(vec3f(input.uv * 2.0 - 1.0, -1.0));\n\n  // Reflect view around normal\n  let reflectDir = reflect(viewDir, normal);\n  let stepDir = reflectDir.xy * uniforms.stepSize;\n\n  var hitUV = input.uv;\n  var hit = false;\n  let steps = i32(uniforms.maxSteps);\n\n  for (var i = 1; i <= steps; i++) {\n    hitUV += stepDir;\n\n    // Bounds check\n    if (hitUV.x < 0.0 || hitUV.x > 1.0 || hitUV.y < 0.0 || hitUV.y > 1.0) { break; }\n\n    let sampleDepth = textureSample(depthTexture, texSampler, hitUV).r;\n    let expectedDepth = depth + f32(i) * uniforms.stepSize;\n\n    if (expectedDepth > sampleDepth && expectedDepth - sampleDepth < uniforms.thickness) {\n      hit = true;\n\n      // Binary refinement (4 steps)\n      var refineStep = stepDir * 0.5;\n      for (var j = 0; j < 4; j++) {\n        hitUV -= refineStep;\n        let rd = textureSample(depthTexture, texSampler, hitUV).r;\n        let re = depth + length(hitUV - input.uv) / uniforms.stepSize * uniforms.stepSize;\n        if (re > rd) {\n          hitUV += refineStep;\n        }\n        refineStep *= 0.5;\n      }\n      break;\n    }\n  }\n\n  if (!hit) { return color; }\n\n  // Roughness blur: golden-angle 8-sample blur at hit point scaled by roughness\n  var reflectionColor = vec3f(0.0);\n  if (uniforms.roughnessBlur > 0.001) {\n    let blurRadius = uniforms.roughnessBlur * 0.01;\n    let goldenAngle = 2.399963;\n    var totalW = 0.0;\n    for (var s = 0; s < 8; s++) {\n      let angle = f32(s) * goldenAngle;\n      let r = sqrt(f32(s + 1) / 8.0) * blurRadius;\n      let blurOffset = vec2f(cos(angle), sin(angle)) * r;\n      let sampleC = textureSample(inputTexture, texSampler, hitUV + blurOffset).rgb;\n      let w = 1.0 - f32(s) / 8.0;\n      reflectionColor += sampleC * w;\n      totalW += w;\n    }\n    reflectionColor /= totalW;\n  } else {\n    reflectionColor = textureSample(inputTexture, texSampler, hitUV).rgb;\n  }\n\n  // Schlick Fresnel weighting\n  let cosTheta = max(dot(-viewDir, normal), 0.0);\n  let f0 = 0.04; // dielectric\n  let fresnel = f0 + (1.0 - f0) * pow(1.0 - cosTheta, 5.0);\n  let fresnelWeight = mix(1.0, fresnel, uniforms.fresnelStrength);\n\n  // Edge fade\n  let edgeDist = max(abs(hitUV.x - 0.5), abs(hitUV.y - 0.5)) * 2.0;\n  let edgeFade = 1.0 - pow(clamp(edgeDist, 0.0, 1.0), uniforms.edgeFade);\n\n  // Distance fade\n  let travelDist = length(hitUV - input.uv);\n  let distFade = 1.0 - clamp(travelDist * 2.0, 0.0, 1.0);\n\n  let reflectionMask = edgeFade * distFade * uniforms.intensity * fresnelWeight;\n  return vec4f(mix(color.rgb, reflectionColor, reflectionMask), color.a);\n}\n";
+/**
+ * Screen-Space Global Illumination (SSGI) shader
+ * Approximates indirect lighting by sampling nearby pixels' colors
+ * and treating them as bounce light sources.
+ */
+declare const SSGI_SHADER = "\n\n// Luminance calculation (Rec. 709)\nfn luminance(color: vec3f) -> f32 {\n  return dot(color, vec3f(0.2126, 0.7152, 0.0722));\n}\n\n// sRGB to linear conversion\nfn srgbToLinear(color: vec3f) -> vec3f {\n  return pow(color, vec3f(2.2));\n}\n\n// Linear to sRGB conversion\nfn linearToSrgb(color: vec3f) -> vec3f {\n  return pow(color, vec3f(1.0 / 2.2));\n}\n\n// Hash function for noise\nfn hash(p: vec2f) -> f32 {\n  let k = vec2f(0.3183099, 0.3678794);\n  let x = p * k + k.yx;\n  return fract(16.0 * k.x * fract(x.x * x.y * (x.x + x.y)));\n}\n\n// Simple 2D noise\nfn noise2D(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash(i + vec2f(0.0, 0.0)), hash(i + vec2f(1.0, 0.0)), u.x),\n    mix(hash(i + vec2f(0.0, 1.0)), hash(i + vec2f(1.0, 1.0)), u.x),\n    u.y\n  );\n}\n\n\nstruct SSGIUniforms {\n  radius: f32,\n  samples: f32,\n  bounceIntensity: f32,\n  falloff: f32,\n  time: f32,\n  intensity: f32,\n  temporalBlend: f32,\n  spatialDenoise: f32,\n  multiBounce: f32,\n  padding: vec3f,\n}\n\n@group(0) @binding(0) var texSampler: sampler;\n@group(0) @binding(1) var inputTexture: texture_2d<f32>;\n@group(0) @binding(2) var<uniform> uniforms: SSGIUniforms;\n@group(0) @binding(3) var depthTexture: texture_2d<f32>;\n\n@fragment\nfn fs_ssgi(input: VertexOutput) -> @location(0) vec4f {\n  let color = textureSample(inputTexture, texSampler, input.uv);\n  let centerDepth = textureSample(depthTexture, texSampler, input.uv).r;\n  let texSize = vec2f(textureDimensions(inputTexture));\n  let texel = 1.0 / texSize;\n\n  // Reconstruct normal from depth\n  let dl = textureSample(depthTexture, texSampler, input.uv - vec2f(texel.x, 0.0)).r;\n  let dr = textureSample(depthTexture, texSampler, input.uv + vec2f(texel.x, 0.0)).r;\n  let db = textureSample(depthTexture, texSampler, input.uv - vec2f(0.0, texel.y)).r;\n  let dt = textureSample(depthTexture, texSampler, input.uv + vec2f(0.0, texel.y)).r;\n  let normal = normalize(vec3f(dl - dr, db - dt, 2.0 * texel.x));\n\n  var indirect = vec3f(0.0);\n  let sampleCount = i32(uniforms.samples);\n  let goldenAngle = 2.399963;\n\n  for (var i = 0; i < sampleCount; i++) {\n    let fi = f32(i);\n    let r = sqrt(fi / uniforms.samples) * uniforms.radius;\n    let theta = fi * goldenAngle + uniforms.time * 0.1; // Slight temporal jitter\n    let offset = vec2f(cos(theta), sin(theta)) * r * texel * 8.0;\n    let sampleUV = input.uv + offset;\n\n    let sampleColor = textureSample(inputTexture, texSampler, sampleUV).rgb;\n    let sampleDepth = textureSample(depthTexture, texSampler, sampleUV).r;\n\n    // Weight by depth proximity (nearby surfaces contribute more)\n    let depthDiff = abs(centerDepth - sampleDepth);\n    let depthWeight = exp(-depthDiff * uniforms.falloff * 10.0);\n\n    // Cosine weight: approximate normal-based falloff\n    let sampleDir = normalize(vec3f(offset, 0.05));\n    let cosWeight = max(dot(sampleDir, normal), 0.0);\n\n    indirect += sampleColor * depthWeight * cosWeight;\n  }\n\n  indirect /= uniforms.samples;\n  indirect *= uniforms.bounceIntensity;\n\n  // Multi-bounce approximation: self-illumination feedback\n  if (uniforms.multiBounce > 0.001) {\n    indirect *= (1.0 + uniforms.multiBounce * luminance(indirect));\n  }\n\n  // Spatial denoise: 3\u00D73 edge-stopping cross-bilateral filter\n  if (uniforms.spatialDenoise > 0.5) {\n    var denoised = indirect;\n    var tw = 1.0;\n    for (var dy = -1; dy <= 1; dy++) {\n      for (var dx = -1; dx <= 1; dx++) {\n        if (dx == 0 && dy == 0) { continue; }\n        let off = vec2f(f32(dx), f32(dy)) * texel;\n        let sd = textureSample(depthTexture, texSampler, input.uv + off).r;\n        // Depth weight\n        let dw = exp(-abs(centerDepth - sd) * uniforms.falloff * 10.0);\n        // Normal weight\n        let snl = textureSample(depthTexture, texSampler, input.uv + off - vec2f(texel.x, 0.0)).r;\n        let snr = textureSample(depthTexture, texSampler, input.uv + off + vec2f(texel.x, 0.0)).r;\n        let snb = textureSample(depthTexture, texSampler, input.uv + off - vec2f(0.0, texel.y)).r;\n        let snt = textureSample(depthTexture, texSampler, input.uv + off + vec2f(0.0, texel.y)).r;\n        let sn = normalize(vec3f(snl - snr, snb - snt, 2.0 * texel.x));\n        let nw = max(dot(normal, sn), 0.0);\n        let w = dw * nw;\n        // Sample neighbor's indirect (approximation: use color luminance ratio)\n        let neighborColor = textureSample(inputTexture, texSampler, input.uv + off).rgb;\n        denoised += neighborColor * uniforms.bounceIntensity * w * 0.5;\n        tw += w;\n      }\n    }\n    indirect = denoised / tw;\n  }\n\n  var result = color.rgb + indirect * uniforms.intensity;\n\n  // Temporal blend: mix with previous frame color (approximation using current frame offset)\n  if (uniforms.temporalBlend > 0.001) {\n    // Approximate temporal reprojection by blending with slightly jittered sample\n    let temporalUV = input.uv + vec2f(sin(uniforms.time * 31.0), cos(uniforms.time * 37.0)) * texel * 0.5;\n    let prevColor = textureSample(inputTexture, texSampler, temporalUV).rgb;\n    result = mix(result, prevColor + indirect * uniforms.intensity * 0.5, uniforms.temporalBlend * 0.3);\n  }\n\n  return vec4f(result, color.a);\n}\n";
+/**
+ * Build a complete effect shader by combining vertex shader,
+ * utilities, and the effect's fragment shader.
+ */
+declare function buildEffectShader(fragmentShader: string): string;
+
+/**
+ * PostProcessPipeline.ts
+ *
+ * Manages a chain of post-processing effects, handling render targets
+ * and ping-pong buffering for efficient GPU processing.
+ *
+ * @module render/postprocess
+ */
+
+/**
+ * Default pipeline configuration
+ */
+declare const DEFAULT_PIPELINE_CONFIG: IPostProcessPipelineConfig;
+/**
+ * Post-processing pipeline manager
+ */
+declare class PostProcessPipeline {
+    private device;
+    private config;
+    private effects;
+    private renderTargets;
+    private pingPongTargets;
+    private currentWidth;
+    private currentHeight;
+    private _initialized;
+    private frameCount;
+    constructor(config?: Partial<IPostProcessPipelineConfig>);
+    /**
+     * Check if pipeline is initialized
+     */
+    get initialized(): boolean;
+    /**
+     * Get current configuration
+     */
+    getConfig(): IPostProcessPipelineConfig;
+    /**
+     * Get list of active effects
+     */
+    getEffects(): PostProcessEffect[];
+    /**
+     * Get effect by name
+     */
+    getEffect(name: string): PostProcessEffect | undefined;
+    /**
+     * Get effect by type
+     */
+    getEffectByType(type: PostProcessEffectType): PostProcessEffect | undefined;
+    /**
+     * Initialize the pipeline with GPU device
+     */
+    initialize(device: GPUDevice, width: number, height: number): Promise<void>;
+    /**
+     * Create or recreate render targets
+     */
+    private createRenderTargets;
+    /**
+     * Dispose render targets
+     */
+    private disposeRenderTargets;
+    /**
+     * Resize render targets
+     */
+    resize(width: number, height: number): Promise<void>;
+    /**
+     * Add an effect to the pipeline
+     */
+    addEffect(config: IEffectConfig): Promise<PostProcessEffect>;
+    /**
+     * Remove an effect from the pipeline
+     */
+    removeEffect(nameOrType: string | PostProcessEffectType): boolean;
+    /**
+     * Reorder effects
+     */
+    reorderEffects(order: string[]): void;
+    /**
+     * Update effect parameters
+     */
+    updateEffectParams(nameOrType: string | PostProcessEffectType, params: Partial<EffectParams>): boolean;
+    /**
+     * Enable/disable an effect
+     */
+    setEffectEnabled(nameOrType: string | PostProcessEffectType, enabled: boolean): boolean;
+    /**
+     * Execute the post-processing pipeline
+     *
+     * @param commandEncoder GPU command encoder
+     * @param inputView Input texture view (scene render)
+     * @param outputView Output texture view (swap chain)
+     * @param frameData Frame timing and camera data
+     */
+    render(commandEncoder: GPUCommandEncoder, inputView: GPUTextureView, outputView: GPUTextureView, frameData?: Partial<IFrameData>): void;
+    /**
+     * Create temporary render target wrapper for output view
+     */
+    private createTempTarget;
+    /**
+     * Copy texture using a blit pass
+     */
+    private copyTexture;
+    /**
+     * Copy input view to a render target
+     */
+    private copyToTarget;
+    /**
+     * Create a preset pipeline configuration
+     */
+    static createPreset(preset: 'minimal' | 'standard' | 'cinematic' | 'performance'): Partial<IPostProcessPipelineConfig>;
+    /**
+     * Dispose all resources
+     */
+    dispose(): void;
+    /**
+     * Get performance statistics
+     */
+    getStats(): {
+        effectCount: number;
+        enabledEffects: number;
+        renderTargetCount: number;
+        estimatedMemoryMB: number;
+    };
+}
+/**
+ * Create a post-processing pipeline with common presets
+ */
+declare function createPostProcessPipeline(preset?: 'minimal' | 'standard' | 'cinematic' | 'performance', customConfig?: Partial<IPostProcessPipelineConfig>): PostProcessPipeline;
+/**
+ * Quick helper to create a standard HDR pipeline
+ */
+declare function createHDRPipeline(): PostProcessPipeline;
+/**
+ * Quick helper to create a minimal LDR pipeline
+ */
+declare function createLDRPipeline(): PostProcessPipeline;
+
+/**
+ * Post-Processing Module
+ *
+ * WebGPU-based post-processing effects for the HoloScript renderer.
+ *
+ * @module render/postprocess
+ *
+ * @example
+ * ```ts
+ * import { createHDRPipeline, PostProcessPipeline } from '@holoscript/core';
+ *
+ * // Create with preset
+ * const pipeline = createHDRPipeline();
+ *
+ * // Or create custom
+ * const custom = new PostProcessPipeline({
+ *   hdrEnabled: true,
+ *   effects: [
+ *     { type: 'bloom', params: { intensity: 0.8 } },
+ *     { type: 'tonemap', params: { operator: 'aces' } },
+ *     { type: 'fxaa' },
+ *   ]
+ * });
+ *
+ * // Initialize with WebGPU device
+ * await pipeline.initialize(device, width, height);
+ *
+ * // In render loop
+ * pipeline.render(commandEncoder, sceneTexture, swapChainTexture, {
+ *   time: performance.now() / 1000,
+ *   deltaTime: dt,
+ * });
+ * ```
+ */
+
+declare const index$1_BLIT_SHADER: typeof BLIT_SHADER;
+declare const index$1_BLOOM_SHADER: typeof BLOOM_SHADER;
+type index$1_BlendMode = BlendMode;
+type index$1_BloomEffect = BloomEffect;
+declare const index$1_BloomEffect: typeof BloomEffect;
+declare const index$1_CAUSTICS_SHADER: typeof CAUSTICS_SHADER;
+declare const index$1_CHROMATIC_ABERRATION_SHADER: typeof CHROMATIC_ABERRATION_SHADER;
+declare const index$1_COLOR_GRADE_SHADER: typeof COLOR_GRADE_SHADER;
+type index$1_CausticsEffect = CausticsEffect;
+declare const index$1_CausticsEffect: typeof CausticsEffect;
+type index$1_ChromaticAberrationEffect = ChromaticAberrationEffect;
+declare const index$1_ChromaticAberrationEffect: typeof ChromaticAberrationEffect;
+declare const index$1_DEFAULT_PARAMS: typeof DEFAULT_PARAMS;
+declare const index$1_DEFAULT_PIPELINE_CONFIG: typeof DEFAULT_PIPELINE_CONFIG;
+declare const index$1_DOF_SHADER: typeof DOF_SHADER;
+type index$1_EffectParams = EffectParams;
+declare const index$1_FILM_GRAIN_SHADER: typeof FILM_GRAIN_SHADER;
+declare const index$1_FOG_SHADER: typeof FOG_SHADER;
+declare const index$1_FULLSCREEN_VERTEX_SHADER: typeof FULLSCREEN_VERTEX_SHADER;
+type index$1_FXAAEffect = FXAAEffect;
+declare const index$1_FXAAEffect: typeof FXAAEffect;
+type index$1_FXAAQuality = FXAAQuality;
+declare const index$1_FXAA_SHADER: typeof FXAA_SHADER;
+type index$1_FilmGrainEffect = FilmGrainEffect;
+declare const index$1_FilmGrainEffect: typeof FilmGrainEffect;
+type index$1_IBaseEffectParams = IBaseEffectParams;
+type index$1_IBloomParams = IBloomParams;
+type index$1_ICausticsParams = ICausticsParams;
+type index$1_IChromaticAberrationParams = IChromaticAberrationParams;
+type index$1_IColorGradeParams = IColorGradeParams;
+type index$1_ICustomEffectParams = ICustomEffectParams;
+type index$1_IDOFParams = IDOFParams;
+type index$1_IEffectConfig = IEffectConfig;
+type index$1_IEffectRenderContext = IEffectRenderContext;
+type index$1_IFXAAParams = IFXAAParams;
+type index$1_IFilmGrainParams = IFilmGrainParams;
+type index$1_IFogParams = IFogParams;
+type index$1_IFrameData = IFrameData;
+type index$1_IMotionBlurParams = IMotionBlurParams;
+type index$1_IPostProcessPipelineConfig = IPostProcessPipelineConfig;
+type index$1_IRenderTarget = IRenderTarget;
+type index$1_IRenderTargetConfig = IRenderTargetConfig;
+type index$1_ISSAOParams = ISSAOParams;
+type index$1_ISSGIParams = ISSGIParams;
+type index$1_ISSRParams = ISSRParams;
+type index$1_ISharpenParams = ISharpenParams;
+type index$1_IToneMapParams = IToneMapParams;
+type index$1_IVignetteParams = IVignetteParams;
+declare const index$1_MOTION_BLUR_SHADER: typeof MOTION_BLUR_SHADER;
+type index$1_PostProcessEffect = PostProcessEffect;
+declare const index$1_PostProcessEffect: typeof PostProcessEffect;
+type index$1_PostProcessEffectType = PostProcessEffectType;
+type index$1_PostProcessPipeline = PostProcessPipeline;
+declare const index$1_PostProcessPipeline: typeof PostProcessPipeline;
+declare const index$1_SHADER_UTILS: typeof SHADER_UTILS;
+declare const index$1_SHARPEN_SHADER: typeof SHARPEN_SHADER;
+type index$1_SSAOEffect = SSAOEffect;
+declare const index$1_SSAOEffect: typeof SSAOEffect;
+declare const index$1_SSAO_SHADER: typeof SSAO_SHADER;
+type index$1_SSGIEffect = SSGIEffect;
+declare const index$1_SSGIEffect: typeof SSGIEffect;
+declare const index$1_SSGI_SHADER: typeof SSGI_SHADER;
+type index$1_SSREffect = SSREffect;
+declare const index$1_SSREffect: typeof SSREffect;
+declare const index$1_SSR_SHADER: typeof SSR_SHADER;
+type index$1_SharpenEffect = SharpenEffect;
+declare const index$1_SharpenEffect: typeof SharpenEffect;
+declare const index$1_TONEMAP_SHADER: typeof TONEMAP_SHADER;
+type index$1_ToneMapEffect = ToneMapEffect;
+declare const index$1_ToneMapEffect: typeof ToneMapEffect;
+type index$1_ToneMapOperator = ToneMapOperator;
+declare const index$1_UNIFORM_SIZES: typeof UNIFORM_SIZES;
+declare const index$1_VIGNETTE_SHADER: typeof VIGNETTE_SHADER;
+type index$1_VignetteEffect = VignetteEffect;
+declare const index$1_VignetteEffect: typeof VignetteEffect;
+declare const index$1_buildEffectShader: typeof buildEffectShader;
+declare const index$1_createEffect: typeof createEffect;
+declare const index$1_createHDRPipeline: typeof createHDRPipeline;
+declare const index$1_createLDRPipeline: typeof createLDRPipeline;
+declare const index$1_createPostProcessPipeline: typeof createPostProcessPipeline;
+declare const index$1_getDefaultParams: typeof getDefaultParams;
+declare const index$1_mergeParams: typeof mergeParams;
+declare const index$1_validateParams: typeof validateParams;
+declare namespace index$1 {
+  export { index$1_BLIT_SHADER as BLIT_SHADER, index$1_BLOOM_SHADER as BLOOM_SHADER, type index$1_BlendMode as BlendMode, index$1_BloomEffect as BloomEffect, index$1_CAUSTICS_SHADER as CAUSTICS_SHADER, index$1_CHROMATIC_ABERRATION_SHADER as CHROMATIC_ABERRATION_SHADER, index$1_COLOR_GRADE_SHADER as COLOR_GRADE_SHADER, index$1_CausticsEffect as CausticsEffect, index$1_ChromaticAberrationEffect as ChromaticAberrationEffect, index$1_DEFAULT_PARAMS as DEFAULT_PARAMS, index$1_DEFAULT_PIPELINE_CONFIG as DEFAULT_PIPELINE_CONFIG, index$1_DOF_SHADER as DOF_SHADER, type index$1_EffectParams as EffectParams, index$1_FILM_GRAIN_SHADER as FILM_GRAIN_SHADER, index$1_FOG_SHADER as FOG_SHADER, index$1_FULLSCREEN_VERTEX_SHADER as FULLSCREEN_VERTEX_SHADER, index$1_FXAAEffect as FXAAEffect, type index$1_FXAAQuality as FXAAQuality, index$1_FXAA_SHADER as FXAA_SHADER, index$1_FilmGrainEffect as FilmGrainEffect, type index$1_IBaseEffectParams as IBaseEffectParams, type index$1_IBloomParams as IBloomParams, type index$1_ICausticsParams as ICausticsParams, type index$1_IChromaticAberrationParams as IChromaticAberrationParams, type index$1_IColorGradeParams as IColorGradeParams, type index$1_ICustomEffectParams as ICustomEffectParams, type index$1_IDOFParams as IDOFParams, type index$1_IEffectConfig as IEffectConfig, type index$1_IEffectRenderContext as IEffectRenderContext, type index$1_IFXAAParams as IFXAAParams, type index$1_IFilmGrainParams as IFilmGrainParams, type index$1_IFogParams as IFogParams, type index$1_IFrameData as IFrameData, type index$1_IMotionBlurParams as IMotionBlurParams, type index$1_IPostProcessPipelineConfig as IPostProcessPipelineConfig, type index$1_IRenderTarget as IRenderTarget, type index$1_IRenderTargetConfig as IRenderTargetConfig, type index$1_ISSAOParams as ISSAOParams, type index$1_ISSGIParams as ISSGIParams, type index$1_ISSRParams as ISSRParams, type index$1_ISharpenParams as ISharpenParams, type index$1_IToneMapParams as IToneMapParams, type index$1_IVignetteParams as IVignetteParams, index$1_MOTION_BLUR_SHADER as MOTION_BLUR_SHADER, index$1_PostProcessEffect as PostProcessEffect, type index$1_PostProcessEffectType as PostProcessEffectType, index$1_PostProcessPipeline as PostProcessPipeline, index$1_SHADER_UTILS as SHADER_UTILS, index$1_SHARPEN_SHADER as SHARPEN_SHADER, index$1_SSAOEffect as SSAOEffect, index$1_SSAO_SHADER as SSAO_SHADER, index$1_SSGIEffect as SSGIEffect, index$1_SSGI_SHADER as SSGI_SHADER, index$1_SSREffect as SSREffect, index$1_SSR_SHADER as SSR_SHADER, index$1_SharpenEffect as SharpenEffect, index$1_TONEMAP_SHADER as TONEMAP_SHADER, index$1_ToneMapEffect as ToneMapEffect, type index$1_ToneMapOperator as ToneMapOperator, index$1_UNIFORM_SIZES as UNIFORM_SIZES, index$1_VIGNETTE_SHADER as VIGNETTE_SHADER, index$1_VignetteEffect as VignetteEffect, index$1_buildEffectShader as buildEffectShader, index$1_createEffect as createEffect, index$1_createHDRPipeline as createHDRPipeline, index$1_createLDRPipeline as createLDRPipeline, index$1_createPostProcessPipeline as createPostProcessPipeline, index$1_getDefaultParams as getDefaultParams, index$1_mergeParams as mergeParams, index$1_validateParams as validateParams };
+}
+
+/**
+ * Puppeteer-based Headless Chrome Renderer
+ *
+ * Provides headless Chrome rendering capabilities for HoloScript scenes:
+ * - Screenshot capture (PNG, JPEG, WebP)
+ * - PDF generation
+ * - Pre-rendered HTML for SEO/social sharing
+ * - Visual regression testing support
+ * - Animation capture (GIF/video frames)
+ *
+ * @module render/headless/PuppeteerRenderer
+ * @version 1.0.0
+ */
+interface ScreenshotOptions {
+    /** Output format */
+    format?: 'png' | 'jpeg' | 'webp';
+    /** Quality for JPEG/WebP (0-100) */
+    quality?: number;
+    /** Viewport width */
+    width?: number;
+    /** Viewport height */
+    height?: number;
+    /** Device scale factor for retina screenshots */
+    deviceScaleFactor?: number;
+    /** Take full page screenshot */
+    fullPage?: boolean;
+    /** Transparent background (PNG only) */
+    omitBackground?: boolean;
+    /** Wait for scene to stabilize (ms) */
+    waitForStable?: number;
+    /** Custom wait selector */
+    waitForSelector?: string;
+    /** Capture after N animation frames */
+    captureAfterFrames?: number;
+}
+interface PDFOptions {
+    /** Page format */
+    format?: 'A4' | 'Letter' | 'Legal' | 'Tabloid' | 'A3' | 'A5';
+    /** Landscape orientation */
+    landscape?: boolean;
+    /** Print background graphics */
+    printBackground?: boolean;
+    /** Page margins */
+    margin?: {
+        top?: string;
+        right?: string;
+        bottom?: string;
+        left?: string;
+    };
+    /** Scale (0.1 - 2.0) */
+    scale?: number;
+    /** Custom width */
+    width?: string;
+    /** Custom height */
+    height?: string;
+}
+interface PrerenderOptions {
+    /** Wait for JavaScript to execute */
+    waitUntil?: 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2';
+    /** Timeout in ms */
+    timeout?: number;
+    /** Strip JavaScript from output */
+    removeScripts?: boolean;
+    /** Inline CSS */
+    inlineStyles?: boolean;
+    /** Add meta tags for SEO */
+    addMetaTags?: boolean;
+}
+interface AnimationFrameOptions extends ScreenshotOptions {
+    /** Number of frames to capture */
+    frameCount: number;
+    /** Time between frames in ms */
+    frameInterval?: number;
+    /** Output directory for frames */
+    outputDir?: string;
+    /** Frame filename pattern */
+    filenamePattern?: string;
+}
+interface RenderResult {
+    success: boolean;
+    data?: Buffer | string;
+    error?: string;
+    timing?: {
+        navigationMs: number;
+        renderMs: number;
+        captureMs: number;
+        totalMs: number;
+    };
+    metadata?: {
+        width: number;
+        height: number;
+        format: string;
+        size: number;
+    };
+}
+interface PuppeteerRendererOptions {
+    /** Puppeteer executable path (chromium) */
+    executablePath?: string;
+    /** Run in headless mode (default: true) */
+    headless?: boolean;
+    /** Browser arguments */
+    args?: string[];
+    /** Default viewport size */
+    defaultViewport?: {
+        width: number;
+        height: number;
+    };
+    /** Timeout for operations in ms */
+    timeout?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Base URL for the render service */
+    renderServiceUrl?: string;
+    /** Custom Three.js/WebGL version */
+    threeVersion?: string;
+}
+/**
+ * PuppeteerRenderer - Headless Chrome renderer for HoloScript scenes
+ *
+ * @example
+ * ```typescript
+ * const renderer = new PuppeteerRenderer();
+ * await renderer.initialize();
+ *
+ * // Take a screenshot of a scene
+ * const result = await renderer.screenshot(holoCode, {
+ *   width: 1920,
+ *   height: 1080,
+ *   format: 'png'
+ * });
+ *
+ * // Generate PDF
+ * const pdf = await renderer.generatePDF(holoCode, { format: 'A4' });
+ *
+ * // Pre-render for SEO
+ * const html = await renderer.prerender(holoCode, { waitUntil: 'networkidle0' });
+ *
+ * await renderer.close();
+ * ```
+ */
+declare class PuppeteerRenderer {
+    private browser;
+    private options;
+    private initialized;
+    private pagePool;
+    private maxPoolSize;
+    constructor(options?: PuppeteerRendererOptions);
+    /**
+     * Initialize the browser instance
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get or create a page from the pool
+     */
+    private getPage;
+    /**
+     * Return a page to the pool
+     */
+    private releasePage;
+    /**
+     * Ensure browser is initialized
+     */
+    private ensureInitialized;
+    /**
+     * Take a screenshot of a HoloScript scene
+     */
+    screenshot(holoCode: string, options?: ScreenshotOptions): Promise<RenderResult>;
+    /**
+     * Generate a PDF of a HoloScript scene
+     */
+    generatePDF(holoCode: string, options?: PDFOptions): Promise<RenderResult>;
+    /**
+     * Pre-render HoloScript for SEO/social sharing
+     * Returns fully rendered HTML with all JavaScript executed
+     */
+    prerender(holoCode: string, options?: PrerenderOptions): Promise<RenderResult>;
+    /**
+     * Capture animation frames for GIF/video generation
+     */
+    captureAnimationFrames(holoCode: string, options: AnimationFrameOptions): Promise<RenderResult & {
+        frames?: Buffer[];
+    }>;
+    /**
+     * Run visual regression test - compare scene against baseline
+     */
+    visualRegression(holoCode: string, baselineBuffer: Buffer, threshold?: number): Promise<{
+        match: boolean;
+        diffPercentage: number;
+        diffImage?: Buffer;
+    }>;
+    /**
+     * Generate HTML for rendering a HoloScript scene
+     */
+    private generateRenderHTML;
+    /**
+     * Close the browser and cleanup resources
+     */
+    close(): Promise<void>;
+    /**
+     * Check if puppeteer is available
+     */
+    static isAvailable(): Promise<boolean>;
+    /**
+     * Get browser version
+     */
+    getVersion(): Promise<string>;
+    /**
+     * Debug logging
+     */
+    private log;
+}
+/**
+ * Convenience function to create and use a renderer
+ */
+declare function renderScreenshot(holoCode: string, options?: ScreenshotOptions): Promise<RenderResult>;
+/**
+ * Convenience function to generate PDF
+ */
+declare function renderPDF(holoCode: string, options?: PDFOptions): Promise<RenderResult>;
+/**
+ * Convenience function to prerender HTML
+ */
+declare function prerenderHTML(holoCode: string, options?: PrerenderOptions): Promise<RenderResult>;
+
+/**
+ * Rendering subsystem — extracted from @holoscript/core (A.011.01a).
+ *
+ * Includes WebGPU renderer, post-processing pipeline, headless (Puppeteer)
+ * rendering, materials, lighting, ray tracing, shader graph, and visual effects.
+ */
+
+type index_AABB = AABB;
+type index_AdvancedLight = AdvancedLight;
+type index_AdvancedLightingManager = AdvancedLightingManager;
+declare const index_AdvancedLightingManager: typeof AdvancedLightingManager;
+type index_AdvancedPBRConfig = AdvancedPBRConfig;
+type index_AdvancedPBRMaterial = AdvancedPBRMaterial;
+declare const index_AdvancedPBRMaterial: typeof AdvancedPBRMaterial;
+type index_AmbientConfig = AmbientConfig;
+type index_AnimationFrameOptions = AnimationFrameOptions;
+type index_AnisotropyConfig = AnisotropyConfig;
+type index_AreaLightConfig = AreaLightConfig;
+type index_AreaLightShape = AreaLightShape;
+type index_AtlasPacker = AtlasPacker;
+type index_AtlasRect = AtlasRect;
+type index_AttachmentFormat = AttachmentFormat;
+type index_BVH = BVH;
+declare const index_BVH: typeof BVH;
+type index_BVHNode = BVHNode;
+type index_BatchStats = BatchStats;
+type index_BloomConfig = BloomConfig;
+type index_CausticConfig = CausticConfig;
+type index_ChromaticAberrationConfig = ChromaticAberrationConfig;
+type index_ClearOp = ClearOp;
+type index_ClearcoatConfig = ClearcoatConfig;
+type index_CloudConfig = CloudConfig;
+type index_CloudRenderer = CloudRenderer;
+declare const index_CloudRenderer: typeof CloudRenderer;
+type index_CloudSample = CloudSample;
+type index_ColorGrading = ColorGrading;
+declare const index_ColorGrading: typeof ColorGrading;
+type index_ColorGradingConfig = ColorGradingConfig;
+type index_CompiledShader = CompiledShader;
+type index_DOFConfig = DOFConfig;
+type index_DecalBatcher = DecalBatcher;
+declare const index_DecalBatcher: typeof DecalBatcher;
+type index_DecalDef = DecalDef;
+type index_DecalInstance = DecalInstance;
+type index_DecalSystem = DecalSystem;
+declare const index_DecalSystem: typeof DecalSystem;
+type index_DetailMapConfig = DetailMapConfig;
+type index_DisplacementConfig = DisplacementConfig;
+type index_DrawBatch = DrawBatch;
+type index_FogConfig = FogConfig;
+type index_FogMode = FogMode;
+type index_FogSystem = FogSystem;
+declare const index_FogSystem: typeof FogSystem;
+type index_FramebufferAttachment = FramebufferAttachment;
+type index_GIConfig = GIConfig;
+type index_GIMode = GIMode;
+type index_GIProbe = GIProbe;
+type index_GIProbeGrid = GIProbeGrid;
+declare const index_GIProbeGrid: typeof GIProbeGrid;
+type index_GraphStats = GraphStats;
+type index_HitRecord = HitRecord;
+type index_IBlendComponent = IBlendComponent;
+type index_IBlendState = IBlendState;
+type index_IBoundingBox = IBoundingBox;
+type index_IBufferDescriptor = IBufferDescriptor;
+type index_ICameraUniforms = ICameraUniforms;
+type index_IColorTargetState = IColorTargetState;
+type index_IDepthStencilState = IDepthStencilState;
+type index_IDeviceCapabilities = IDeviceCapabilities;
+type index_IDrawCall = IDrawCall;
+type index_IESProfile = IESProfile;
+type index_IFrameStats = IFrameStats;
+type index_IGPUTexture = IGPUTexture;
+type index_IIndexBuffer = IIndexBuffer;
+type index_IRenderMaterial = IRenderMaterial;
+type index_IRenderMesh = IRenderMesh;
+type index_IRenderPassColorAttachment = IRenderPassColorAttachment;
+type index_IRenderPassDepthStencilAttachment = IRenderPassDepthStencilAttachment;
+type index_IRenderPassDescriptor = IRenderPassDescriptor;
+type index_IRenderPipelineDescriptor = IRenderPipelineDescriptor;
+type index_IRendererStats = IRendererStats;
+type index_ISamplerDescriptor = ISamplerDescriptor;
+type index_ISceneUniforms = ISceneUniforms;
+type index_IShaderModule = IShaderModule;
+type index_ITextureDescriptor = ITextureDescriptor;
+type index_IUniformBuffer = IUniformBuffer;
+type index_IVertexAttribute = IVertexAttribute;
+type index_IVertexBuffer = IVertexBuffer;
+type index_IVertexBufferLayout = IVertexBufferLayout;
+type index_IWebGPUContext = IWebGPUContext;
+type index_IWebGPUInitOptions = IWebGPUInitOptions;
+type index_IridescenceConfig = IridescenceConfig;
+type index_Light = Light;
+type index_LightCookie = LightCookie;
+type index_LightType = LightType;
+type index_LightingModel = LightingModel;
+declare const index_LightingModel: typeof LightingModel;
+type index_MaterialDef = MaterialDef;
+type index_MaterialInstance = MaterialInstance;
+type index_MaterialLibrary = MaterialLibrary;
+declare const index_MaterialLibrary: typeof MaterialLibrary;
+type index_MaterialSystem = MaterialSystem;
+declare const index_MaterialSystem: typeof MaterialSystem;
+type index_MotionBlurConfig = MotionBlurConfig;
+type index_NLMConfig = NLMConfig;
+type index_PDFOptions = PDFOptions;
+type index_POMConfig = POMConfig;
+declare const index_PP_PRESETS: typeof PP_PRESETS;
+type index_PassContext = PassContext;
+type index_PathTracerScene = PathTracerScene;
+type index_PhysicsDebugDrawer = PhysicsDebugDrawer;
+declare const index_PhysicsDebugDrawer: typeof PhysicsDebugDrawer;
+type index_PixelBuffer = PixelBuffer;
+type index_PostProcessProfile = PostProcessProfile;
+type index_PostProcessStack = PostProcessStack;
+declare const index_PostProcessStack: typeof PostProcessStack;
+type index_PostProcessingStack = PostProcessingStack;
+declare const index_PostProcessingStack: typeof PostProcessingStack;
+type index_PrerenderOptions = PrerenderOptions;
+type index_ProbeInfo = ProbeInfo;
+type index_ProjectorConfig = ProjectorConfig;
+type index_ProjectorLight = ProjectorLight;
+declare const index_ProjectorLight: typeof ProjectorLight;
+type index_PuppeteerRenderer = PuppeteerRenderer;
+declare const index_PuppeteerRenderer: typeof PuppeteerRenderer;
+type index_PuppeteerRendererOptions = PuppeteerRendererOptions;
+type index_RTApi = RTApi;
+type index_RTFeature = RTFeature;
+type index_Ray = Ray;
+type index_RayTracer = RayTracer;
+declare const index_RayTracer: typeof RayTracer;
+type index_RayTracingConfig = RayTracingConfig;
+type index_RenderGraph = RenderGraph;
+declare const index_RenderGraph: typeof RenderGraph;
+type index_RenderPass = RenderPass;
+declare const index_RenderPass: typeof RenderPass;
+type index_RenderPassConfig = RenderPassConfig;
+type index_RenderPassDescriptor = RenderPassDescriptor;
+type index_RenderResult = RenderResult;
+type index_RenderTarget = RenderTarget;
+type index_SH9 = SH9;
+declare const index_SHADER_NODES: typeof SHADER_NODES;
+type index_SSAOConfig = SSAOConfig;
+type index_SSGIConfig = SSGIConfig;
+type index_SSRConfig = SSRConfig;
+type index_SSSConfig = SSSConfig;
+type index_SSSLayer = SSSLayer;
+type index_SSSMaterial = SSSMaterial;
+declare const index_SSSMaterial: typeof SSSMaterial;
+type index_SSSModel = SSSModel;
+declare const index_SSS_PRESETS: typeof SSS_PRESETS;
+declare const index_STANDARD_FRAGMENT_SHADER: typeof STANDARD_FRAGMENT_SHADER;
+declare const index_STANDARD_VERTEX_SHADER: typeof STANDARD_VERTEX_SHADER;
+type index_ScreenshotOptions = ScreenshotOptions;
+type index_ShaderConnection = ShaderConnection;
+type index_ShaderDataType = ShaderDataType;
+type index_ShaderGraph = ShaderGraph;
+declare const index_ShaderGraph: typeof ShaderGraph;
+type index_ShaderNode = ShaderNode;
+type index_ShaderNodeDef = ShaderNodeDef;
+type index_ShaderPort = ShaderPort;
+type index_ShaderPortRef = ShaderPortRef;
+type index_ShaderUniform = ShaderUniform;
+type index_SheenConfig = SheenConfig;
+type index_TAAConfig = TAAConfig;
+type index_Texture2D = Texture2D;
+type index_TextureFormat = TextureFormat;
+type index_TextureSlot = TextureSlot;
+type index_ToneMapper = ToneMapper;
+type index_TonemapOperator = TonemapOperator;
+type index_Triangle = Triangle;
+declare const index_UNLIT_FRAGMENT_SHADER: typeof UNLIT_FRAGMENT_SHADER;
+declare const index_UNLIT_VERTEX_SHADER: typeof UNLIT_VERTEX_SHADER;
+type index_UniformDef = UniformDef;
+type index_UniformType = UniformType;
+type index_VolumetricLight = VolumetricLight;
+declare const index_VolumetricLight: typeof VolumetricLight;
+type index_VolumetricLightConfig = VolumetricLightConfig;
+type index_VolumetricSample = VolumetricSample;
+type index_WebGPURenderer = WebGPURenderer;
+declare const index_WebGPURenderer: typeof WebGPURenderer;
+declare const index_aabbCentroid: typeof aabbCentroid;
+declare const index_aabbSurfaceArea: typeof aabbSurfaceArea;
+declare const index_addSHSample: typeof addSHSample;
+declare const index_anisotropicRoughness: typeof anisotropicRoughness;
+declare const index_applyChromaticAberration: typeof applyChromaticAberration;
+declare const index_applyDOF: typeof applyDOF;
+declare const index_applyDetailAlbedo: typeof applyDetailAlbedo;
+declare const index_applyFilmGrain: typeof applyFilmGrain;
+declare const index_applyMotionBlur: typeof applyMotionBlur;
+declare const index_applyVignette: typeof applyVignette;
+declare const index_blendDetailNormal: typeof blendDetailNormal;
+declare const index_blendTAA: typeof blendTAA;
+declare const index_buildCircleCookie: typeof buildCircleCookie;
+declare const index_buildSeparableSSSKernel: typeof buildSeparableSSSKernel;
+declare const index_burleyProfile: typeof burleyProfile;
+declare const index_burleyProfileRGB: typeof burleyProfileRGB;
+declare const index_christensenProfile: typeof christensenProfile;
+declare const index_computeAABB: typeof computeAABB;
+declare const index_computeCoC: typeof computeCoC;
+declare const index_computeDiffuseAlbedo: typeof computeDiffuseAlbedo;
+declare const index_computeDisplacedPosition: typeof computeDisplacedPosition;
+declare const index_computeDisplacementNormalsFromHeightMap: typeof computeDisplacementNormalsFromHeightMap;
+declare const index_computeF0: typeof computeF0;
+declare const index_computePOM: typeof computePOM;
+declare const index_computeSSAO: typeof computeSSAO;
+declare const index_computeSSGI: typeof computeSSGI;
+declare const index_computeSSR: typeof computeSSR;
+declare const index_computeTriangleNormal: typeof computeTriangleNormal;
+declare const index_createAtlasPacker: typeof createAtlasPacker;
+declare const index_createDefaultMaterialDef: typeof createDefaultMaterialDef;
+declare const index_createSH9: typeof createSH9;
+declare const index_createSolidTexture: typeof createSolidTexture;
+declare const index_diskSolidAngle: typeof diskSolidAngle;
+declare const index_distributionGGX: typeof distributionGGX;
+declare const index_distributionGGXAnisotropic: typeof distributionGGXAnisotropic;
+declare const index_evalSH9Irradiance: typeof evalSH9Irradiance;
+declare const index_evalSeparableKernel: typeof evalSeparableKernel;
+declare const index_evaluateClearcoat: typeof evaluateClearcoat;
+declare const index_evaluateIridescence: typeof evaluateIridescence;
+declare const index_evaluateSheen: typeof evaluateSheen;
+declare const index_fresnelRoughness: typeof fresnelRoughness;
+declare const index_fresnelSchlick: typeof fresnelSchlick;
+declare const index_geometrySmith: typeof geometrySmith;
+declare const index_getAtlasEfficiency: typeof getAtlasEfficiency;
+declare const index_getRectUV: typeof getRectUV;
+declare const index_haltonJitter: typeof haltonJitter;
+declare const index_hexToRGBA: typeof hexToRGBA;
+declare const index_intersectRayAABB: typeof intersectRayAABB;
+declare const index_intersectRayTriangle: typeof intersectRayTriangle;
+declare const index_lerpSH9: typeof lerpSH9;
+declare const index_nlmDenoise: typeof nlmDenoise;
+declare const index_packRect: typeof packRect;
+declare const index_parseIESProfile: typeof parseIESProfile;
+declare const index_pathTrace: typeof pathTrace;
+declare const index_prerenderHTML: typeof prerenderHTML;
+declare const index_rectSolidAngle: typeof rectSolidAngle;
+declare const index_renderPDF: typeof renderPDF;
+declare const index_renderScreenshot: typeof renderScreenshot;
+declare const index_rgbaToHex: typeof rgbaToHex;
+declare const index_sampleCookie: typeof sampleCookie;
+declare const index_sampleIES: typeof sampleIES;
+declare const index_sampleTexture: typeof sampleTexture;
+declare const index_sampleTextureBilinear: typeof sampleTextureBilinear;
+declare const index_sampleTriplanar: typeof sampleTriplanar;
+declare const index_scaleSH9: typeof scaleSH9;
+declare const index_sheenDistribution: typeof sheenDistribution;
+declare const index_sheenVisibility: typeof sheenVisibility;
+declare const index_thinSlabTransmission: typeof thinSlabTransmission;
+declare const index_triplanarWeights: typeof triplanarWeights;
+declare namespace index {
+  export { type index_AABB as AABB, MATERIAL_PRESETS$1 as ADVANCED_PBR_PRESETS, type index_AdvancedLight as AdvancedLight, type LightType$1 as AdvancedLightingLightType, index_AdvancedLightingManager as AdvancedLightingManager, type Vec2$1 as AdvancedLightingVec2, type Vec3$4 as AdvancedLightingVec3, type index_AdvancedPBRConfig as AdvancedPBRConfig, index_AdvancedPBRMaterial as AdvancedPBRMaterial, type Vec3$3 as AdvancedPBRVec3, type Vec2 as AdvancedTexturingVec2, type Vec3$2 as AdvancedTexturingVec3, type index_AmbientConfig as AmbientConfig, type index_AnimationFrameOptions as AnimationFrameOptions, type index_AnisotropyConfig as AnisotropyConfig, type index_AreaLightConfig as AreaLightConfig, type index_AreaLightShape as AreaLightShape, type index_AtlasPacker as AtlasPacker, type index_AtlasRect as AtlasRect, type index_AttachmentFormat as AttachmentFormat, index_BVH as BVH, type index_BVHNode as BVHNode, type index_BatchStats as BatchStats, type BlendMode$2 as BlendMode, type index_BloomConfig as BloomConfig, BloomEffect$1 as BloomEffect, type index_CausticConfig as CausticConfig, type index_ChromaticAberrationConfig as ChromaticAberrationConfig, type index_ClearOp as ClearOp, type index_ClearcoatConfig as ClearcoatConfig, type index_CloudConfig as CloudConfig, index_CloudRenderer as CloudRenderer, type index_CloudSample as CloudSample, index_ColorGrading as ColorGrading, type index_ColorGradingConfig as ColorGradingConfig, type index_CompiledShader as CompiledShader, type CullMode$1 as CullMode, type index_DOFConfig as DOFConfig, index_DecalBatcher as DecalBatcher, type index_DecalDef as DecalDef, type index_DecalInstance as DecalInstance, index_DecalSystem as DecalSystem, type index_DetailMapConfig as DetailMapConfig, type index_DisplacementConfig as DisplacementConfig, type index_DrawBatch as DrawBatch, type index_FogConfig as FogConfig, type index_FogMode as FogMode, index_FogSystem as FogSystem, type index_FramebufferAttachment as FramebufferAttachment, type index_GIConfig as GIConfig, type index_GIMode as GIMode, type index_GIProbe as GIProbe, index_GIProbeGrid as GIProbeGrid, type Vec3$1 as GlobalIlluminationVec3, type index_GraphStats as GraphStats, type index_HitRecord as HitRecord, type index_IBlendComponent as IBlendComponent, type index_IBlendState as IBlendState, type index_IBoundingBox as IBoundingBox, type index_IBufferDescriptor as IBufferDescriptor, type index_ICameraUniforms as ICameraUniforms, type index_IColorTargetState as IColorTargetState, type index_IDepthStencilState as IDepthStencilState, type index_IDeviceCapabilities as IDeviceCapabilities, type index_IDrawCall as IDrawCall, type index_IESProfile as IESProfile, type index_IFrameStats as IFrameStats, type index_IGPUTexture as IGPUTexture, type index_IIndexBuffer as IIndexBuffer, type index_IRenderMaterial as IRenderMaterial, type index_IRenderMesh as IRenderMesh, type index_IRenderPassColorAttachment as IRenderPassColorAttachment, type index_IRenderPassDepthStencilAttachment as IRenderPassDepthStencilAttachment, type index_IRenderPassDescriptor as IRenderPassDescriptor, type index_IRenderPipelineDescriptor as IRenderPipelineDescriptor, type index_IRendererStats as IRendererStats, type index_ISamplerDescriptor as ISamplerDescriptor, type index_ISceneUniforms as ISceneUniforms, type index_IShaderModule as IShaderModule, type index_ITextureDescriptor as ITextureDescriptor, type index_IUniformBuffer as IUniformBuffer, type index_IVertexAttribute as IVertexAttribute, type index_IVertexBuffer as IVertexBuffer, type index_IVertexBufferLayout as IVertexBufferLayout, type index_IWebGPUContext as IWebGPUContext, type index_IWebGPUInitOptions as IWebGPUInitOptions, type index_IridescenceConfig as IridescenceConfig, type index_Light as Light, type index_LightCookie as LightCookie, type index_LightType as LightType, index_LightingModel as LightingModel, type index_MaterialDef as MaterialDef, type index_MaterialInstance as MaterialInstance, index_MaterialLibrary as MaterialLibrary, index_MaterialSystem as MaterialSystem, type BlendMode$1 as MaterialSystemBlendMode, type CullMode as MaterialSystemCullMode, type Material as MaterialSystemMaterial, type index_MotionBlurConfig as MotionBlurConfig, type index_NLMConfig as NLMConfig, type index_PDFOptions as PDFOptions, type index_POMConfig as POMConfig, index_PP_PRESETS as PP_PRESETS, type index_PassContext as PassContext, type index_PathTracerScene as PathTracerScene, index_PhysicsDebugDrawer as PhysicsDebugDrawer, type index_PixelBuffer as PixelBuffer, index$1 as PostProcess, type PostProcessEffect$1 as PostProcessEffect, type index_PostProcessProfile as PostProcessProfile, index_PostProcessStack as PostProcessStack, index_PostProcessingStack as PostProcessingStack, type index_PrerenderOptions as PrerenderOptions, type index_ProbeInfo as ProbeInfo, type index_ProjectorConfig as ProjectorConfig, index_ProjectorLight as ProjectorLight, index_PuppeteerRenderer as PuppeteerRenderer, type index_PuppeteerRendererOptions as PuppeteerRendererOptions, MATERIAL_PRESETS as RENDERING_MATERIAL_PRESETS, type RGB$1 as RGB, type index_RTApi as RTApi, type index_RTFeature as RTFeature, type index_Ray as Ray, index_RayTracer as RayTracer, type index_RayTracingConfig as RayTracingConfig, type Vec3 as RayTracingVec3, index_RenderGraph as RenderGraph, index_RenderPass as RenderPass, type index_RenderPassConfig as RenderPassConfig, type index_RenderPassDescriptor as RenderPassDescriptor, type index_RenderResult as RenderResult, type index_RenderTarget as RenderTarget, type MaterialType as RenderingMaterialType, type index_SH9 as SH9, index_SHADER_NODES as SHADER_NODES, type index_SSAOConfig as SSAOConfig, type index_SSGIConfig as SSGIConfig, type index_SSRConfig as SSRConfig, type index_SSSConfig as SSSConfig, type index_SSSLayer as SSSLayer, index_SSSMaterial as SSSMaterial, type index_SSSModel as SSSModel, type RGB as SSSRGB, index_SSS_PRESETS as SSS_PRESETS, index_STANDARD_FRAGMENT_SHADER as STANDARD_FRAGMENT_SHADER, index_STANDARD_VERTEX_SHADER as STANDARD_VERTEX_SHADER, type index_ScreenshotOptions as ScreenshotOptions, type index_ShaderConnection as ShaderConnection, type index_ShaderDataType as ShaderDataType, index_ShaderGraph as ShaderGraph, type index_ShaderNode as ShaderNode, type index_ShaderNodeDef as ShaderNodeDef, type index_ShaderPort as ShaderPort, type index_ShaderPortRef as ShaderPortRef, type index_ShaderUniform as ShaderUniform, type index_SheenConfig as SheenConfig, type index_TAAConfig as TAAConfig, type index_Texture2D as Texture2D, type index_TextureFormat as TextureFormat, type index_TextureSlot as TextureSlot, type index_ToneMapper as ToneMapper, type index_TonemapOperator as TonemapOperator, type index_Triangle as Triangle, index_UNLIT_FRAGMENT_SHADER as UNLIT_FRAGMENT_SHADER, index_UNLIT_VERTEX_SHADER as UNLIT_VERTEX_SHADER, type index_UniformDef as UniformDef, type index_UniformType as UniformType, index_VolumetricLight as VolumetricLight, type index_VolumetricLightConfig as VolumetricLightConfig, type index_VolumetricSample as VolumetricSample, index_WebGPURenderer as WebGPURenderer, index_aabbCentroid as aabbCentroid, index_aabbSurfaceArea as aabbSurfaceArea, index_addSHSample as addSHSample, index_anisotropicRoughness as anisotropicRoughness, index_applyChromaticAberration as applyChromaticAberration, index_applyDOF as applyDOF, index_applyDetailAlbedo as applyDetailAlbedo, index_applyFilmGrain as applyFilmGrain, index_applyMotionBlur as applyMotionBlur, index_applyVignette as applyVignette, index_blendDetailNormal as blendDetailNormal, index_blendTAA as blendTAA, index_buildCircleCookie as buildCircleCookie, index_buildSeparableSSSKernel as buildSeparableSSSKernel, index_burleyProfile as burleyProfile, index_burleyProfileRGB as burleyProfileRGB, index_christensenProfile as christensenProfile, index_computeAABB as computeAABB, index_computeCoC as computeCoC, index_computeDiffuseAlbedo as computeDiffuseAlbedo, index_computeDisplacedPosition as computeDisplacedPosition, index_computeDisplacementNormalsFromHeightMap as computeDisplacementNormalsFromHeightMap, index_computeF0 as computeF0, index_computePOM as computePOM, index_computeSSAO as computeSSAO, index_computeSSGI as computeSSGI, index_computeSSR as computeSSR, index_computeTriangleNormal as computeTriangleNormal, index_createAtlasPacker as createAtlasPacker, index_createDefaultMaterialDef as createDefaultMaterialDef, index_createSH9 as createSH9, index_createSolidTexture as createSolidTexture, index_diskSolidAngle as diskSolidAngle, index_distributionGGX as distributionGGX, index_distributionGGXAnisotropic as distributionGGXAnisotropic, index_evalSH9Irradiance as evalSH9Irradiance, index_evalSeparableKernel as evalSeparableKernel, index_evaluateClearcoat as evaluateClearcoat, index_evaluateIridescence as evaluateIridescence, index_evaluateSheen as evaluateSheen, index_fresnelRoughness as fresnelRoughness, index_fresnelSchlick as fresnelSchlick, index_geometrySmith as geometrySmith, index_getAtlasEfficiency as getAtlasEfficiency, index_getRectUV as getRectUV, index_haltonJitter as haltonJitter, index_hexToRGBA as hexToRGBA, index_intersectRayAABB as intersectRayAABB, index_intersectRayTriangle as intersectRayTriangle, index_lerpSH9 as lerpSH9, index_nlmDenoise as nlmDenoise, index_packRect as packRect, index_parseIESProfile as parseIESProfile, index_pathTrace as pathTrace, index_prerenderHTML as prerenderHTML, index_rectSolidAngle as rectSolidAngle, index_renderPDF as renderPDF, index_renderScreenshot as renderScreenshot, index_rgbaToHex as rgbaToHex, index_sampleCookie as sampleCookie, index_sampleIES as sampleIES, index_sampleTexture as sampleTexture, index_sampleTextureBilinear as sampleTextureBilinear, index_sampleTriplanar as sampleTriplanar, index_scaleSH9 as scaleSH9, index_sheenDistribution as sheenDistribution, index_sheenVisibility as sheenVisibility, index_thinSlabTransmission as thinSlabTransmission, index_triplanarWeights as triplanarWeights };
+}
+
+export { type Vec3$1 as $, type AABB as A, BVH as B, type CausticConfig as C, type CloudSample as D, ColorGrading as E, type ColorGradingConfig as F, type CompiledShader as G, type CullMode$1 as H, type DOFConfig as I, DecalBatcher as J, type DecalDef as K, type LightType$1 as L, MATERIAL_PRESETS$1 as M, type DecalInstance as N, DecalSystem as O, type DetailMapConfig as P, type DisplacementConfig as Q, type DrawBatch as R, type FogConfig as S, type FogMode as T, FogSystem as U, type Vec2$1 as V, type FramebufferAttachment as W, type GIConfig as X, type GIMode as Y, type GIProbe as Z, GIProbeGrid as _, type AdvancedLight as a, type PuppeteerRendererOptions as a$, type GraphStats as a0, type HitRecord as a1, type IBlendComponent as a2, type IBlendState as a3, type IBoundingBox as a4, type IBufferDescriptor as a5, type ICameraUniforms as a6, type IColorTargetState as a7, type IDepthStencilState as a8, type IDeviceCapabilities as a9, LightingModel as aA, type MaterialDef as aB, type MaterialInstance as aC, MaterialLibrary as aD, MaterialSystem as aE, type BlendMode$1 as aF, type CullMode as aG, type Material as aH, type MotionBlurConfig as aI, type NLMConfig as aJ, type PDFOptions as aK, type POMConfig as aL, PP_PRESETS as aM, type PassContext as aN, type PathTracerScene as aO, PhysicsDebugDrawer as aP, type PixelBuffer as aQ, index$1 as aR, type PostProcessEffect$1 as aS, type PostProcessProfile as aT, PostProcessStack as aU, PostProcessingStack as aV, type PrerenderOptions as aW, type ProbeInfo as aX, type ProjectorConfig as aY, ProjectorLight as aZ, PuppeteerRenderer as a_, type IDrawCall as aa, type IESProfile as ab, type IFrameStats as ac, type IGPUTexture as ad, type IIndexBuffer as ae, type IRenderMaterial as af, type IRenderMesh as ag, type IRenderPassColorAttachment as ah, type IRenderPassDepthStencilAttachment as ai, type IRenderPassDescriptor as aj, type IRenderPipelineDescriptor as ak, type IRendererStats as al, type ISamplerDescriptor as am, type ISceneUniforms as an, type IShaderModule as ao, type ITextureDescriptor as ap, type IUniformBuffer as aq, type IVertexAttribute as ar, type IVertexBuffer as as, type IVertexBufferLayout as at, type IWebGPUContext as au, type IWebGPUInitOptions as av, type IridescenceConfig as aw, type Light as ax, type LightCookie as ay, type LightType as az, AdvancedLightingManager as b, applyVignette as b$, MATERIAL_PRESETS as b0, type RGB$1 as b1, type RTApi as b2, type RTFeature as b3, type Ray as b4, RayTracer as b5, type RayTracingConfig as b6, type Vec3 as b7, RenderGraph as b8, RenderPass as b9, type ShaderPortRef as bA, type ShaderUniform as bB, type SheenConfig as bC, type TAAConfig as bD, type Texture2D as bE, type TextureFormat as bF, type TextureSlot as bG, type ToneMapper as bH, type TonemapOperator as bI, type Triangle as bJ, UNLIT_FRAGMENT_SHADER as bK, UNLIT_VERTEX_SHADER as bL, type UniformDef as bM, type UniformType as bN, VolumetricLight as bO, type VolumetricLightConfig as bP, type VolumetricSample as bQ, WebGPURenderer as bR, aabbCentroid as bS, aabbSurfaceArea as bT, addSHSample as bU, anisotropicRoughness as bV, applyChromaticAberration as bW, applyDOF as bX, applyDetailAlbedo as bY, applyFilmGrain as bZ, applyMotionBlur as b_, type RenderPassConfig as ba, type RenderPassDescriptor as bb, type RenderResult as bc, type RenderTarget as bd, index as be, type MaterialType as bf, type SH9 as bg, SHADER_NODES as bh, type SSAOConfig as bi, type SSGIConfig as bj, type SSRConfig as bk, type SSSConfig as bl, type SSSLayer as bm, SSSMaterial as bn, type SSSModel as bo, type RGB as bp, SSS_PRESETS as bq, STANDARD_FRAGMENT_SHADER as br, STANDARD_VERTEX_SHADER as bs, type ScreenshotOptions as bt, type ShaderConnection as bu, type ShaderDataType as bv, ShaderGraph as bw, type ShaderNode as bx, type ShaderNodeDef as by, type ShaderPort as bz, type Vec3$4 as c, blendDetailNormal as c0, blendTAA as c1, buildCircleCookie as c2, buildSeparableSSSKernel as c3, burleyProfile as c4, burleyProfileRGB as c5, christensenProfile as c6, computeAABB as c7, computeCoC as c8, computeDiffuseAlbedo as c9, hexToRGBA as cA, intersectRayAABB as cB, intersectRayTriangle as cC, lerpSH9 as cD, nlmDenoise as cE, packRect as cF, parseIESProfile as cG, pathTrace as cH, prerenderHTML as cI, rectSolidAngle as cJ, renderPDF as cK, renderScreenshot as cL, rgbaToHex as cM, sampleCookie as cN, sampleIES as cO, sampleTexture as cP, sampleTextureBilinear as cQ, sampleTriplanar as cR, scaleSH9 as cS, sheenDistribution as cT, sheenVisibility as cU, thinSlabTransmission as cV, triplanarWeights as cW, computeDisplacedPosition as ca, computeDisplacementNormalsFromHeightMap as cb, computeF0 as cc, computePOM as cd, computeSSAO as ce, computeSSGI as cf, computeSSR as cg, computeTriangleNormal as ch, createAtlasPacker as ci, createDefaultMaterialDef as cj, createSH9 as ck, createSolidTexture as cl, diskSolidAngle as cm, distributionGGX as cn, distributionGGXAnisotropic as co, evalSH9Irradiance as cp, evalSeparableKernel as cq, evaluateClearcoat as cr, evaluateIridescence as cs, evaluateSheen as ct, fresnelRoughness as cu, fresnelSchlick as cv, geometrySmith as cw, getAtlasEfficiency as cx, getRectUV as cy, haltonJitter as cz, type AdvancedPBRConfig as d, AdvancedPBRMaterial as e, type Vec3$3 as f, type Vec2 as g, type Vec3$2 as h, type AmbientConfig as i, type AnimationFrameOptions as j, type AnisotropyConfig as k, type AreaLightConfig as l, type AreaLightShape as m, type AtlasPacker as n, type AtlasRect as o, type AttachmentFormat as p, type BVHNode as q, type BatchStats as r, type BlendMode$2 as s, type BloomConfig as t, BloomEffect$1 as u, type ChromaticAberrationConfig as v, type ClearOp as w, type ClearcoatConfig as x, type CloudConfig as y, CloudRenderer as z };