@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-EDRVQHUU.js

@@ -0,0 +1,1544 @@
+import {
+  __export
+} from "./chunk-AKLW2MUS.js";
+
+// src/environment/index.ts
+var environment_exports = {};
+__export(environment_exports, {
+  ALL_PRESETS: () => ALL_PRESETS,
+  DayNightCycle: () => DayNightCycle,
+  EnvironmentManager: () => EnvironmentManager,
+  FoliageSystem: () => FoliageSystem,
+  GrassRenderer: () => GrassRenderer,
+  PRESET_NIGHT: () => PRESET_NIGHT,
+  PRESET_OVERCAST: () => PRESET_OVERCAST,
+  PRESET_SCIFI: () => PRESET_SCIFI,
+  PRESET_SUNNY_DAY: () => PRESET_SUNNY_DAY,
+  PRESET_SUNSET: () => PRESET_SUNSET,
+  SkyRenderer: () => SkyRenderer,
+  TerrainBrush: () => TerrainBrush,
+  TerrainSystem: () => TerrainSystem,
+  TreePlacer: () => TreePlacer,
+  WeatherSystem: () => WeatherSystem,
+  computeSunIntensity: () => computeSunIntensity,
+  computeSunPosition: () => computeSunPosition,
+  resetWeatherBlackboard: () => resetWeatherBlackboard,
+  updateWeatherBlackboard: () => updateWeatherBlackboard,
+  weatherBlackboard: () => weatherBlackboard
+});
+
+// src/environment/DayNightCycle.ts
+var DayNightCycle = class {
+  time = 8;
+  // Start at 8 AM
+  timeScale = 1;
+  // 1 = real-time, 60 = 1 min per real second
+  dayCount = 0;
+  paused = false;
+  listeners = [];
+  lastPeriod = "morning";
+  // ---------------------------------------------------------------------------
+  // Time Control
+  // ---------------------------------------------------------------------------
+  setTime(hours) {
+    this.time = (hours % 24 + 24) % 24;
+    this.lastPeriod = this.getPeriod();
+  }
+  setTimeScale(scale) {
+    this.timeScale = Math.max(0, scale);
+  }
+  getTimeScale() {
+    return this.timeScale;
+  }
+  pause() {
+    this.paused = true;
+  }
+  resume() {
+    this.paused = false;
+  }
+  isPaused() {
+    return this.paused;
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  update(dt) {
+    if (this.paused) return;
+    const hourStep = dt * this.timeScale / 3600;
+    this.time += hourStep;
+    while (this.time >= 24) {
+      this.time -= 24;
+      this.dayCount++;
+    }
+    const newPeriod = this.getPeriod();
+    if (newPeriod !== this.lastPeriod) {
+      this.lastPeriod = newPeriod;
+      for (const l of this.listeners) l(newPeriod, this.getState());
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Sun / Moon
+  // ---------------------------------------------------------------------------
+  getSunAngle() {
+    if (this.time >= 6 && this.time <= 18) {
+      return (this.time - 6) / 12 * 180;
+    }
+    return -1;
+  }
+  getMoonAngle() {
+    if (this.time >= 18 || this.time <= 6) {
+      const moonTime = this.time >= 18 ? this.time - 18 : this.time + 6;
+      return moonTime / 12 * 180;
+    }
+    return -1;
+  }
+  getSunIntensity() {
+    const angle = this.getSunAngle();
+    if (angle < 0) return 0;
+    return Math.sin(angle / 180 * Math.PI);
+  }
+  getMoonIntensity() {
+    const angle = this.getMoonAngle();
+    if (angle < 0) return 0;
+    return Math.sin(angle / 180 * Math.PI) * 0.3;
+  }
+  // ---------------------------------------------------------------------------
+  // Ambient
+  // ---------------------------------------------------------------------------
+  getAmbientColor() {
+    const intensity = this.getSunIntensity();
+    if (intensity > 0.7) return { r: 1, g: 0.95, b: 0.9 };
+    if (intensity > 0.3) return { r: 1, g: 0.7, b: 0.4 };
+    if (intensity > 0) return { r: 0.6, g: 0.3, b: 0.3 };
+    return { r: 0.1, g: 0.1, b: 0.2 };
+  }
+  // ---------------------------------------------------------------------------
+  // Period
+  // ---------------------------------------------------------------------------
+  getPeriod() {
+    if (this.time >= 5 && this.time < 7) return "dawn";
+    if (this.time >= 7 && this.time < 11) return "morning";
+    if (this.time >= 11 && this.time < 13) return "noon";
+    if (this.time >= 13 && this.time < 17) return "afternoon";
+    if (this.time >= 17 && this.time < 19) return "dusk";
+    if (this.time >= 19 && this.time < 22) return "evening";
+    if (this.time >= 22 || this.time < 1) return "night";
+    return "midnight";
+  }
+  // ---------------------------------------------------------------------------
+  // Events
+  // ---------------------------------------------------------------------------
+  onPeriodChange(listener) {
+    this.listeners.push(listener);
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getTime() {
+    return this.time;
+  }
+  getDayCount() {
+    return this.dayCount;
+  }
+  getState() {
+    return {
+      time: this.time,
+      sunAngle: this.getSunAngle(),
+      moonAngle: this.getMoonAngle(),
+      sunIntensity: this.getSunIntensity(),
+      moonIntensity: this.getMoonIntensity(),
+      ambientColor: this.getAmbientColor(),
+      ambientIntensity: Math.max(this.getSunIntensity(), this.getMoonIntensity()),
+      period: this.getPeriod(),
+      dayCount: this.dayCount
+    };
+  }
+  getFormattedTime() {
+    const h = Math.floor(this.time);
+    const m = Math.floor(this.time % 1 * 60);
+    return `${h.toString().padStart(2, "0")}:${m.toString().padStart(2, "0")}`;
+  }
+};
+
+// src/environment/EnvironmentPresets.ts
+var PRESET_SUNNY_DAY = {
+  id: "sunny_day",
+  name: "Sunny Day",
+  skybox: {
+    type: "gradient",
+    topColor: "#1e90ff",
+    bottomColor: "#87ceeb",
+    horizonColor: "#f0f8ff",
+    sunPosition: { x: 0.5, y: 0.8, z: 0.2 }
+  },
+  lights: [
+    {
+      type: "directional",
+      color: "#fff5e6",
+      intensity: 1.2,
+      direction: { x: -0.5, y: -0.8, z: -0.2 },
+      castShadows: true,
+      shadowMapSize: 2048
+    },
+    { type: "ambient", color: "#87ceeb", intensity: 0.4 }
+  ],
+  fog: { type: "exponential2", color: "#c8dff5", density: 8e-4 },
+  atmosphere: {
+    ambientOcclusion: true,
+    bloom: true,
+    bloomIntensity: 0.5,
+    bloomThreshold: 0.8,
+    toneMappingExposure: 1,
+    colorGrading: { saturation: 1.1, contrast: 1.05, temperature: 6500 }
+  }
+};
+var PRESET_SUNSET = {
+  id: "sunset",
+  name: "Golden Sunset",
+  skybox: {
+    type: "gradient",
+    topColor: "#1a0533",
+    bottomColor: "#ff6b35",
+    horizonColor: "#ff4500",
+    sunPosition: { x: 0.9, y: 0.1, z: 0 }
+  },
+  lights: [
+    {
+      type: "directional",
+      color: "#ff8c42",
+      intensity: 0.8,
+      direction: { x: -0.9, y: -0.1, z: 0 },
+      castShadows: true,
+      shadowMapSize: 2048
+    },
+    { type: "ambient", color: "#4a2040", intensity: 0.3 }
+  ],
+  fog: { type: "exponential2", color: "#ff8c6b", density: 1e-3 },
+  atmosphere: {
+    ambientOcclusion: true,
+    bloom: true,
+    bloomIntensity: 1,
+    bloomThreshold: 0.6,
+    toneMappingExposure: 1.2,
+    colorGrading: { saturation: 1.3, contrast: 1.1, temperature: 4e3 }
+  }
+};
+var PRESET_NIGHT = {
+  id: "night",
+  name: "Moonlit Night",
+  skybox: {
+    type: "gradient",
+    topColor: "#0a0a1a",
+    bottomColor: "#14142b",
+    horizonColor: "#1a1a3e",
+    sunPosition: { x: -0.3, y: 0.6, z: 0.5 }
+    // Moon position
+  },
+  lights: [
+    {
+      type: "directional",
+      color: "#b0c4de",
+      intensity: 0.15,
+      direction: { x: 0.3, y: -0.6, z: -0.5 },
+      castShadows: true,
+      shadowMapSize: 1024
+    },
+    { type: "ambient", color: "#0a0a2e", intensity: 0.1 }
+  ],
+  fog: { type: "exponential2", color: "#0a0a1a", density: 2e-3 },
+  atmosphere: {
+    ambientOcclusion: true,
+    bloom: true,
+    bloomIntensity: 0.8,
+    bloomThreshold: 0.4,
+    toneMappingExposure: 0.5,
+    colorGrading: { saturation: 0.7, contrast: 1.2, temperature: 8e3 }
+  }
+};
+var PRESET_OVERCAST = {
+  id: "overcast",
+  name: "Overcast",
+  skybox: {
+    type: "gradient",
+    topColor: "#808890",
+    bottomColor: "#a0a8b0",
+    horizonColor: "#b0b8c0"
+  },
+  lights: [
+    {
+      type: "directional",
+      color: "#c0c0c0",
+      intensity: 0.5,
+      direction: { x: -0.3, y: -0.8, z: -0.2 },
+      castShadows: true,
+      shadowMapSize: 1024
+    },
+    { type: "ambient", color: "#909090", intensity: 0.5 }
+  ],
+  fog: { type: "exponential2", color: "#a0a8b0", density: 15e-4 },
+  atmosphere: {
+    ambientOcclusion: true,
+    bloom: false,
+    bloomIntensity: 0,
+    bloomThreshold: 1,
+    toneMappingExposure: 0.8,
+    colorGrading: { saturation: 0.8, contrast: 0.95, temperature: 6800 }
+  }
+};
+var PRESET_SCIFI = {
+  id: "scifi",
+  name: "Sci-Fi Neon",
+  skybox: {
+    type: "gradient",
+    topColor: "#0a001a",
+    bottomColor: "#1a0033",
+    horizonColor: "#330066"
+  },
+  lights: [
+    {
+      type: "directional",
+      color: "#00ffff",
+      intensity: 0.3,
+      direction: { x: 0, y: -1, z: 0 },
+      castShadows: true,
+      shadowMapSize: 2048
+    },
+    { type: "ambient", color: "#1a003a", intensity: 0.2 },
+    { type: "point", color: "#ff00ff", intensity: 2, position: { x: 0, y: 10, z: 0 } }
+  ],
+  fog: { type: "exponential2", color: "#0a001a", density: 3e-3 },
+  atmosphere: {
+    ambientOcclusion: true,
+    bloom: true,
+    bloomIntensity: 2,
+    bloomThreshold: 0.3,
+    toneMappingExposure: 1.5,
+    colorGrading: { saturation: 1.5, contrast: 1.3, temperature: 3500 }
+  }
+};
+var ALL_PRESETS = [
+  PRESET_SUNNY_DAY,
+  PRESET_SUNSET,
+  PRESET_NIGHT,
+  PRESET_OVERCAST,
+  PRESET_SCIFI
+];
+var EnvironmentManager = class {
+  currentEnv;
+  timeOfDay;
+  weather;
+  constructor(preset = PRESET_SUNNY_DAY) {
+    this.currentEnv = { ...preset };
+    this.timeOfDay = {
+      sunriseHour: 6,
+      sunsetHour: 18,
+      currentHour: 12,
+      daySpeed: 1
+    };
+    this.weather = {
+      type: "clear",
+      intensity: 0,
+      windDirection: { x: 1, y: 0, z: 0 },
+      windSpeed: 2,
+      transitionProgress: 1
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Environment
+  // ---------------------------------------------------------------------------
+  setEnvironment(config) {
+    this.currentEnv = { ...config };
+  }
+  getEnvironment() {
+    return { ...this.currentEnv };
+  }
+  setPreset(presetId) {
+    const preset = ALL_PRESETS.find((p) => p.id === presetId);
+    if (!preset) return false;
+    this.currentEnv = { ...preset };
+    return true;
+  }
+  getPresetIds() {
+    return ALL_PRESETS.map((p) => p.id);
+  }
+  // ---------------------------------------------------------------------------
+  // Time of Day
+  // ---------------------------------------------------------------------------
+  setTimeOfDay(hour) {
+    this.timeOfDay.currentHour = hour % 24;
+    this.updateSunFromTime();
+  }
+  advanceTime(deltaSeconds) {
+    const hoursElapsed = deltaSeconds / 3600 * this.timeOfDay.daySpeed;
+    this.timeOfDay.currentHour = (this.timeOfDay.currentHour + hoursElapsed) % 24;
+    this.updateSunFromTime();
+  }
+  getTimeOfDay() {
+    return { ...this.timeOfDay };
+  }
+  updateSunFromTime() {
+    const hour = this.timeOfDay.currentHour;
+    const dayLength = this.timeOfDay.sunsetHour - this.timeOfDay.sunriseHour;
+    const isDay = hour >= this.timeOfDay.sunriseHour && hour <= this.timeOfDay.sunsetHour;
+    if (isDay) {
+      const progress = (hour - this.timeOfDay.sunriseHour) / dayLength;
+      const angle = progress * Math.PI;
+      this.currentEnv.skybox.sunPosition = {
+        x: Math.cos(angle) * 0.5,
+        y: Math.sin(angle),
+        z: 0.2
+      };
+      const sunIntensity = Math.sin(angle);
+      if (this.currentEnv.lights[0]) {
+        this.currentEnv.lights[0].intensity = 0.3 + sunIntensity * 0.9;
+      }
+    } else {
+      this.currentEnv.skybox.sunPosition = { x: 0, y: -0.5, z: 0 };
+      if (this.currentEnv.lights[0]) {
+        this.currentEnv.lights[0].intensity = 0.1;
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Weather
+  // ---------------------------------------------------------------------------
+  setWeather(type, intensity = 0.5) {
+    this.weather = {
+      ...this.weather,
+      type,
+      intensity: Math.max(0, Math.min(1, intensity)),
+      transitionProgress: 0
+    };
+    switch (type) {
+      case "fog":
+        this.currentEnv.fog = {
+          type: "exponential2",
+          color: "#c0c0c0",
+          density: 5e-3 * intensity
+        };
+        break;
+      case "rain":
+      case "storm":
+        this.currentEnv.fog = {
+          type: "exponential2",
+          color: "#808080",
+          density: 2e-3 * intensity
+        };
+        break;
+      case "snow":
+        this.currentEnv.fog = {
+          type: "exponential2",
+          color: "#e0e0e0",
+          density: 3e-3 * intensity
+        };
+        break;
+      default:
+        break;
+    }
+  }
+  getWeather() {
+    return { ...this.weather };
+  }
+  updateWeatherTransition(dt) {
+    if (this.weather.transitionProgress < 1) {
+      this.weather.transitionProgress = Math.min(1, this.weather.transitionProgress + dt * 0.5);
+    }
+  }
+};
+
+// src/environment/FoliageSystem.ts
+var FoliageSystem = class {
+  types = /* @__PURE__ */ new Map();
+  patches = /* @__PURE__ */ new Map();
+  windDir = { x: 1, z: 0 };
+  windStrength = 0.5;
+  time = 0;
+  // ---------------------------------------------------------------------------
+  // Types
+  // ---------------------------------------------------------------------------
+  registerType(type) {
+    this.types.set(type.id, type);
+  }
+  getType(id) {
+    return this.types.get(id);
+  }
+  getTypeCount() {
+    return this.types.size;
+  }
+  // ---------------------------------------------------------------------------
+  // Wind
+  // ---------------------------------------------------------------------------
+  setWind(dirX, dirZ, strength) {
+    const len = Math.sqrt(dirX * dirX + dirZ * dirZ) || 1;
+    this.windDir = { x: dirX / len, z: dirZ / len };
+    this.windStrength = Math.max(0, Math.min(1, strength));
+  }
+  getWind() {
+    return { dirX: this.windDir.x, dirZ: this.windDir.z, strength: this.windStrength };
+  }
+  // ---------------------------------------------------------------------------
+  // Scattering
+  // ---------------------------------------------------------------------------
+  scatter(patchId, typeId, bounds, count, seed = 42) {
+    const type = this.types.get(typeId);
+    if (!type) throw new Error(`Unknown foliage type: ${typeId}`);
+    const instances = [];
+    let rng = seed;
+    const nextRand = () => {
+      rng = rng * 1103515245 + 12345 & 2147483647;
+      return rng / 2147483647;
+    };
+    for (let i = 0; i < count; i++) {
+      const x = bounds.x + nextRand() * bounds.w;
+      const z = bounds.z + nextRand() * bounds.h;
+      const scale = type.minScale + nextRand() * (type.maxScale - type.minScale);
+      instances.push({
+        typeId,
+        position: { x, y: 0, z },
+        scale,
+        rotation: nextRand() * Math.PI * 2,
+        windPhase: nextRand() * Math.PI * 2,
+        lodLevel: 0,
+        visible: true
+      });
+    }
+    const patch = {
+      id: patchId,
+      bounds,
+      instances,
+      density: count / (bounds.w * bounds.h)
+    };
+    this.patches.set(patchId, patch);
+    return patch;
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  update(dt, cameraPos) {
+    this.time += dt;
+    for (const patch of this.patches.values()) {
+      for (const inst of patch.instances) {
+        const type = this.types.get(inst.typeId);
+        if (!type) continue;
+        const dx = inst.position.x - cameraPos.x;
+        const dz = inst.position.z - cameraPos.z;
+        const dist = Math.sqrt(dx * dx + dz * dz);
+        inst.lodLevel = 0;
+        inst.visible = true;
+        for (let l = 0; l < type.lodDistances.length; l++) {
+          if (dist > type.lodDistances[l]) inst.lodLevel = l + 1;
+        }
+        if (inst.lodLevel > type.lodDistances.length) inst.visible = false;
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Wind sway (queried per instance for rendering)
+  // ---------------------------------------------------------------------------
+  getWindOffset(inst) {
+    const type = this.types.get(inst.typeId);
+    const response = type?.windResponse ?? 0;
+    const sway = Math.sin(this.time * 2 + inst.windPhase) * this.windStrength * response;
+    return { x: this.windDir.x * sway, z: this.windDir.z * sway };
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getPatch(id) {
+    return this.patches.get(id);
+  }
+  getPatchCount() {
+    return this.patches.size;
+  }
+  getVisibleCount() {
+    let count = 0;
+    for (const p of this.patches.values()) {
+      for (const i of p.instances) if (i.visible) count++;
+    }
+    return count;
+  }
+  getTotalInstanceCount() {
+    let count = 0;
+    for (const p of this.patches.values()) count += p.instances.length;
+    return count;
+  }
+  removePatch(id) {
+    return this.patches.delete(id);
+  }
+};
+
+// src/environment/GrassRenderer.ts
+var GrassRenderer = class {
+  config;
+  blades = [];
+  constructor(config) {
+    this.config = {
+      baseHeight: 0.3,
+      heightVariation: 0.15,
+      baseWidth: 0.02,
+      widthVariation: 0.01,
+      baseColor: { r: 0.2, g: 0.6, b: 0.1 },
+      tipColor: { r: 0.5, g: 0.8, b: 0.2 },
+      colorVariation: 0.1,
+      billboardDistance: 30,
+      cullDistance: 60,
+      bendRange: 0.3,
+      bladesPerUnit: 10,
+      ...config
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Generation
+  // ---------------------------------------------------------------------------
+  generate(bounds, seed = 123) {
+    this.blades = [];
+    const area = bounds.w * bounds.h;
+    const count = Math.floor(area * this.config.bladesPerUnit);
+    let rng = seed;
+    const rand = () => {
+      rng = rng * 1103515245 + 12345 & 2147483647;
+      return rng / 2147483647;
+    };
+    for (let i = 0; i < count; i++) {
+      const x = bounds.x + rand() * bounds.w;
+      const z = bounds.z + rand() * bounds.h;
+      const heightMul = 1 - this.config.heightVariation + rand() * this.config.heightVariation * 2;
+      const widthMul = 1 - this.config.widthVariation / this.config.baseWidth + rand() * (this.config.widthVariation / this.config.baseWidth) * 2;
+      const colorVar = (rand() - 0.5) * 2 * this.config.colorVariation;
+      this.blades.push({
+        position: { x, y: 0, z },
+        height: this.config.baseHeight * heightMul,
+        width: this.config.baseWidth * Math.max(0.5, widthMul),
+        bendFactor: rand() * this.config.bendRange,
+        color: {
+          r: Math.max(0, Math.min(1, this.config.baseColor.r + colorVar)),
+          g: Math.max(0, Math.min(1, this.config.baseColor.g + colorVar)),
+          b: Math.max(0, Math.min(1, this.config.baseColor.b + colorVar))
+        },
+        lodLevel: 0,
+        isBillboard: false
+      });
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Update LOD
+  // ---------------------------------------------------------------------------
+  updateLOD(cameraPos) {
+    for (const blade of this.blades) {
+      const dx = blade.position.x - cameraPos.x;
+      const dz = blade.position.z - cameraPos.z;
+      const dist = Math.sqrt(dx * dx + dz * dz);
+      if (dist > this.config.cullDistance) {
+        blade.lodLevel = -1;
+        blade.isBillboard = false;
+      } else if (dist > this.config.billboardDistance) {
+        blade.lodLevel = 2;
+        blade.isBillboard = true;
+      } else if (dist > this.config.billboardDistance * 0.5) {
+        blade.lodLevel = 1;
+        blade.isBillboard = false;
+      } else {
+        blade.lodLevel = 0;
+        blade.isBillboard = false;
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getBladeCount() {
+    return this.blades.length;
+  }
+  getVisibleBlades() {
+    return this.blades.filter((b) => b.lodLevel >= 0);
+  }
+  getBillboardCount() {
+    return this.blades.filter((b) => b.isBillboard).length;
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  setConfig(config) {
+    Object.assign(this.config, config);
+  }
+};
+
+// src/environment/SkyRenderer.ts
+var _cloudId = 0;
+var SkyRenderer = class {
+  gradient = {
+    top: { r: 0.3, g: 0.5, b: 0.9 },
+    horizon: { r: 0.7, g: 0.8, b: 1 },
+    bottom: { r: 0.4, g: 0.4, b: 0.5 }
+  };
+  stars = { seed: 42, density: 100, brightness: 1, twinkleSpeed: 1 };
+  clouds = /* @__PURE__ */ new Map();
+  sun = {
+    visible: true,
+    angle: 90,
+    size: 10,
+    color: { r: 1, g: 0.95, b: 0.8 },
+    intensity: 1
+  };
+  moon = {
+    visible: false,
+    angle: -45,
+    size: 8,
+    color: { r: 0.9, g: 0.9, b: 1 },
+    intensity: 0.3
+  };
+  moonPhase = 0;
+  // 0-7 (new, waxing crescent, first quarter, etc.)
+  starsVisible = false;
+  // ---------------------------------------------------------------------------
+  // Gradient
+  // ---------------------------------------------------------------------------
+  setGradient(gradient) {
+    this.gradient = { ...gradient };
+  }
+  getGradient() {
+    return { ...this.gradient };
+  }
+  sampleGradient(t) {
+    if (t <= 0.5) {
+      const localT = t * 2;
+      return this.lerpColor(this.gradient.bottom, this.gradient.horizon, localT);
+    } else {
+      const localT = (t - 0.5) * 2;
+      return this.lerpColor(this.gradient.horizon, this.gradient.top, localT);
+    }
+  }
+  lerpColor(a, b, t) {
+    return { r: a.r + (b.r - a.r) * t, g: a.g + (b.g - a.g) * t, b: a.b + (b.b - a.b) * t };
+  }
+  // ---------------------------------------------------------------------------
+  // Stars
+  // ---------------------------------------------------------------------------
+  setStarField(config) {
+    Object.assign(this.stars, config);
+  }
+  setStarsVisible(visible) {
+    this.starsVisible = visible;
+  }
+  areStarsVisible() {
+    return this.starsVisible;
+  }
+  getStarField() {
+    return { ...this.stars };
+  }
+  // ---------------------------------------------------------------------------
+  // Clouds
+  // ---------------------------------------------------------------------------
+  addCloudLayer(coverage, altitude = 1e3, speed) {
+    const id = `cloud_${_cloudId++}`;
+    const layer = {
+      id,
+      altitude,
+      coverage,
+      speed: speed ?? { x: 5, z: 0 },
+      color: { r: 1, g: 1, b: 1, a: 0.8 },
+      scale: 1,
+      offset: { x: 0, z: 0 }
+    };
+    this.clouds.set(id, layer);
+    return layer;
+  }
+  removeCloudLayer(id) {
+    return this.clouds.delete(id);
+  }
+  getCloudLayers() {
+    return [...this.clouds.values()];
+  }
+  getCloudCount() {
+    return this.clouds.size;
+  }
+  updateClouds(dt) {
+    for (const layer of this.clouds.values()) {
+      layer.offset.x += layer.speed.x * dt;
+      layer.offset.z += layer.speed.z * dt;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Sun / Moon
+  // ---------------------------------------------------------------------------
+  setSunAngle(angle) {
+    this.sun.angle = angle;
+    this.sun.visible = angle >= 0;
+  }
+  setMoonAngle(angle) {
+    this.moon.angle = angle;
+    this.moon.visible = angle >= 0;
+  }
+  setMoonPhase(phase) {
+    this.moonPhase = phase % 8;
+  }
+  getMoonPhase() {
+    return this.moonPhase;
+  }
+  getSun() {
+    return { ...this.sun };
+  }
+  getMoon() {
+    return { ...this.moon };
+  }
+  // ---------------------------------------------------------------------------
+  // Time-of-Day Presets
+  // ---------------------------------------------------------------------------
+  applyDaytime() {
+    this.setGradient({
+      top: { r: 0.25, g: 0.45, b: 0.85 },
+      horizon: { r: 0.6, g: 0.75, b: 0.95 },
+      bottom: { r: 0.4, g: 0.4, b: 0.5 }
+    });
+    this.starsVisible = false;
+  }
+  applySunset() {
+    this.setGradient({
+      top: { r: 0.3, g: 0.3, b: 0.6 },
+      horizon: { r: 1, g: 0.5, b: 0.2 },
+      bottom: { r: 0.5, g: 0.2, b: 0.1 }
+    });
+    this.starsVisible = false;
+  }
+  applyNight() {
+    this.setGradient({
+      top: { r: 0.02, g: 0.02, b: 0.08 },
+      horizon: { r: 0.05, g: 0.05, b: 0.15 },
+      bottom: { r: 0.03, g: 0.03, b: 0.05 }
+    });
+    this.starsVisible = true;
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getTotalCoverage() {
+    let maxCoverage = 0;
+    for (const layer of this.clouds.values()) {
+      maxCoverage = Math.max(maxCoverage, layer.coverage);
+    }
+    return maxCoverage;
+  }
+};
+
+// src/environment/TerrainBrush.ts
+var DEFAULT_BRUSH = {
+  mode: "raise",
+  radius: 5,
+  strength: 0.1,
+  falloff: 0.7
+};
+var TerrainBrush = class {
+  config;
+  terrain;
+  undoStack = [];
+  redoStack = [];
+  constructor(terrain, config = {}) {
+    this.terrain = terrain;
+    this.config = { ...DEFAULT_BRUSH, ...config };
+  }
+  // ---------------------------------------------------------------------------
+  // Configuration
+  // ---------------------------------------------------------------------------
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  setMode(mode) {
+    this.config.mode = mode;
+  }
+  setRadius(radius) {
+    this.config.radius = Math.max(1, Math.min(50, radius));
+  }
+  setStrength(strength) {
+    this.config.strength = Math.max(0, Math.min(1, strength));
+  }
+  // ---------------------------------------------------------------------------
+  // Apply Brush
+  // ---------------------------------------------------------------------------
+  /**
+   * Apply the brush at a grid position on a terrain.
+   */
+  apply(terrainId, gridX, gridZ) {
+    const terrainData = this.terrain.getTerrain(terrainId);
+    if (!terrainData) {
+      return { terrainId, gridX, gridZ, config: { ...this.config }, affectedCells: [] };
+    }
+    const res = terrainData.config.resolution;
+    const heightmap = terrainData.heightmap;
+    const affectedCells = [];
+    const r = this.config.radius;
+    for (let dz = -r; dz <= r; dz++) {
+      for (let dx = -r; dx <= r; dx++) {
+        const cx = gridX + dx;
+        const cz = gridZ + dz;
+        if (cx < 0 || cx >= res || cz < 0 || cz >= res) continue;
+        const dist = Math.sqrt(dx * dx + dz * dz);
+        if (dist > r) continue;
+        const t = dist / r;
+        const falloff = 1 - Math.pow(t, 1 / Math.max(this.config.falloff, 0.01));
+        const influence = falloff * this.config.strength;
+        const idx = cz * res + cx;
+        const oldHeight = heightmap[idx];
+        let newHeight = oldHeight;
+        switch (this.config.mode) {
+          case "raise":
+            newHeight = Math.min(1, oldHeight + influence * 0.05);
+            break;
+          case "lower":
+            newHeight = Math.max(0, oldHeight - influence * 0.05);
+            break;
+          case "flatten":
+            const target = this.config.flattenHeight ?? 0.5;
+            newHeight = oldHeight + (target - oldHeight) * influence;
+            break;
+          case "smooth": {
+            let sum = 0;
+            let count = 0;
+            for (let sz = -1; sz <= 1; sz++) {
+              for (let sx = -1; sx <= 1; sx++) {
+                const nx = cx + sx;
+                const nz = cz + sz;
+                if (nx >= 0 && nx < res && nz >= 0 && nz < res) {
+                  sum += heightmap[nz * res + nx];
+                  count++;
+                }
+              }
+            }
+            const avg = sum / count;
+            newHeight = oldHeight + (avg - oldHeight) * influence;
+            break;
+          }
+          case "paint":
+            break;
+        }
+        if (newHeight !== oldHeight) {
+          heightmap[idx] = newHeight;
+          affectedCells.push({ x: cx, z: cz, oldHeight, newHeight });
+        }
+      }
+    }
+    const stroke = {
+      terrainId,
+      gridX,
+      gridZ,
+      config: { ...this.config },
+      affectedCells
+    };
+    this.undoStack.push(stroke);
+    this.redoStack = [];
+    return stroke;
+  }
+  // ---------------------------------------------------------------------------
+  // Undo/Redo
+  // ---------------------------------------------------------------------------
+  undo() {
+    const stroke = this.undoStack.pop();
+    if (!stroke) return null;
+    const terrainData = this.terrain.getTerrain(stroke.terrainId);
+    if (!terrainData) return null;
+    const res = terrainData.config.resolution;
+    for (const cell of stroke.affectedCells) {
+      terrainData.heightmap[cell.z * res + cell.x] = cell.oldHeight;
+    }
+    this.redoStack.push(stroke);
+    return stroke;
+  }
+  redo() {
+    const stroke = this.redoStack.pop();
+    if (!stroke) return null;
+    const terrainData = this.terrain.getTerrain(stroke.terrainId);
+    if (!terrainData) return null;
+    const res = terrainData.config.resolution;
+    for (const cell of stroke.affectedCells) {
+      terrainData.heightmap[cell.z * res + cell.x] = cell.newHeight;
+    }
+    this.undoStack.push(stroke);
+    return stroke;
+  }
+  getUndoCount() {
+    return this.undoStack.length;
+  }
+  getRedoCount() {
+    return this.redoStack.length;
+  }
+};
+
+// src/environment/TerrainSystem.ts
+function hash2D(x, y) {
+  let n = x * 73856093 ^ y * 19349663;
+  n = (n ^ n >> 13) * 1274126177;
+  return ((n ^ n >> 16) & 2147483647) / 2147483647;
+}
+function smoothstep(t) {
+  return t * t * (3 - 2 * t);
+}
+function valueNoise2D(x, y) {
+  const ix = Math.floor(x);
+  const iy = Math.floor(y);
+  const fx = x - ix;
+  const fy = y - iy;
+  const sx = smoothstep(fx);
+  const sy = smoothstep(fy);
+  const n00 = hash2D(ix, iy);
+  const n10 = hash2D(ix + 1, iy);
+  const n01 = hash2D(ix, iy + 1);
+  const n11 = hash2D(ix + 1, iy + 1);
+  const nx0 = n00 + (n10 - n00) * sx;
+  const nx1 = n01 + (n11 - n01) * sx;
+  return nx0 + (nx1 - nx0) * sy;
+}
+function fbm(x, y, octaves, lacunarity, gain) {
+  let value = 0;
+  let amplitude = 1;
+  let frequency = 1;
+  let maxValue = 0;
+  for (let i = 0; i < octaves; i++) {
+    value += valueNoise2D(x * frequency, y * frequency) * amplitude;
+    maxValue += amplitude;
+    amplitude *= gain;
+    frequency *= lacunarity;
+  }
+  return value / maxValue;
+}
+var TerrainSystem = class {
+  terrains = /* @__PURE__ */ new Map();
+  // ---------------------------------------------------------------------------
+  // Creation
+  // ---------------------------------------------------------------------------
+  /**
+   * Create a terrain with a procedurally generated heightmap.
+   */
+  createTerrain(config, options = {}) {
+    const { octaves = 6, lacunarity = 2, gain = 0.5, seed = 42, scale = 0.02 } = options;
+    const res = config.resolution;
+    const heightmap = new Float32Array(res * res);
+    for (let z = 0; z < res; z++) {
+      for (let x = 0; x < res; x++) {
+        const nx = (x + seed) * scale;
+        const nz = (z + seed * 0.7) * scale;
+        heightmap[z * res + x] = fbm(nx, nz, octaves, lacunarity, gain);
+      }
+    }
+    const chunks = this.generateChunks(config, heightmap, 0);
+    this.terrains.set(config.id, {
+      config,
+      heightmap,
+      layers: this.getDefaultLayers(),
+      chunks
+    });
+    return config.id;
+  }
+  /**
+   * Create terrain from an existing heightmap array.
+   */
+  createFromHeightmap(config, heightmap) {
+    const chunks = this.generateChunks(config, heightmap, 0);
+    this.terrains.set(config.id, {
+      config,
+      heightmap,
+      layers: this.getDefaultLayers(),
+      chunks
+    });
+    return config.id;
+  }
+  // ---------------------------------------------------------------------------
+  // Heightmap Access
+  // ---------------------------------------------------------------------------
+  /**
+   * Get height at a world position (bilinear interpolation).
+   */
+  getHeightAt(terrainId, worldX, worldZ) {
+    const terrain = this.terrains.get(terrainId);
+    if (!terrain) return 0;
+    const { config, heightmap } = terrain;
+    const res = config.resolution;
+    const localX = (worldX - config.position.x) / config.width;
+    const localZ = (worldZ - config.position.z) / config.depth;
+    if (localX < 0 || localX > 1 || localZ < 0 || localZ > 1) return 0;
+    const gx = localX * (res - 1);
+    const gz = localZ * (res - 1);
+    const ix = Math.floor(gx);
+    const iz = Math.floor(gz);
+    const fx = gx - ix;
+    const fz = gz - iz;
+    const ix1 = Math.min(ix + 1, res - 1);
+    const iz1 = Math.min(iz + 1, res - 1);
+    const h00 = heightmap[iz * res + ix];
+    const h10 = heightmap[iz * res + ix1];
+    const h01 = heightmap[iz1 * res + ix];
+    const h11 = heightmap[iz1 * res + ix1];
+    const h = h00 * (1 - fx) * (1 - fz) + h10 * fx * (1 - fz) + h01 * (1 - fx) * fz + h11 * fx * fz;
+    return config.position.y + h * config.maxHeight;
+  }
+  /**
+   * Get surface normal at a world position (finite differences).
+   */
+  getNormalAt(terrainId, worldX, worldZ) {
+    const epsilon = 0.5;
+    const hL = this.getHeightAt(terrainId, worldX - epsilon, worldZ);
+    const hR = this.getHeightAt(terrainId, worldX + epsilon, worldZ);
+    const hD = this.getHeightAt(terrainId, worldX, worldZ - epsilon);
+    const hU = this.getHeightAt(terrainId, worldX, worldZ + epsilon);
+    const nx = hL - hR;
+    const nz = hD - hU;
+    const ny = 2 * epsilon;
+    const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
+    return { x: nx / len, y: ny / len, z: nz / len };
+  }
+  /**
+   * Set height at a specific grid position.
+   */
+  setHeightAt(terrainId, gridX, gridZ, height) {
+    const terrain = this.terrains.get(terrainId);
+    if (!terrain) return;
+    const res = terrain.config.resolution;
+    if (gridX < 0 || gridX >= res || gridZ < 0 || gridZ >= res) return;
+    terrain.heightmap[gridZ * res + gridX] = Math.max(0, Math.min(1, height));
+  }
+  /**
+   * Get the collider interface for a terrain.
+   */
+  getCollider(terrainId) {
+    if (!this.terrains.has(terrainId)) return null;
+    return {
+      getHeightAt: (x, z) => this.getHeightAt(terrainId, x, z),
+      getNormalAt: (x, z) => this.getNormalAt(terrainId, x, z)
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Layers
+  // ---------------------------------------------------------------------------
+  setLayers(terrainId, layers) {
+    const terrain = this.terrains.get(terrainId);
+    if (terrain) terrain.layers = layers;
+  }
+  getLayers(terrainId) {
+    return this.terrains.get(terrainId)?.layers || [];
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getTerrain(id) {
+    return this.terrains.get(id);
+  }
+  getTerrainIds() {
+    return [...this.terrains.keys()];
+  }
+  removeTerrain(id) {
+    return this.terrains.delete(id);
+  }
+  getChunks(terrainId) {
+    return this.terrains.get(terrainId)?.chunks || [];
+  }
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+  generateChunks(config, heightmap, lod) {
+    const res = config.resolution;
+    const chunkSize = 32;
+    const step = 1 << lod;
+    const chunks = [];
+    for (let cz = 0; cz < res - 1; cz += chunkSize) {
+      for (let cx = 0; cx < res - 1; cx += chunkSize) {
+        const vertices = [];
+        const indices = [];
+        const _vertexIndex = 0;
+        const endX = Math.min(cx + chunkSize, res - 1);
+        const endZ = Math.min(cz + chunkSize, res - 1);
+        for (let z = cz; z <= endZ; z += step) {
+          for (let x = cx; x <= endX; x += step) {
+            const h = heightmap[z * res + x];
+            const worldX = config.position.x + x / (res - 1) * config.width;
+            const worldZ = config.position.z + z / (res - 1) * config.depth;
+            const worldY = config.position.y + h * config.maxHeight;
+            vertices.push({
+              position: { x: worldX, y: worldY, z: worldZ },
+              normal: { x: 0, y: 1, z: 0 },
+              // Simplified; real normals computed post-pass
+              uv: { u: x / (res - 1), v: z / (res - 1) },
+              height: h
+            });
+          }
+        }
+        const rowVerts = Math.ceil((endX - cx) / step) + 1;
+        const colVerts = Math.ceil((endZ - cz) / step) + 1;
+        for (let row = 0; row < colVerts - 1; row++) {
+          for (let col = 0; col < rowVerts - 1; col++) {
+            const tl = row * rowVerts + col;
+            const tr = tl + 1;
+            const bl = (row + 1) * rowVerts + col;
+            const br = bl + 1;
+            indices.push(tl, bl, tr);
+            indices.push(tr, bl, br);
+          }
+        }
+        chunks.push({
+          x: cx,
+          z: cz,
+          lod,
+          vertices,
+          indices
+        });
+      }
+    }
+    return chunks;
+  }
+  getDefaultLayers() {
+    return [
+      {
+        id: "sand",
+        texture: "terrain_sand",
+        tiling: 20,
+        minHeight: 0,
+        maxHeight: 0.15,
+        minSlope: 0,
+        maxSlope: 0.3
+      },
+      {
+        id: "grass",
+        texture: "terrain_grass",
+        tiling: 15,
+        minHeight: 0.1,
+        maxHeight: 0.6,
+        minSlope: 0,
+        maxSlope: 0.6
+      },
+      {
+        id: "rock",
+        texture: "terrain_rock",
+        tiling: 10,
+        minHeight: 0.4,
+        maxHeight: 0.9,
+        minSlope: 0.5,
+        maxSlope: 1
+      },
+      {
+        id: "snow",
+        texture: "terrain_snow",
+        tiling: 12,
+        minHeight: 0.8,
+        maxHeight: 1,
+        minSlope: 0,
+        maxSlope: 0.4
+      }
+    ];
+  }
+};
+
+// src/environment/TreePlacer.ts
+var _treeId = 0;
+var TreePlacer = class {
+  templates = /* @__PURE__ */ new Map();
+  biomes = /* @__PURE__ */ new Map();
+  trees = [];
+  // ---------------------------------------------------------------------------
+  // Templates & Biomes
+  // ---------------------------------------------------------------------------
+  addTemplate(template) {
+    this.templates.set(template.id, template);
+  }
+  getTemplate(id) {
+    return this.templates.get(id);
+  }
+  getTemplateCount() {
+    return this.templates.size;
+  }
+  addBiome(biome) {
+    this.biomes.set(biome.id, biome);
+  }
+  getBiome(id) {
+    return this.biomes.get(id);
+  }
+  // ---------------------------------------------------------------------------
+  // Placement
+  // ---------------------------------------------------------------------------
+  placeInRegion(biomeId, bounds, heightSampler, slopeSampler, seed = 7) {
+    const biome = this.biomes.get(biomeId);
+    if (!biome) return [];
+    const validTemplates = [...this.templates.values()].filter((t) => t.biomes.includes(biomeId));
+    if (validTemplates.length === 0) return [];
+    const totalWeight = validTemplates.reduce((sum, t) => sum + t.probability, 0);
+    const area = bounds.w * bounds.h;
+    const count = Math.floor(area * biome.density);
+    let rng = seed;
+    const rand = () => {
+      rng = rng * 1103515245 + 12345 & 2147483647;
+      return rng / 2147483647;
+    };
+    const placed = [];
+    for (let attempt = 0; attempt < count * 3 && placed.length < count; attempt++) {
+      const x = bounds.x + rand() * bounds.w;
+      const z = bounds.z + rand() * bounds.h;
+      const y = heightSampler ? heightSampler(x, z) : 0;
+      if (y < biome.heightRange.min || y > biome.heightRange.max) continue;
+      if (slopeSampler) {
+        const slope = slopeSampler(x, z);
+        if (slope > biome.slopeMax) continue;
+      }
+      if (!this.checkSpacing(x, z, biome.minSpacing, placed)) continue;
+      const template = this.pickTemplate(validTemplates, totalWeight, rand);
+      if (!template) continue;
+      const scale = template.minScale + rand() * (template.maxScale - template.minScale);
+      const tree = {
+        id: `tree_${_treeId++}`,
+        templateId: template.id,
+        position: { x, y, z },
+        scale,
+        rotation: rand() * Math.PI * 2
+      };
+      placed.push(tree);
+      this.trees.push(tree);
+    }
+    return placed;
+  }
+  checkSpacing(x, z, minSpacing, placed) {
+    const minSq = minSpacing * minSpacing;
+    for (const tree of placed) {
+      const dx = tree.position.x - x;
+      const dz = tree.position.z - z;
+      if (dx * dx + dz * dz < minSq) return false;
+    }
+    for (const tree of this.trees) {
+      const dx = tree.position.x - x;
+      const dz = tree.position.z - z;
+      if (dx * dx + dz * dz < minSq) return false;
+    }
+    return true;
+  }
+  pickTemplate(templates, totalWeight, rand) {
+    let r = rand() * totalWeight;
+    for (const t of templates) {
+      r -= t.probability;
+      if (r <= 0) return t;
+    }
+    return templates[templates.length - 1];
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getPlacedCount() {
+    return this.trees.length;
+  }
+  getAllTrees() {
+    return [...this.trees];
+  }
+  getTreesInRadius(x, z, radius) {
+    const rSq = radius * radius;
+    return this.trees.filter((t) => {
+      const dx = t.position.x - x;
+      const dz = t.position.z - z;
+      return dx * dx + dz * dz <= rSq;
+    });
+  }
+  removeTree(id) {
+    const idx = this.trees.findIndex((t) => t.id === id);
+    if (idx === -1) return false;
+    this.trees.splice(idx, 1);
+    return true;
+  }
+  clear() {
+    this.trees = [];
+  }
+};
+
+// src/environment/WeatherBlackboard.ts
+var DEFAULT_STATE = {
+  wind_vector: [0, 0, 0],
+  precipitation: 0,
+  precipitation_type: "none",
+  temperature: 20,
+  humidity: 0.5,
+  sun_position: [0.5, 0.866, 0],
+  // ~60 degree elevation, noon
+  sun_intensity: 1,
+  cloud_density: 0.3,
+  cloud_altitude: 2e3,
+  fog_density: 0,
+  time_of_day: 12,
+  is_night: false,
+  surface_wetness: 0,
+  wind_speed: 0,
+  visibility_range: 1e4,
+  frame: 0
+};
+var weatherBlackboard = { ...DEFAULT_STATE };
+function updateWeatherBlackboard(partial) {
+  Object.assign(weatherBlackboard, partial);
+  const wv = weatherBlackboard.wind_vector;
+  weatherBlackboard.wind_speed = Math.sqrt(wv[0] * wv[0] + wv[1] * wv[1] + wv[2] * wv[2]);
+  weatherBlackboard.is_night = weatherBlackboard.sun_intensity < 0.1;
+  weatherBlackboard.visibility_range = 1e4 * (1 - weatherBlackboard.fog_density * 0.9) * (1 - weatherBlackboard.precipitation * 0.5);
+  if (weatherBlackboard.precipitation > 0 && weatherBlackboard.precipitation_type === "rain") {
+    weatherBlackboard.surface_wetness = Math.min(
+      1,
+      weatherBlackboard.surface_wetness + weatherBlackboard.precipitation * 0.01
+    );
+  } else {
+    weatherBlackboard.surface_wetness = Math.max(0, weatherBlackboard.surface_wetness - 1e-3);
+  }
+  weatherBlackboard.frame++;
+}
+function resetWeatherBlackboard() {
+  Object.assign(weatherBlackboard, DEFAULT_STATE);
+  weatherBlackboard.frame = 0;
+}
+function computeSunPosition(timeOfDay, latitude = 45) {
+  const hourAngle = (timeOfDay - 12) * (Math.PI / 12);
+  const latRad = latitude * (Math.PI / 180);
+  const maxElevation = Math.PI / 2 - Math.abs(latRad - 23.5 * Math.PI / 180);
+  const elevation = Math.sin(Math.PI * timeOfDay / 24) * maxElevation;
+  const x = Math.cos(hourAngle) * Math.cos(elevation);
+  const y = Math.sin(elevation);
+  const z = Math.sin(hourAngle) * Math.cos(elevation);
+  const len = Math.sqrt(x * x + y * y + z * z);
+  if (len < 1e-3) return [0, -1, 0];
+  return [x / len, y / len, z / len];
+}
+function computeSunIntensity(sunY) {
+  if (sunY <= 0) return 0;
+  return Math.min(1, sunY * 2) * Math.min(1, sunY * 5);
+}
+
+// src/environment/WeatherSystem.ts
+var WEATHER_DEFAULTS = {
+  clear: { intensity: 0, visibility: 1, precipitation: 0, humidity: 0.3 },
+  cloudy: { intensity: 0.3, visibility: 0.9, precipitation: 0, humidity: 0.5 },
+  rain: { intensity: 0.6, visibility: 0.6, precipitation: 0.7, humidity: 0.8 },
+  storm: { intensity: 1, visibility: 0.3, precipitation: 1, humidity: 0.95 },
+  snow: { intensity: 0.5, visibility: 0.5, precipitation: 0.6, humidity: 0.7 },
+  fog: { intensity: 0.4, visibility: 0.2, precipitation: 0, humidity: 0.9 },
+  sandstorm: { intensity: 0.8, visibility: 0.15, precipitation: 0, humidity: 0.1 }
+};
+var WeatherSystem = class {
+  current;
+  transition = null;
+  targetState = null;
+  listeners = [];
+  history = [];
+  constructor(initial = "clear") {
+    this.current = this.createState(initial);
+    this.history.push({ type: initial, timestamp: Date.now() });
+  }
+  createState(type) {
+    const defaults = WEATHER_DEFAULTS[type];
+    return {
+      type,
+      intensity: defaults.intensity ?? 0,
+      wind: { x: 0, y: 0, z: 0, speed: 0 },
+      temperature: 20,
+      humidity: defaults.humidity ?? 0.5,
+      visibility: defaults.visibility ?? 1,
+      precipitation: defaults.precipitation ?? 0
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Weather Control
+  // ---------------------------------------------------------------------------
+  setWeather(type, transitionDuration = 5) {
+    if (type === this.current.type && !this.transition) return;
+    this.targetState = this.createState(type);
+    this.transition = {
+      from: this.current.type,
+      to: type,
+      duration: transitionDuration,
+      elapsed: 0
+    };
+    this.history.push({ type, timestamp: Date.now() });
+  }
+  setImmediate(type) {
+    this.current = this.createState(type);
+    this.transition = null;
+    this.targetState = null;
+    this.notify();
+  }
+  setWind(x, y, z, speed) {
+    this.current.wind = { x, y, z, speed };
+  }
+  setTemperature(temp) {
+    this.current.temperature = temp;
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  update(dt) {
+    if (!this.transition || !this.targetState) return;
+    this.transition.elapsed += dt;
+    const t = Math.min(1, this.transition.elapsed / this.transition.duration);
+    const ease = t * t * (3 - 2 * t);
+    this.current.intensity = this.lerp(this.current.intensity, this.targetState.intensity, ease);
+    this.current.visibility = this.lerp(this.current.visibility, this.targetState.visibility, ease);
+    this.current.precipitation = this.lerp(
+      this.current.precipitation,
+      this.targetState.precipitation,
+      ease
+    );
+    this.current.humidity = this.lerp(this.current.humidity, this.targetState.humidity, ease);
+    if (t >= 1) {
+      this.current.type = this.transition.to;
+      this.current = {
+        ...this.targetState,
+        wind: this.current.wind,
+        temperature: this.current.temperature
+      };
+      this.transition = null;
+      this.targetState = null;
+      this.notify();
+    }
+  }
+  lerp(a, b, t) {
+    return a + (b - a) * t;
+  }
+  // ---------------------------------------------------------------------------
+  // Events
+  // ---------------------------------------------------------------------------
+  onChange(listener) {
+    this.listeners.push(listener);
+  }
+  notify() {
+    for (const l of this.listeners) l(this.getState());
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getState() {
+    return { ...this.current, wind: { ...this.current.wind } };
+  }
+  getType() {
+    return this.current.type;
+  }
+  isTransitioning() {
+    return this.transition !== null;
+  }
+  getTransitionProgress() {
+    return this.transition ? this.transition.elapsed / this.transition.duration : 0;
+  }
+  getHistory() {
+    return [...this.history];
+  }
+};
+
+export {
+  DayNightCycle,
+  PRESET_SUNNY_DAY,
+  PRESET_SUNSET,
+  PRESET_NIGHT,
+  PRESET_OVERCAST,
+  PRESET_SCIFI,
+  ALL_PRESETS,
+  EnvironmentManager,
+  FoliageSystem,
+  GrassRenderer,
+  SkyRenderer,
+  TerrainBrush,
+  TerrainSystem,
+  TreePlacer,
+  weatherBlackboard,
+  updateWeatherBlackboard,
+  resetWeatherBlackboard,
+  computeSunPosition,
+  computeSunIntensity,
+  WeatherSystem,
+  environment_exports
+};