@holoscript/engine 6.0.3 → 6.0.4

package/dist/index-BQutTphC.d.cts

@@ -0,0 +1,790 @@
+import { I as IVector3 } from './PhysicsTypes-Dw6_oXuD.cjs';
+
+/**
+ * DayNightCycle.ts
+ *
+ * Time of day simulation: sun/moon position, ambient lighting,
+ * time scale control, and time-based events.
+ *
+ * @module environment
+ */
+type TimeOfDay = 'dawn' | 'morning' | 'noon' | 'afternoon' | 'dusk' | 'evening' | 'night' | 'midnight';
+interface DayNightState {
+    time: number;
+    sunAngle: number;
+    moonAngle: number;
+    sunIntensity: number;
+    moonIntensity: number;
+    ambientColor: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    ambientIntensity: number;
+    period: TimeOfDay;
+    dayCount: number;
+}
+declare class DayNightCycle {
+    private time;
+    private timeScale;
+    private dayCount;
+    private paused;
+    private listeners;
+    private lastPeriod;
+    setTime(hours: number): void;
+    setTimeScale(scale: number): void;
+    getTimeScale(): number;
+    pause(): void;
+    resume(): void;
+    isPaused(): boolean;
+    update(dt: number): void;
+    getSunAngle(): number;
+    getMoonAngle(): number;
+    getSunIntensity(): number;
+    getMoonIntensity(): number;
+    getAmbientColor(): {
+        r: number;
+        g: number;
+        b: number;
+    };
+    getPeriod(): TimeOfDay;
+    onPeriodChange(listener: (period: TimeOfDay, state: DayNightState) => void): void;
+    getTime(): number;
+    getDayCount(): number;
+    getState(): DayNightState;
+    getFormattedTime(): string;
+}
+
+/**
+ * EnvironmentPresets.ts
+ *
+ * Pre-built environment configurations for skybox, lighting, fog, and atmosphere.
+ * Provides time-of-day and weather systems.
+ *
+ * @module environment
+ */
+
+interface SkyboxConfig {
+    type: 'color' | 'gradient' | 'hdri' | 'procedural';
+    topColor: string;
+    bottomColor: string;
+    horizonColor?: string;
+    hdriAsset?: string;
+    turbidity?: number;
+    rayleigh?: number;
+    sunPosition?: IVector3;
+}
+interface LightConfig {
+    type: 'directional' | 'ambient' | 'point' | 'spot';
+    color: string;
+    intensity: number;
+    direction?: IVector3;
+    position?: IVector3;
+    castShadows?: boolean;
+    shadowMapSize?: number;
+}
+interface FogConfig {
+    type: 'none' | 'linear' | 'exponential' | 'exponential2';
+    color: string;
+    near?: number;
+    far?: number;
+    density?: number;
+}
+interface AtmosphereConfig {
+    ambientOcclusion: boolean;
+    bloom: boolean;
+    bloomIntensity: number;
+    bloomThreshold: number;
+    toneMappingExposure: number;
+    colorGrading?: {
+        saturation: number;
+        contrast: number;
+        temperature: number;
+    };
+}
+interface EnvironmentConfig {
+    id: string;
+    name: string;
+    skybox: SkyboxConfig;
+    lights: LightConfig[];
+    fog: FogConfig;
+    atmosphere: AtmosphereConfig;
+}
+interface TimeOfDayConfig {
+    sunriseHour: number;
+    sunsetHour: number;
+    currentHour: number;
+    daySpeed: number;
+}
+interface WeatherState$1 {
+    type: 'clear' | 'cloudy' | 'rain' | 'storm' | 'snow' | 'fog';
+    intensity: number;
+    windDirection: IVector3;
+    windSpeed: number;
+    transitionProgress: number;
+}
+declare const PRESET_SUNNY_DAY: EnvironmentConfig;
+declare const PRESET_SUNSET: EnvironmentConfig;
+declare const PRESET_NIGHT: EnvironmentConfig;
+declare const PRESET_OVERCAST: EnvironmentConfig;
+declare const PRESET_SCIFI: EnvironmentConfig;
+declare const ALL_PRESETS: EnvironmentConfig[];
+declare class EnvironmentManager {
+    private currentEnv;
+    private timeOfDay;
+    private weather;
+    constructor(preset?: EnvironmentConfig);
+    setEnvironment(config: EnvironmentConfig): void;
+    getEnvironment(): EnvironmentConfig;
+    setPreset(presetId: string): boolean;
+    getPresetIds(): string[];
+    setTimeOfDay(hour: number): void;
+    advanceTime(deltaSeconds: number): void;
+    getTimeOfDay(): TimeOfDayConfig;
+    private updateSunFromTime;
+    setWeather(type: WeatherState$1['type'], intensity?: number): void;
+    getWeather(): WeatherState$1;
+    updateWeatherTransition(dt: number): void;
+}
+
+/**
+ * FoliageSystem.ts
+ *
+ * Instance-based foliage: scattering, density maps,
+ * wind sway animation, LOD, and culling.
+ *
+ * @module environment
+ */
+interface FoliageType {
+    id: string;
+    meshId: string;
+    density: number;
+    minScale: number;
+    maxScale: number;
+    alignToNormal: boolean;
+    windResponse: number;
+    castsShadow: boolean;
+    lodDistances: number[];
+}
+interface FoliageInstance {
+    typeId: string;
+    position: [number, number, number];
+    scale: number;
+    rotation: number;
+    windPhase: number;
+    lodLevel: number;
+    visible: boolean;
+}
+interface FoliagePatch {
+    id: string;
+    bounds: {
+        x: number;
+        z: number;
+        w: number;
+        h: number;
+    };
+    instances: FoliageInstance[];
+    density: number;
+}
+declare class FoliageSystem {
+    private types;
+    private patches;
+    private windDir;
+    private windStrength;
+    private time;
+    registerType(type: FoliageType): void;
+    getType(id: string): FoliageType | undefined;
+    getTypeCount(): number;
+    setWind(dirX: number, dirZ: number, strength: number): void;
+    getWind(): {
+        dirX: number;
+        dirZ: number;
+        strength: number;
+    };
+    scatter(patchId: string, typeId: string, bounds: FoliagePatch['bounds'], count: number, seed?: number): FoliagePatch;
+    update(dt: number, cameraPos: {
+        x: number;
+        z: number;
+    }): void;
+    getWindOffset(inst: FoliageInstance): {
+        x: number;
+        z: number;
+    };
+    getPatch(id: string): FoliagePatch | undefined;
+    getPatchCount(): number;
+    getVisibleCount(): number;
+    getTotalInstanceCount(): number;
+    removePatch(id: string): boolean;
+}
+
+/**
+ * GrassRenderer.ts
+ *
+ * Grass blade generation: procedural blade mesh,
+ * LOD with billboarding, color variation, and density control.
+ *
+ * @module environment
+ */
+interface GrassBlade {
+    position: [number, number, number];
+    height: number;
+    width: number;
+    bendFactor: number;
+    color: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    lodLevel: number;
+    isBillboard: boolean;
+}
+interface GrassConfig {
+    baseHeight: number;
+    heightVariation: number;
+    baseWidth: number;
+    widthVariation: number;
+    baseColor: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    tipColor: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    colorVariation: number;
+    billboardDistance: number;
+    cullDistance: number;
+    bendRange: number;
+    bladesPerUnit: number;
+}
+declare class GrassRenderer {
+    private config;
+    private blades;
+    constructor(config?: Partial<GrassConfig>);
+    generate(bounds: {
+        x: number;
+        z: number;
+        w: number;
+        h: number;
+    }, seed?: number): void;
+    updateLOD(cameraPos: {
+        x: number;
+        z: number;
+    }): void;
+    getBladeCount(): number;
+    getVisibleBlades(): GrassBlade[];
+    getBillboardCount(): number;
+    getConfig(): GrassConfig;
+    setConfig(config: Partial<GrassConfig>): void;
+}
+
+/**
+ * SkyRenderer.ts
+ *
+ * Procedural sky: gradient colors, star field, cloud layers,
+ * sun/moon discs, and atmospheric scattering approximation.
+ *
+ * @module environment
+ */
+interface SkyGradient {
+    top: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    horizon: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    bottom: {
+        r: number;
+        g: number;
+        b: number;
+    };
+}
+interface StarField {
+    seed: number;
+    density: number;
+    brightness: number;
+    twinkleSpeed: number;
+}
+interface CloudLayer {
+    id: string;
+    altitude: number;
+    coverage: number;
+    speed: {
+        x: number;
+        z: number;
+    };
+    color: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    scale: number;
+    offset: {
+        x: number;
+        z: number;
+    };
+}
+interface CelestialBody {
+    visible: boolean;
+    angle: number;
+    size: number;
+    color: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    intensity: number;
+}
+declare class SkyRenderer {
+    private gradient;
+    private stars;
+    private clouds;
+    private sun;
+    private moon;
+    private moonPhase;
+    private starsVisible;
+    setGradient(gradient: SkyGradient): void;
+    getGradient(): SkyGradient;
+    sampleGradient(t: number): {
+        r: number;
+        g: number;
+        b: number;
+    };
+    private lerpColor;
+    setStarField(config: Partial<StarField>): void;
+    setStarsVisible(visible: boolean): void;
+    areStarsVisible(): boolean;
+    getStarField(): StarField;
+    addCloudLayer(coverage: number, altitude?: number, speed?: {
+        x: number;
+        z: number;
+    }): CloudLayer;
+    removeCloudLayer(id: string): boolean;
+    getCloudLayers(): CloudLayer[];
+    getCloudCount(): number;
+    updateClouds(dt: number): void;
+    setSunAngle(angle: number): void;
+    setMoonAngle(angle: number): void;
+    setMoonPhase(phase: number): void;
+    getMoonPhase(): number;
+    getSun(): CelestialBody;
+    getMoon(): CelestialBody;
+    applyDaytime(): void;
+    applySunset(): void;
+    applyNight(): void;
+    getTotalCoverage(): number;
+}
+
+/**
+ * TerrainSystem.ts
+ *
+ * Heightmap-based terrain with procedural generation,
+ * LOD meshing, and physics collision support.
+ *
+ * @module environment
+ */
+
+interface TerrainConfig {
+    id: string;
+    width: number;
+    depth: number;
+    resolution: number;
+    maxHeight: number;
+    position: IVector3;
+}
+interface TerrainLayer {
+    id: string;
+    texture: string;
+    tiling: number;
+    minHeight: number;
+    maxHeight: number;
+    minSlope: number;
+    maxSlope: number;
+}
+interface TerrainVertex {
+    position: IVector3;
+    normal: IVector3;
+    uv: {
+        u: number;
+        v: number;
+    };
+    height: number;
+}
+interface TerrainChunk {
+    x: number;
+    z: number;
+    lod: number;
+    vertices: TerrainVertex[];
+    indices: number[];
+}
+interface TerrainCollider {
+    getHeightAt(worldX: number, worldZ: number): number;
+    getNormalAt(worldX: number, worldZ: number): IVector3;
+}
+declare class TerrainSystem {
+    private terrains;
+    /**
+     * Create a terrain with a procedurally generated heightmap.
+     */
+    createTerrain(config: TerrainConfig, options?: {
+        octaves?: number;
+        lacunarity?: number;
+        gain?: number;
+        seed?: number;
+        scale?: number;
+    }): string;
+    /**
+     * Create terrain from an existing heightmap array.
+     */
+    createFromHeightmap(config: TerrainConfig, heightmap: Float32Array): string;
+    /**
+     * Get height at a world position (bilinear interpolation).
+     */
+    getHeightAt(terrainId: string, worldX: number, worldZ: number): number;
+    /**
+     * Get surface normal at a world position (finite differences).
+     */
+    getNormalAt(terrainId: string, worldX: number, worldZ: number): IVector3;
+    /**
+     * Set height at a specific grid position.
+     */
+    setHeightAt(terrainId: string, gridX: number, gridZ: number, height: number): void;
+    /**
+     * Get the collider interface for a terrain.
+     */
+    getCollider(terrainId: string): TerrainCollider | null;
+    setLayers(terrainId: string, layers: TerrainLayer[]): void;
+    getLayers(terrainId: string): TerrainLayer[];
+    getTerrain(id: string): {
+        config: TerrainConfig;
+        heightmap: Float32Array;
+        layers: TerrainLayer[];
+        chunks: TerrainChunk[];
+    } | undefined;
+    getTerrainIds(): string[];
+    removeTerrain(id: string): boolean;
+    getChunks(terrainId: string): TerrainChunk[];
+    private generateChunks;
+    private getDefaultLayers;
+}
+
+/**
+ * TerrainBrush.ts
+ *
+ * Editor tools for sculpting and painting terrain heightmaps.
+ * Supports raise, lower, flatten, smooth, and texture paint brushes.
+ *
+ * @module environment
+ */
+
+type BrushMode = 'raise' | 'lower' | 'flatten' | 'smooth' | 'paint';
+interface BrushConfig {
+    mode: BrushMode;
+    radius: number;
+    strength: number;
+    falloff: number;
+    flattenHeight?: number;
+    paintLayerId?: string;
+}
+interface BrushStroke {
+    terrainId: string;
+    gridX: number;
+    gridZ: number;
+    config: BrushConfig;
+    affectedCells: {
+        x: number;
+        z: number;
+        oldHeight: number;
+        newHeight: number;
+    }[];
+}
+declare class TerrainBrush {
+    private config;
+    private terrain;
+    private undoStack;
+    private redoStack;
+    constructor(terrain: TerrainSystem, config?: Partial<BrushConfig>);
+    setConfig(config: Partial<BrushConfig>): void;
+    getConfig(): BrushConfig;
+    setMode(mode: BrushMode): void;
+    setRadius(radius: number): void;
+    setStrength(strength: number): void;
+    /**
+     * Apply the brush at a grid position on a terrain.
+     */
+    apply(terrainId: string, gridX: number, gridZ: number): BrushStroke;
+    undo(): BrushStroke | null;
+    redo(): BrushStroke | null;
+    getUndoCount(): number;
+    getRedoCount(): number;
+}
+
+/**
+ * TreePlacer.ts
+ *
+ * Procedural tree placement: biome rules, collision avoidance,
+ * density control, and distribution patterns.
+ *
+ * @module environment
+ */
+interface TreeTemplate {
+    id: string;
+    meshId: string;
+    minScale: number;
+    maxScale: number;
+    trunkRadius: number;
+    biomes: string[];
+    probability: number;
+}
+interface PlacedTree {
+    id: string;
+    templateId: string;
+    position: [number, number, number];
+    scale: number;
+    rotation: number;
+}
+interface BiomeRule {
+    id: string;
+    name: string;
+    density: number;
+    minSpacing: number;
+    heightRange: {
+        min: number;
+        max: number;
+    };
+    slopeMax: number;
+}
+declare class TreePlacer {
+    private templates;
+    private biomes;
+    private trees;
+    addTemplate(template: TreeTemplate): void;
+    getTemplate(id: string): TreeTemplate | undefined;
+    getTemplateCount(): number;
+    addBiome(biome: BiomeRule): void;
+    getBiome(id: string): BiomeRule | undefined;
+    placeInRegion(biomeId: string, bounds: {
+        x: number;
+        z: number;
+        w: number;
+        h: number;
+    }, heightSampler?: (x: number, z: number) => number, slopeSampler?: (x: number, z: number) => number, seed?: number): PlacedTree[];
+    private checkSpacing;
+    private pickTemplate;
+    getPlacedCount(): number;
+    getAllTrees(): PlacedTree[];
+    getTreesInRadius(x: number, z: number, radius: number): PlacedTree[];
+    removeTree(id: string): boolean;
+    clear(): void;
+}
+
+/**
+ * WeatherBlackboard — Singleton shared state for @weather hub trait.
+ *
+ * The @weather trait owns this blackboard and writes to it each frame.
+ * Consumer traits (@volumetric_clouds, @cloth, @fluid, @physics, @erosion,
+ * @god_rays, @particle_system) read from it. This creates environmental
+ * coherence without trait-to-trait coupling.
+ *
+ * Pattern: P.GAPS.10 (Hub Trait Architecture)
+ *
+ * @module environment
+ */
+type PrecipitationType = 'none' | 'rain' | 'snow' | 'hail';
+interface WeatherBlackboardState {
+    /** Wind direction and magnitude as a 3D vector */
+    wind_vector: [number, number, number];
+    /** Precipitation intensity 0-1 */
+    precipitation: number;
+    /** Type of precipitation */
+    precipitation_type: PrecipitationType;
+    /** Ambient temperature in Celsius */
+    temperature: number;
+    /** Relative humidity 0-1 */
+    humidity: number;
+    /** Normalized sun direction vector (from surface toward sun) */
+    sun_position: [number, number, number];
+    /** Sun light intensity 0-1 (0 at night) */
+    sun_intensity: number;
+    /** Cloud coverage density 0-1 */
+    cloud_density: number;
+    /** Cloud layer altitude in meters */
+    cloud_altitude: number;
+    /** Fog density 0-1 */
+    fog_density: number;
+    /** Time of day in hours 0-24 (fractional) */
+    time_of_day: number;
+    /** True when sun_intensity < 0.1 */
+    is_night: boolean;
+    /** Accumulated surface moisture from rain 0-1 (decays when not raining) */
+    surface_wetness: number;
+    /** Wind speed (magnitude of wind_vector) */
+    wind_speed: number;
+    /** Visibility range in meters (affected by fog + precipitation) */
+    visibility_range: number;
+    /** Frame counter — incremented each @weather update */
+    frame: number;
+}
+/**
+ * Global weather blackboard.
+ *
+ * WRITE: Only the @weather hub trait should write to this.
+ * READ: Any consumer trait can read from this each frame.
+ *
+ * The blackboard is a plain object — reads are zero-cost.
+ * The @weather trait must run FIRST in the trait update loop
+ * so consumers see the latest state.
+ */
+declare const weatherBlackboard: WeatherBlackboardState;
+/**
+ * Update the blackboard with new values. Recomputes derived fields.
+ * Called by WeatherHubTrait.onUpdate() each frame.
+ */
+declare function updateWeatherBlackboard(partial: Partial<Omit<WeatherBlackboardState, 'is_night' | 'surface_wetness' | 'wind_speed' | 'visibility_range' | 'frame'>>): void;
+/**
+ * Reset blackboard to default state. Used in testing.
+ */
+declare function resetWeatherBlackboard(): void;
+/**
+ * Compute sun position from time of day and latitude.
+ *
+ * Returns normalized direction vector pointing from surface toward sun.
+ * At midnight (0/24), sun is directly below horizon.
+ * At noon (12), sun is at maximum elevation.
+ *
+ * @param timeOfDay - Hours 0-24
+ * @param latitude - Degrees, default 45 (mid-latitude)
+ * @returns [x, y, z] normalized sun direction
+ */
+declare function computeSunPosition(timeOfDay: number, latitude?: number): [number, number, number];
+/**
+ * Compute sun intensity from elevation angle.
+ * Smooth ramp: 0 at horizon, 1 at max elevation, with atmospheric scattering falloff.
+ */
+declare function computeSunIntensity(sunY: number): number;
+
+/**
+ * WeatherSystem.ts
+ *
+ * Dynamic weather: types, transitions, intensity,
+ * wind, and environmental effects.
+ *
+ * @module environment
+ */
+type WeatherType = 'clear' | 'cloudy' | 'rain' | 'storm' | 'snow' | 'fog' | 'sandstorm';
+interface WeatherState {
+    type: WeatherType;
+    intensity: number;
+    wind: {
+        x: number;
+        y: number;
+        z: number;
+        speed: number;
+    };
+    temperature: number;
+    humidity: number;
+    visibility: number;
+    precipitation: number;
+}
+interface WeatherTransition {
+    from: WeatherType;
+    to: WeatherType;
+    duration: number;
+    elapsed: number;
+}
+declare class WeatherSystem {
+    private current;
+    private transition;
+    private targetState;
+    private listeners;
+    private history;
+    constructor(initial?: WeatherType);
+    private createState;
+    setWeather(type: WeatherType, transitionDuration?: number): void;
+    setImmediate(type: WeatherType): void;
+    setWind(x: number, y: number, z: number, speed: number): void;
+    setTemperature(temp: number): void;
+    update(dt: number): void;
+    private lerp;
+    onChange(listener: (state: WeatherState) => void): void;
+    private notify;
+    getState(): WeatherState;
+    getType(): WeatherType;
+    isTransitioning(): boolean;
+    getTransitionProgress(): number;
+    getHistory(): typeof this.history;
+}
+
+declare const index_ALL_PRESETS: typeof ALL_PRESETS;
+type index_AtmosphereConfig = AtmosphereConfig;
+type index_BiomeRule = BiomeRule;
+type index_BrushConfig = BrushConfig;
+type index_BrushMode = BrushMode;
+type index_BrushStroke = BrushStroke;
+type index_CelestialBody = CelestialBody;
+type index_CloudLayer = CloudLayer;
+type index_DayNightCycle = DayNightCycle;
+declare const index_DayNightCycle: typeof DayNightCycle;
+type index_DayNightState = DayNightState;
+type index_EnvironmentConfig = EnvironmentConfig;
+type index_EnvironmentManager = EnvironmentManager;
+declare const index_EnvironmentManager: typeof EnvironmentManager;
+type index_FogConfig = FogConfig;
+type index_FoliageInstance = FoliageInstance;
+type index_FoliagePatch = FoliagePatch;
+type index_FoliageSystem = FoliageSystem;
+declare const index_FoliageSystem: typeof FoliageSystem;
+type index_FoliageType = FoliageType;
+type index_GrassBlade = GrassBlade;
+type index_GrassConfig = GrassConfig;
+type index_GrassRenderer = GrassRenderer;
+declare const index_GrassRenderer: typeof GrassRenderer;
+type index_LightConfig = LightConfig;
+declare const index_PRESET_NIGHT: typeof PRESET_NIGHT;
+declare const index_PRESET_OVERCAST: typeof PRESET_OVERCAST;
+declare const index_PRESET_SCIFI: typeof PRESET_SCIFI;
+declare const index_PRESET_SUNNY_DAY: typeof PRESET_SUNNY_DAY;
+declare const index_PRESET_SUNSET: typeof PRESET_SUNSET;
+type index_PlacedTree = PlacedTree;
+type index_PrecipitationType = PrecipitationType;
+type index_SkyGradient = SkyGradient;
+type index_SkyRenderer = SkyRenderer;
+declare const index_SkyRenderer: typeof SkyRenderer;
+type index_SkyboxConfig = SkyboxConfig;
+type index_StarField = StarField;
+type index_TerrainBrush = TerrainBrush;
+declare const index_TerrainBrush: typeof TerrainBrush;
+type index_TerrainChunk = TerrainChunk;
+type index_TerrainCollider = TerrainCollider;
+type index_TerrainConfig = TerrainConfig;
+type index_TerrainLayer = TerrainLayer;
+type index_TerrainSystem = TerrainSystem;
+declare const index_TerrainSystem: typeof TerrainSystem;
+type index_TerrainVertex = TerrainVertex;
+type index_TimeOfDay = TimeOfDay;
+type index_TimeOfDayConfig = TimeOfDayConfig;
+type index_TreePlacer = TreePlacer;
+declare const index_TreePlacer: typeof TreePlacer;
+type index_TreeTemplate = TreeTemplate;
+type index_WeatherBlackboardState = WeatherBlackboardState;
+type index_WeatherSystem = WeatherSystem;
+declare const index_WeatherSystem: typeof WeatherSystem;
+type index_WeatherTransition = WeatherTransition;
+type index_WeatherType = WeatherType;
+declare const index_computeSunIntensity: typeof computeSunIntensity;
+declare const index_computeSunPosition: typeof computeSunPosition;
+declare const index_resetWeatherBlackboard: typeof resetWeatherBlackboard;
+declare const index_updateWeatherBlackboard: typeof updateWeatherBlackboard;
+declare const index_weatherBlackboard: typeof weatherBlackboard;
+declare namespace index {
+  export { index_ALL_PRESETS as ALL_PRESETS, type index_AtmosphereConfig as AtmosphereConfig, type index_BiomeRule as BiomeRule, type index_BrushConfig as BrushConfig, type index_BrushMode as BrushMode, type index_BrushStroke as BrushStroke, type index_CelestialBody as CelestialBody, type index_CloudLayer as CloudLayer, index_DayNightCycle as DayNightCycle, type index_DayNightState as DayNightState, type index_EnvironmentConfig as EnvironmentConfig, index_EnvironmentManager as EnvironmentManager, type index_FogConfig as FogConfig, type index_FoliageInstance as FoliageInstance, type index_FoliagePatch as FoliagePatch, index_FoliageSystem as FoliageSystem, type index_FoliageType as FoliageType, type index_GrassBlade as GrassBlade, type index_GrassConfig as GrassConfig, index_GrassRenderer as GrassRenderer, type index_LightConfig as LightConfig, index_PRESET_NIGHT as PRESET_NIGHT, index_PRESET_OVERCAST as PRESET_OVERCAST, index_PRESET_SCIFI as PRESET_SCIFI, index_PRESET_SUNNY_DAY as PRESET_SUNNY_DAY, index_PRESET_SUNSET as PRESET_SUNSET, type index_PlacedTree as PlacedTree, type index_PrecipitationType as PrecipitationType, type WeatherState$1 as PresetWeatherState, type index_SkyGradient as SkyGradient, index_SkyRenderer as SkyRenderer, type index_SkyboxConfig as SkyboxConfig, type index_StarField as StarField, type WeatherState as SystemWeatherState, index_TerrainBrush as TerrainBrush, type index_TerrainChunk as TerrainChunk, type index_TerrainCollider as TerrainCollider, type index_TerrainConfig as TerrainConfig, type index_TerrainLayer as TerrainLayer, index_TerrainSystem as TerrainSystem, type index_TerrainVertex as TerrainVertex, type index_TimeOfDay as TimeOfDay, type index_TimeOfDayConfig as TimeOfDayConfig, index_TreePlacer as TreePlacer, type index_TreeTemplate as TreeTemplate, type index_WeatherBlackboardState as WeatherBlackboardState, index_WeatherSystem as WeatherSystem, type index_WeatherTransition as WeatherTransition, type index_WeatherType as WeatherType, index_computeSunIntensity as computeSunIntensity, index_computeSunPosition as computeSunPosition, index_resetWeatherBlackboard as resetWeatherBlackboard, index_updateWeatherBlackboard as updateWeatherBlackboard, index_weatherBlackboard as weatherBlackboard };
+}
+
+export { updateWeatherBlackboard as $, ALL_PRESETS as A, type BiomeRule as B, type CelestialBody as C, DayNightCycle as D, type EnvironmentConfig as E, type FogConfig as F, type GrassBlade as G, type TerrainConfig as H, type TerrainLayer as I, TerrainSystem as J, type TerrainVertex as K, type LightConfig as L, type TimeOfDay as M, type TimeOfDayConfig as N, TreePlacer as O, PRESET_NIGHT as P, type TreeTemplate as Q, type WeatherBlackboardState as R, type SkyGradient as S, TerrainBrush as T, WeatherSystem as U, type WeatherTransition as V, type WeatherState$1 as W, type WeatherType as X, computeSunIntensity as Y, computeSunPosition as Z, resetWeatherBlackboard as _, type AtmosphereConfig as a, weatherBlackboard as a0, type BrushConfig as b, type BrushMode as c, type BrushStroke as d, type CloudLayer as e, type DayNightState as f, EnvironmentManager as g, type FoliageInstance as h, index as i, type FoliagePatch as j, FoliageSystem as k, type FoliageType as l, type GrassConfig as m, GrassRenderer as n, PRESET_OVERCAST as o, PRESET_SCIFI as p, PRESET_SUNNY_DAY as q, PRESET_SUNSET as r, type PlacedTree as s, type PrecipitationType as t, SkyRenderer as u, type SkyboxConfig as v, type StarField as w, type WeatherState as x, type TerrainChunk as y, type TerrainCollider as z };