minerender 2.1.0-alpha.119 → 2.1.0-alpha.120

package/dist/browser/index.js

@@ -7618,6 +7618,7 @@ __export(index_browser_exports, {
   classicSkinTextureCoordinates: () => classicSkinTextureCoordinates,
   computeMorphedAttributes: () => computeMorphedAttributes,
   computeTangents: () => computeTangents,
+  copySectionLight: () => copySectionLight,
   createCanvas: () => createCanvas,
   createFluidGeometry: () => createFluidGeometry,
   createGuiTextGeometry: () => createGuiTextGeometry,
@@ -7670,6 +7671,7 @@ __export(index_browser_exports, {
   sampleEntityAnimation: () => sampleEntityAnimation,
   sampleEntityKeyframes: () => sampleEntityKeyframes,
   sampleFluid: () => sampleFluid,
+  sampleSectionLight: () => sampleSectionLight,
   sectionGeometryTransferables: () => sectionGeometryTransferables,
   serializeBoxGeometryKey: () => serializeBoxGeometryKey,
   serializeImageKey: () => serializeImageKey,
@@ -16992,11 +16994,20 @@ var AnvilParser = class {
     const { root, expected } = await this.readNBT(data, location, options);
     const level = root.Level?.type === "compound" ? root.Level.value : root;
     const dataVersion = root.DataVersion?.type === "int" ? root.DataVersion.value : void 0;
+    const sections = this.compounds(level.sections ?? level.Sections, "sections");
+    const lightFlagName = level.isLightOn ? "isLightOn" : "LightPopulated";
+    const lightFlag = level[lightFlagName];
+    if (lightFlag && (lightFlag.type !== "byte" || lightFlag.value !== 0 && lightFlag.value !== 1)) {
+      throw new MineRenderError(`Anvil ${lightFlagName} must be a byte containing 0 or 1`);
+    }
+    const modernLighting = root.Level?.type !== "compound" || sections.some((section) => section.Palette || section.BlockStates || section.block_states);
+    const lightValid = lightFlag ? lightFlag.value === 1 : modernLighting ? false : void 0;
     const chunk = {
       x: this.integer(level.xPos, "xPos"),
       z: this.integer(level.zPos, "zPos"),
       dataVersion,
-      sections: []
+      sections: [],
+      ...lightValid !== void 0 ? { lightValid } : {}
     };
     if ((chunk.x % 32 + 32) % 32 !== location.x || (chunk.z % 32 + 32) % 32 !== location.z) {
       throw new MineRenderError("Anvil chunk coordinates do not match its region location");
@@ -17006,7 +17017,7 @@ var AnvilParser = class {
     }
     const numericStates = /* @__PURE__ */ new Map();
     let legacyMappings;
-    for (const section of this.compounds(level.sections ?? level.Sections, "sections")) {
+    for (const section of sections) {
       const y = this.integer(section.Y, "section Y");
       let data2;
       if (section.Blocks || section.Data || section.Add) {
@@ -17036,7 +17047,8 @@ var AnvilParser = class {
       }
       if (chunk.sections.some((section2) => section2.y === y)) throw new MineRenderError(`Duplicate Anvil section Y ${y}`);
       const biomes = this.biomes(section.biomes);
-      chunk.sections.push({ y, data: data2, ...biomes ? { biomes } : {} });
+      const light = this.light(section, y, chunk.lightValid);
+      chunk.sections.push({ y, data: data2, ...biomes ? { biomes } : {}, ...light ? { light } : {} });
     }
     for (const entry of this.compounds(level.block_entities ?? level.TileEntities, "block entities")) {
       const x = this.integer(entry.x, "block entity x") - chunk.x * 16;
@@ -17089,6 +17101,18 @@ var AnvilParser = class {
       return { position: [...position.value.value], nbt: { type: "compound", value } };
     });
   }
+  static light(section, y, valid) {
+    const light = {};
+    for (const [name, channel] of [["BlockLight", "block"], ["SkyLight", "sky"]]) {
+      const tag = section[name];
+      if (!tag) continue;
+      if (tag.type !== "byteArray" || !Array.isArray(tag.value) || tag.value.length !== 2048) {
+        throw new MineRenderError(`Anvil section ${y} ${name} must contain 2048 bytes`);
+      }
+      light[channel] = Uint8Array.from(tag.value);
+    }
+    return light.block || light.sky || valid ? light : void 0;
+  }
   static biomes(tag) {
     if (!tag) return void 0;
     if (tag.type !== "compound") throw new MineRenderError("Anvil biomes must be a compound");
@@ -17666,12 +17690,45 @@ var WorldEntities = class {
 
 // src/world/MineRenderWorld.ts
 init_FluidQuads();
+
+// src/world/WorldLight.ts
+function copySectionLight(light) {
+  const copy = {};
+  for (const channel of ["block", "sky"]) {
+    const bytes = light[channel];
+    if (bytes === void 0) continue;
+    if (!(bytes instanceof Uint8Array) || bytes.length !== 2048) {
+      throw new RangeError(`Section ${channel} light must contain 2048 packed bytes`);
+    }
+    copy[channel] = new Uint8Array(bytes);
+  }
+  return copy;
+}
+function sampleSectionLight(light, index) {
+  if (!light) return void 0;
+  const shift = (index & 1) * 4;
+  return {
+    block: (light.block?.[index >> 1] ?? 0) >> shift & 15,
+    sky: (light.sky?.[index >> 1] ?? 0) >> shift & 15
+  };
+}
+
+// src/world/MineRenderWorld.ts
 var MineRenderWorld = class {
   constructor(scene, options = {}) {
     this._chunks = /* @__PURE__ */ new Map();
     this.biomes = /* @__PURE__ */ new Map();
+    this.light = /* @__PURE__ */ new Map();
+    this.lightValidity = /* @__PURE__ */ new Map();
+    this.highestSkySection = /* @__PURE__ */ new Map();
     this.pendingCulling = /* @__PURE__ */ new Map();
+    if (options.savedLighting && !options.sectionMeshing) throw new TypeError("savedLighting requires sectionMeshing");
+    if (options.ambientLight !== void 0 && (!Number.isFinite(options.ambientLight) || options.ambientLight < 0 || options.ambientLight > 1)) {
+      throw new RangeError("ambientLight must be a number from 0 to 1");
+    }
     this.scene = scene;
+    this.savedLighting = options.savedLighting ?? false;
+    this.ambientLight = options.ambientLight ?? 0;
     if (options.sectionMeshing) this.sectionModels = new SectionModels(options.maxAtlasSize);
     if (options.renderEntities) this.entities = new WorldEntities(scene);
   }
@@ -17693,6 +17750,24 @@ var MineRenderWorld = class {
     const lx = posOrX.x - cx * 16, ly = posOrX.y - cy * 16, lz = posOrX.z - cz * 16;
     return this.biomes.get(`${cx}_${cz}`)?.get(cy)?.[Math.floor(lx / 4) + Math.floor(lz / 4) * 4 + Math.floor(ly / 4) * 16];
   }
+  getLightAt(posOrX, y, z) {
+    if (typeof posOrX === "number") return this.getLightAt(new import_three42.Vector3(posOrX, y, z));
+    if (isTripleArray(posOrX)) return this.getLightAt(new import_three42.Vector3(...posOrX));
+    this.validatePosBounds(posOrX);
+    const { x, y: py, z: pz } = posOrX;
+    const cx = Math.floor(x / 16), cy = Math.floor(py / 16), cz = Math.floor(pz / 16);
+    const key = `${cx}_${cz}`, top = this.highestSkySection.get(key);
+    const sample = sampleSectionLight(this.light.get(key)?.get(cy), (x & 15) + (pz & 15) * 16 + (py & 15) * 256);
+    return top !== void 0 && cy > top ? { block: sample?.block ?? 0, sky: 15 } : sample;
+  }
+  lightLevelAt(x, y, z) {
+    const cx = Math.floor(x / 16), cy = Math.floor(y / 16), cz = Math.floor(z / 16), key = `${cx}_${cz}`;
+    if (this.lightValidity.get(key) === false) return 255;
+    const top = this.highestSkySection.get(key);
+    if (top !== void 0 && cy > top) return 15;
+    const sample = sampleSectionLight(this.light.get(key)?.get(cy), (x & 15) + (z & 15) * 16 + (y & 15) * 256);
+    return sample ? Math.max(sample.block, sample.sky) : 255;
+  }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
       return this.setBlockAt(new import_three42.Vector3(posOrX, yOrBlock, z), block);
@@ -17807,7 +17882,7 @@ var MineRenderWorld = class {
       }
     }
   }
-  /** Replaces a chunk column's blocks and biome samples and, with `renderEntities`, its supported saved mobs. */
+  /** Replaces a chunk column's blocks, biomes, and saved light and, with `renderEntities`, its supported saved mobs. */
   async placeChunk(chunk, executor) {
     if (![chunk.x, chunk.z].every(Number.isSafeInteger)) {
       throw new RangeError("Chunk column coordinates must be safe integers");
@@ -17815,6 +17890,11 @@ var MineRenderWorld = class {
     if (!chunk.sections.every((section) => Number.isSafeInteger(section.y))) {
       throw new RangeError("Chunk section coordinates must be safe integers");
     }
+    const lights = /* @__PURE__ */ new Map();
+    for (const section of chunk.sections) {
+      const light = section.light ?? (chunk.lightValid === true ? {} : void 0);
+      if (light) lights.set(section.y, copySectionLight(light));
+    }
     this.entities?.clearColumn(chunk.x, chunk.z);
     const placeEntities = this.entities?.prepare(chunk.entities, [chunk.x, chunk.z]);
     const changes = /* @__PURE__ */ new Map();
@@ -17830,6 +17910,15 @@ var MineRenderWorld = class {
     }
     try {
       await this.clearChunkColumn(chunk.x, chunk.z);
+      const columnKey = `${chunk.x}_${chunk.z}`;
+      if (lights.size) this.light.set(columnKey, lights);
+      for (const [y, light] of lights) {
+        if (light.sky) this.highestSkySection.set(columnKey, Math.max(y, this.highestSkySection.get(columnKey) ?? -Infinity));
+      }
+      if (chunk.lightValid !== void 0) this.lightValidity.set(columnKey, chunk.lightValid);
+      if (this.savedLighting) {
+        for (const y of lights.keys()) this.markSectionChanged({ x: chunk.x, y, z: chunk.z });
+      }
       for (const section of chunk.sections) {
         if (section.biomes) {
           const position = new import_three42.Vector3(chunk.x * 16, section.y * 16, chunk.z * 16);
@@ -17899,6 +17988,12 @@ var MineRenderWorld = class {
   }
   async clearChunkColumn(x, z) {
     this.biomes.delete(`${x}_${z}`);
+    if (this.savedLighting) {
+      for (const y of this.light.get(`${x}_${z}`)?.keys() ?? []) this.markSectionChanged({ x, y, z });
+    }
+    this.light.delete(`${x}_${z}`);
+    this.lightValidity.delete(`${x}_${z}`);
+    this.highestSkySection.delete(`${x}_${z}`);
     const previous = [...this._chunks.entries()].filter(([, section]) => section.x === x && section.z === z);
     for (const [key, section] of previous) {
       this._chunks.delete(key);
@@ -17908,7 +18003,8 @@ var MineRenderWorld = class {
     }
   }
   markSectionChanged(chunk) {
-    if (this._chunks.get(`${chunk.x}_${chunk.y}_${chunk.z}`) === chunk) this.pendingCulling.set(chunk, "all");
+    const current = this._chunks.get(`${chunk.x}_${chunk.y}_${chunk.z}`);
+    if (current && current === chunk) this.pendingCulling.set(current, "all");
     for (let dy = -1; dy <= 1; dy++) {
       for (let dz = -1; dz <= 1; dz++) {
         for (let dx = -1; dx <= 1; dx++) {
@@ -17936,6 +18032,9 @@ var MineRenderWorld = class {
     const chunks = [...this._chunks.values()];
     this._chunks.clear();
     this.biomes.clear();
+    this.light.clear();
+    this.lightValidity.clear();
+    this.highestSkySection.clear();
     for (const chunk of chunks) {
       await chunk.dispose();
     }
@@ -17998,6 +18097,7 @@ var MineRenderWorld = class {
               }
             }
             for (const [index, mask] of masks) await chunk.setCullMaskIndex(index, mask);
+            await chunk.refreshLight(indices === "all" ? void 0 : indices);
           }
           await Promise.all(batch.map(([chunk]) => chunk.rebuildSectionMesh()));
         }
@@ -18038,7 +18138,23 @@ var MineRenderWorld = class {
           }
           await chunk.refreshBiomes();
           await this._chunks.get(`${x}_${y + 1}_${z}`)?.refreshBiomes();
-        }
+        },
+        this.savedLighting ? (x2, y2, z2) => this.lightLevelAt(x2, y2, z2) : void 0,
+        async () => {
+          if (this._chunks.get(key) !== chunk) return;
+          const columnKey = `${x}_${z}`, column = this.light.get(columnKey);
+          if (!column?.delete(y)) return;
+          if (!column.size) this.light.delete(columnKey);
+          this.highestSkySection.delete(columnKey);
+          for (const [y2, light] of column) {
+            if (light.sky) this.highestSkySection.set(columnKey, Math.max(y2, this.highestSkySection.get(columnKey) ?? -Infinity));
+          }
+          if (this.savedLighting) {
+            this.markSectionChanged(chunk);
+            await this.updateCulling([]);
+          }
+        },
+        this.ambientLight
       );
       this._chunks.set(key, chunk);
     }
@@ -18087,12 +18203,43 @@ init_Materials();
 
 // src/world/SectionGeometry.ts
 init_FluidQuads();
+
+// src/world/_light/FaceLight.ts
+function lightBrightness(level, ambient = 0) {
+  if (level === 255) return 1;
+  const curve = level / (60 - 3 * level);
+  return curve + ambient * (1 - curve);
+}
+function quadLightIndex(positions, normals, quad) {
+  const start = quad * 12;
+  let axis = 0;
+  if (Math.abs(normals[start + 1]) > Math.abs(normals[start + axis])) axis = 1;
+  if (Math.abs(normals[start + 2]) > Math.abs(normals[start + axis])) axis = 2;
+  const positive2 = normals[start + axis] > 0;
+  const boundary = positive2 ? 8 : -8;
+  for (let vertex = 0; vertex < 4; vertex++) {
+    if (Math.abs(positions[start + vertex * 3 + axis] - boundary) > 16e-4) return 0;
+  }
+  return axis * 2 + (positive2 ? 1 : 2);
+}
+function fluidLightLevel(center, neighbor) {
+  return Math.max(center === 255 ? 15 : center, neighbor === 255 ? 15 : neighbor);
+}
+var LIGHT_SAMPLE_OFFSETS = [0, 1, -1, 324, -324, 18, -18];
+
+// src/world/SectionGeometry.ts
 function buildSectionGeometry(input) {
-  const { count, indices, templates, cullMasks, templateData, atlases, maxAtlasSize, fluids } = input;
+  const { count, indices, templates, cullMasks, templateData, atlases, maxAtlasSize, fluids, light, ambientLight } = input;
   if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("Section atlas size must be a positive integer");
   if (count > indices.length || count > templates.length || count > cullMasks.length) throw new RangeError("Section entry count exceeds its arrays");
   if (fluids && fluids.cells.length !== 5832) throw new RangeError("Section fluid cells must cover an 18\xD718\xD718 neighborhood");
   if (fluids?.waterTints && fluids.waterTints.length !== 4096 * 3) throw new RangeError("Section water tints must contain RGB for 4096 cells");
+  if (light && (light.length !== 5832 || light.some((level) => level > 15 && level !== 255))) {
+    throw new RangeError("Section light must cover an 18\xD718\xD718 neighborhood with levels from 0 to 15 or 255");
+  }
+  if (ambientLight !== void 0 && (!Number.isFinite(ambientLight) || ambientLight < 0 || ambientLight > 1)) {
+    throw new RangeError("Section ambient light must be a number from 0 to 1");
+  }
   for (const template of templateData) {
     const { quads } = template;
     if (template.positions.length !== quads * 12 || template.normals.length !== quads * 12 || template.uvs.length !== quads * 8 || template.uvBounds.length !== quads * 16 || template.colors.length !== quads * 12 || template.indices.length !== quads * 6 || template.cullFaces.length !== quads) {
@@ -18197,8 +18344,10 @@ function buildSectionGeometry(input) {
       const offsetX = indices[entry] % 16 * 16;
       const offsetY = Math.floor(indices[entry] / 256) * 16;
       const offsetZ = Math.floor(indices[entry] / 16) % 16 * 16;
+      const lightIndex = (offsetY / 16 + 1) * 324 + (offsetZ / 16 + 1) * 18 + offsetX / 16 + 1;
       for (let quad = 0; quad < template.quads; quad++) {
         if (cullMasks[entry] & template.cullFaces[quad]) continue;
+        const brightness = light ? lightBrightness(light[lightIndex + LIGHT_SAMPLE_OFFSETS[quadLightIndex(template.positions, template.normals, quad)]], ambientLight) : 1;
         const start = vertex;
         for (let corner = 0; corner < 4; corner++, vertex++) {
           const source = quad * 4 + corner;
@@ -18214,9 +18363,9 @@ function buildSectionGeometry(input) {
           uvBounds[vertex * 4 + 1] = mapV(template.uvBounds[source * 4 + 1]);
           uvBounds[vertex * 4 + 2] = mapU(template.uvBounds[source * 4 + 2]);
           uvBounds[vertex * 4 + 3] = mapV(template.uvBounds[source * 4 + 3]);
-          colors[vertex * 3] = template.colors[source * 3];
-          colors[vertex * 3 + 1] = template.colors[source * 3 + 1];
-          colors[vertex * 3 + 2] = template.colors[source * 3 + 2];
+          colors[vertex * 3] = template.colors[source * 3] * brightness;
+          colors[vertex * 3 + 1] = template.colors[source * 3 + 1] * brightness;
+          colors[vertex * 3 + 2] = template.colors[source * 3 + 2] * brightness;
         }
         for (let corner = 0; corner < 6; corner++) outputIndices[indexOffset++] = start + template.indices[quad * 6 + corner];
       }
@@ -18226,8 +18375,13 @@ function buildSectionGeometry(input) {
       const placement = page.placements[0];
       const mapU = (u) => (placement.x + u * atlas.width) / page.width;
       const mapV = (v) => 1 - (placement.y + (1 - v) * atlas.height) / page.height;
+      const lightIndex = (y + 1) * 324 + (z + 1) * 18 + x + 1;
       for (let quad = 0; quad < quads.sprites.length; quad++) {
         const rect = quads.sprites[quad] === 0 ? data.still : data.flow;
+        const brightness = light ? lightBrightness(fluidLightLevel(
+          light[lightIndex],
+          light[lightIndex + (quads.normals[quad * 12 + 1] < 0 ? -324 : 324)]
+        ), ambientLight) : 1;
         const start = vertex;
         for (let corner = 0; corner < 4; corner++, vertex++) {
           const source = quad * 4 + corner;
@@ -18245,7 +18399,9 @@ function buildSectionGeometry(input) {
             mapU((rect[0] + rect[2]) / atlas.width),
             mapV(1 - rect[1] / atlas.height)
           ], vertex * 4);
-          colors.set(tint, vertex * 3);
+          colors[vertex * 3] = tint[0] * brightness;
+          colors[vertex * 3 + 1] = tint[1] * brightness;
+          colors[vertex * 3 + 2] = tint[2] * brightness;
         }
         outputIndices.set([start, start + 1, start + 2, start, start + 2, start + 3], indexOffset);
         indexOffset += 6;
@@ -18313,7 +18469,7 @@ var SectionWorker = _SectionWorker;
 // src/world/SectionMesh.ts
 var templateCache = /* @__PURE__ */ new WeakMap();
 var WATER_TINT = new import_three43.Color(4159204).toArray();
-function toInput(entries, maxAtlasSize, fluids) {
+function toInput(entries, maxAtlasSize, fluids, lighting) {
   if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("Section atlas size must be a positive integer");
   const atlases = [];
   const atlasIds = /* @__PURE__ */ new Map();
@@ -18325,7 +18481,8 @@ function toInput(entries, maxAtlasSize, fluids) {
     cullMasks: new Uint8Array(entries.length),
     templateData: [],
     atlases: [],
-    maxAtlasSize
+    maxAtlasSize,
+    ...lighting
   };
   for (let i = 0; i < entries.length; i++) {
     const { index, template, cullMask } = entries[i];
@@ -18413,13 +18570,13 @@ var SectionMesh = class _SectionMesh extends import_three43.Group {
     this.ownedMeshes = [];
   }
   /** Builds section-local meshes from visible quads. `maxAtlasSize` limits each atlas dimension in pixels. */
-  static build(entries, maxAtlasSize = 2048, fluids) {
-    const { input, atlases } = toInput(entries, maxAtlasSize, fluids);
+  static build(entries, maxAtlasSize = 2048, fluids, lighting) {
+    const { input, atlases } = toInput(entries, maxAtlasSize, fluids, lighting);
     return this.fromPages(buildSectionGeometry(input), atlases);
   }
   /** Builds section-local meshes in a browser worker when available, with synchronous fallback. */
-  static async buildAsync(entries, maxAtlasSize = 2048, fluids) {
-    const { input, atlases } = toInput(entries, maxAtlasSize, fluids);
+  static async buildAsync(entries, maxAtlasSize = 2048, fluids, lighting) {
+    const { input, atlases } = toInput(entries, maxAtlasSize, fluids, lighting);
     const worker = SectionWorker.shared();
     const pages = worker ? await worker.build(input).catch(() => buildSectionGeometry(input)) : buildSectionGeometry(input);
     return this.fromPages(pages, atlases);
@@ -18489,12 +18646,15 @@ init_FluidQuads();
 init_CubeFace();
 var WATER_TINT2 = new import_three44.Color(4159204).toArray();
 var Chunk = class _Chunk {
-  constructor(scene, x, y, z, onBlocksChanged, sectionModels, neighborCell, biomeAt, onBiomesChanged) {
+  constructor(scene, x, y, z, onBlocksChanged, sectionModels, neighborCell, biomeAt, onBiomesChanged, lightAt, onLightCleared, ambientLight = 0) {
     this.onBlocksChanged = onBlocksChanged;
     this.sectionModels = sectionModels;
     this.neighborCell = neighborCell;
     this.biomeAt = biomeAt;
     this.onBiomesChanged = onBiomesChanged;
+    this.lightAt = lightAt;
+    this.onLightCleared = onLightCleared;
+    this.ambientLight = ambientLight;
     this.data = new ChunkData();
     this.renderedBlocks = /* @__PURE__ */ new Map();
     this.sectionBlocks = /* @__PURE__ */ new Map();
@@ -18776,6 +18936,13 @@ var Chunk = class _Chunk {
   positionAt(index) {
     return [this.x * 16 + index % 16, this.y * 16 + Math.floor(index / 256), this.z * 16 + Math.floor(index / 16) % 16];
   }
+  /** Refreshes saved lighting after adjacent columns load or unload, including columns with only light data. */
+  async refreshLight(indices) {
+    if (!this.lightAt) return;
+    for (const index of indices ?? this.renderedBlocks.keys()) {
+      if (this.renderedBlocks.has(index)) this.meshDirty = true;
+    }
+  }
   biomePosition(index, blockState3, stored) {
     const position = this.positionAt(index), name = blockState3.key?.toNamespacedString();
     if (stored.properties?.half === "upper" && (name === "minecraft:tall_grass" || name === "minecraft:large_fern")) position[1]--;
@@ -18953,7 +19120,23 @@ var Chunk = class _Chunk {
         fluids[kind] = await this.sectionModels.fluidAtlas(kind, state?.key?.root);
       }
     }
-    const next = entries.length || fluids ? await SectionMesh.buildAsync(entries, this.sectionModels.maxAtlasSize, fluids) : void 0;
+    let light;
+    if (this.lightAt) {
+      light = new Uint8Array(18 * 18 * 18);
+      for (let y = -1; y <= 16; y++) {
+        for (let z = -1; z <= 16; z++) {
+          for (let x = -1; x <= 16; x++) {
+            light[(y + 1) * 324 + (z + 1) * 18 + x + 1] = this.lightAt(this.x * 16 + x, this.y * 16 + y, this.z * 16 + z);
+          }
+        }
+      }
+    }
+    const next = entries.length || fluids ? await SectionMesh.buildAsync(
+      entries,
+      this.sectionModels.maxAtlasSize,
+      fluids,
+      light ? { light, ambientLight: this.ambientLight } : void 0
+    ) : void 0;
     if (generation !== this.meshGeneration) {
       next?.dispose();
       return;
@@ -18985,6 +19168,7 @@ var Chunk = class _Chunk {
     this.biomes = void 0;
     if (notify) {
       await this.onBiomesChanged?.(void 0);
+      await this.onLightCleared?.();
       await this.onBlocksChanged?.(positions);
     }
   }