minecraft-renderer 0.1.106 → 0.1.108

package/src/wasm-mesher/worker/mesherWasmOwnerLight.test.ts

@@ -0,0 +1,161 @@
+//@ts-nocheck
+import { describe, expect, it } from 'vitest'
+import { createEmptyLightCache, isLightSectionPresent, worldSectionMaskBit, type ParsedUpdateLight } from './mesherWasmLightMerge'
+import {
+  applyOwnerPublicationToColumnCaches,
+  applyPackedOwnerSectionsToLightCache,
+  applyRawLightPacketToCaches,
+  detachDisplayOnOwnerTakeover,
+  ownerDeltaSectionWorldYs,
+  revertDisplayToIncoming
+} from './mesherWasmOwnerLight'
+import { packUnpackedLightSection } from '../../mesher-shared/lightNibblePack'
+
+describe('applyPackedOwnerSectionsToLightCache', () => {
+  it('unpacks owner packed channels into the worker column cache without touching other sections', () => {
+    const cache = createEmptyLightCache(16)
+    const unpacked = new Uint8Array(4096).fill(0)
+    unpacked[0] = 9
+    const packed = packUnpackedLightSection(unpacked)
+    const next = applyPackedOwnerSectionsToLightCache(cache, [{ sx: 0, sy: 64, sz: 0, blockLight: packed, skyLight: packed }], 0, 0, 0, 16)
+    expect(next.blockLight[4 * 4096]).toBe(9)
+    expect(next.skyLight[4 * 4096]).toBe(9)
+    expect(isLightSectionPresent(next.blockPresent, worldSectionMaskBit(4))).toBe(true)
+    expect(next.blockLight[0]).toBe(0)
+    expect(isLightSectionPresent(next.blockPresent, worldSectionMaskBit(0))).toBe(false)
+  })
+
+  it('writes a section delta in place without cloning the full column arrays', () => {
+    const cache = createEmptyLightCache(16)
+    cache.blockLight[0] = 4
+    cache.skyLight[0] = 7
+    const blockRef = cache.blockLight
+    const skyRef = cache.skyLight
+    const unpacked = new Uint8Array(4096).fill(0)
+    unpacked[0] = 9
+    const packed = packUnpackedLightSection(unpacked)
+    const next = applyPackedOwnerSectionsToLightCache(cache, [{ sx: 0, sy: 64, sz: 0, blockLight: packed, skyLight: packed }], 0, 0, 0, 16)
+    expect(next.blockLight).toBe(blockRef)
+    expect(next.skyLight).toBe(skyRef)
+    expect(next.blockLight[0]).toBe(4)
+    expect(next.skyLight[0]).toBe(7)
+    expect(next.blockLight[4 * 4096]).toBe(9)
+  })
+
+  it('lists only the published section Y origins for a column', () => {
+    expect(
+      ownerDeltaSectionWorldYs(
+        [
+          { sx: 0, sy: 64, sz: 0 },
+          { sx: 16, sy: 64, sz: 0 },
+          { sx: 0, sy: 80, sz: 0 }
+        ],
+        0,
+        0
+      )
+    ).toEqual([64, 80])
+  })
+})
+
+describe('applyRawLightPacketToCaches', () => {
+  function parsedBlock(sectionIndex: number, value: number): ParsedUpdateLight {
+    const blockLight = new Uint8Array(16 * 4096)
+    blockLight.fill(value, sectionIndex * 4096, (sectionIndex + 1) * 4096)
+    const blockLightMask = new Uint32Array(2)
+    blockLightMask[0] = 1 << (sectionIndex + 1)
+    return {
+      x: 0,
+      z: 0,
+      trustEdges: true,
+      numSections: 16,
+      skyLight: new Uint8Array(16 * 4096),
+      blockLight,
+      skyLightMask: new Uint32Array(2),
+      emptySkyLightMask: new Uint32Array(2),
+      blockLightMask,
+      emptyBlockLightMask: new Uint32Array(2)
+    }
+  }
+
+  it('writes incoming server light into the display cache when the owner does not own the column', () => {
+    const result = applyRawLightPacketToCaches({
+      ownerOwnsColumn: false,
+      incoming: undefined,
+      display: undefined,
+      parsed: parsedBlock(4, 9)
+    })
+    expect(result.dirtyDisplay).toBe(true)
+    expect(result.display?.blockLight[4 * 4096]).toBe(9)
+    expect(result.incoming.blockLight[4 * 4096]).toBe(9)
+  })
+
+  it('keeps incoming server light separate and does not overwrite owner display cache', () => {
+    const display = createEmptyLightCache(16)
+    display.blockLight[4 * 4096] = 3
+    const result = applyRawLightPacketToCaches({
+      ownerOwnsColumn: true,
+      incoming: undefined,
+      display,
+      parsed: parsedBlock(4, 9)
+    })
+    expect(result.dirtyDisplay).toBe(false)
+    expect(result.display?.blockLight[4 * 4096]).toBe(3)
+    expect(result.incoming.blockLight[4 * 4096]).toBe(9)
+  })
+})
+
+describe('owner takeover incoming/display split', () => {
+  it('clones display once so an in-place owner write does not change incoming server light', () => {
+    const incoming = createEmptyLightCache(16)
+    incoming.blockLight[4 * 4096] = 9
+    const aliased = detachDisplayOnOwnerTakeover({ incoming, display: incoming })
+    expect(aliased.display).not.toBe(aliased.incoming)
+
+    const unpacked = new Uint8Array(4096).fill(0)
+    unpacked[0] = 3
+    const packed = packUnpackedLightSection(unpacked)
+    const applied = applyOwnerPublicationToColumnCaches({
+      incoming: aliased.incoming,
+      display: aliased.display,
+      sections: [{ sx: 0, sy: 64, sz: 0, blockLight: packed }],
+      worldMinY: 0,
+      columnWorldX: 0,
+      columnWorldZ: 0,
+      numSections: 16
+    })
+    expect(applied.incoming?.blockLight[4 * 4096]).toBe(9)
+    expect(applied.display.blockLight[4 * 4096]).toBe(3)
+    expect(applied.display.blockLight).not.toBe(applied.incoming?.blockLight)
+  })
+
+  it('does not clone the full column on a second owner delta', () => {
+    const incoming = createEmptyLightCache(16)
+    incoming.blockLight[4 * 4096] = 9
+    const first = detachDisplayOnOwnerTakeover({ incoming, display: incoming })
+    const displayRef = first.display!.blockLight
+    const unpacked = new Uint8Array(4096).fill(0)
+    unpacked[0] = 3
+    const packed = packUnpackedLightSection(unpacked)
+    const second = applyOwnerPublicationToColumnCaches({
+      incoming: first.incoming,
+      display: first.display,
+      sections: [{ sx: 0, sy: 64, sz: 0, blockLight: packed }],
+      worldMinY: 0,
+      columnWorldX: 0,
+      columnWorldZ: 0,
+      numSections: 16
+    })
+    expect(second.display.blockLight).toBe(displayRef)
+  })
+
+  it('reverts display to last server incoming without zeroing omitted sections', () => {
+    const incoming = createEmptyLightCache(16)
+    incoming.blockLight[4 * 4096] = 9
+    const display = createEmptyLightCache(16)
+    display.blockLight[4 * 4096] = 3
+    const reverted = revertDisplayToIncoming({ incoming, display })
+    expect(reverted.display?.blockLight[4 * 4096]).toBe(9)
+    expect(reverted.incoming?.blockLight[4 * 4096]).toBe(9)
+    expect(isLightSectionPresent(reverted.incoming!.blockPresent, worldSectionMaskBit(0))).toBe(false)
+  })
+})

package/src/wasm-mesher/worker/mesherWasmOwnerLight.ts

@@ -0,0 +1,112 @@
+//@ts-nocheck
+import {
+  cloneLightCache,
+  createEmptyLightCache,
+  maskBitSet,
+  mergeUpdateLight,
+  worldSectionMaskBit,
+  type ParsedUpdateLight,
+  type UpdateLightColumnCache
+} from './mesherWasmLightMerge'
+import { unpackPackedLightSection } from '../../mesher-shared/lightNibblePack'
+
+export type OwnerPackedSection = {
+  sx: number
+  sy: number
+  sz: number
+  blockLight: Uint8Array
+  skyLight?: Uint8Array
+}
+
+/** World-origin Y of published sections that belong to this column. */
+export function ownerDeltaSectionWorldYs(sections: Array<{ sx: number; sy: number; sz: number }>, columnWorldX: number, columnWorldZ: number): number[] {
+  const colSx = Math.floor(columnWorldX / 16) * 16
+  const colSz = Math.floor(columnWorldZ / 16) * 16
+  const ys: number[] = []
+  const seen = new Set<number>()
+  for (const section of sections) {
+    if (section.sx !== colSx || section.sz !== colSz) continue
+    if (seen.has(section.sy)) continue
+    seen.add(section.sy)
+    ys.push(section.sy)
+  }
+  return ys
+}
+
+/** Write owner packed 2048-byte channels into the worker's unpacked column cache. */
+export function applyPackedOwnerSectionsToLightCache(
+  cache: UpdateLightColumnCache | undefined,
+  sections: OwnerPackedSection[],
+  worldMinY: number,
+  columnWorldX: number,
+  columnWorldZ: number,
+  numSections: number
+): UpdateLightColumnCache {
+  const next = cache ?? createEmptyLightCache(numSections)
+  const colSx = Math.floor(columnWorldX / 16) * 16
+  const colSz = Math.floor(columnWorldZ / 16) * 16
+  for (const section of sections) {
+    if (section.sx !== colSx || section.sz !== colSz) continue
+    const sectionIndex = Math.floor((section.sy - worldMinY) / 16)
+    if (sectionIndex < 0 || sectionIndex >= next.numSections) continue
+    const start = sectionIndex * 4096
+    const block = unpackPackedLightSection(section.blockLight)
+    next.blockLight.set(block, start)
+    maskBitSet(next.blockPresent, worldSectionMaskBit(sectionIndex))
+    if (section.skyLight) {
+      const sky = unpackPackedLightSection(section.skyLight)
+      next.skyLight.set(sky, start)
+      maskBitSet(next.skyPresent, worldSectionMaskBit(sectionIndex))
+    }
+  }
+  return next
+}
+
+export function applyRawLightPacketToCaches(opts: {
+  ownerOwnsColumn: boolean
+  incoming: UpdateLightColumnCache | undefined
+  display: UpdateLightColumnCache | undefined
+  parsed: ParsedUpdateLight
+}): { incoming: UpdateLightColumnCache; display: UpdateLightColumnCache | undefined; dirtyDisplay: boolean } {
+  const incoming = mergeUpdateLight(opts.incoming, opts.parsed)
+  if (opts.ownerOwnsColumn) {
+    return { incoming, display: opts.display, dirtyDisplay: false }
+  }
+  return { incoming, display: incoming, dirtyDisplay: true }
+}
+
+/** First owner takeover: clone incoming onto display once. Later deltas write display in place. */
+export function detachDisplayOnOwnerTakeover(opts: { incoming: UpdateLightColumnCache | undefined; display: UpdateLightColumnCache | undefined }): {
+  incoming: UpdateLightColumnCache | undefined
+  display: UpdateLightColumnCache | undefined
+} {
+  if (!opts.incoming) return { incoming: undefined, display: opts.display }
+  if (opts.display == null || opts.display === opts.incoming) {
+    return { incoming: opts.incoming, display: cloneLightCache(opts.incoming) }
+  }
+  return { incoming: opts.incoming, display: opts.display }
+}
+
+export function applyOwnerPublicationToColumnCaches(opts: {
+  incoming: UpdateLightColumnCache | undefined
+  display: UpdateLightColumnCache | undefined
+  sections: OwnerPackedSection[]
+  worldMinY: number
+  columnWorldX: number
+  columnWorldZ: number
+  numSections: number
+}): { incoming: UpdateLightColumnCache | undefined; display: UpdateLightColumnCache } {
+  const detached = detachDisplayOnOwnerTakeover({ incoming: opts.incoming, display: opts.display })
+  return {
+    incoming: detached.incoming,
+    display: applyPackedOwnerSectionsToLightCache(detached.display, opts.sections, opts.worldMinY, opts.columnWorldX, opts.columnWorldZ, opts.numSections)
+  }
+}
+
+export function revertDisplayToIncoming(opts: { incoming: UpdateLightColumnCache | undefined; display: UpdateLightColumnCache | undefined }): {
+  incoming: UpdateLightColumnCache | undefined
+  display: UpdateLightColumnCache | undefined
+} {
+  if (!opts.incoming) return { incoming: undefined, display: opts.display }
+  return { incoming: opts.incoming, display: cloneLightCache(opts.incoming) }
+}

package/src/wasm-mesher/worker/mesherWasmTickParseCache.ts

@@ -0,0 +1,45 @@
+//@ts-nocheck
+/**
+ * Tick-scoped cache for WASM column parses in the two-step mesh path.
+ *
+ * `getOrConvertColumn` only covers the JS walk. The three WASM converters
+ * (`convertRawMapChunkToWasm` / `convertParsedV17ToWasm` / `convertParsedV16ToWasm`)
+ * used to re-parse the same neighbour for every dirty target column in a tick.
+ * This map lives for one `processColumnTick` and is dropped in `finally`.
+ *
+ * Same contract as `getOrConvertColumn`: cached values are `set()` sources /
+ * WASM inputs only. Consumers must not mutate them, so we do not copy.
+ */
+
+let cache: Map<string, unknown> | null = null
+let hits = 0
+let misses = 0
+
+export function beginTickWasmParseCache(): void {
+  cache = new Map()
+  hits = 0
+  misses = 0
+}
+
+export function endTickWasmParseCache(): void {
+  cache = null
+}
+
+export function getTickWasmParseStats(): { hits: number; misses: number } {
+  return { hits, misses }
+}
+
+export function getOrConvertTickWasmParse<T>(key: string, convert: () => T | null): { result: T | null; hit: boolean } {
+  if (!cache) {
+    misses++
+    return { result: convert(), hit: false }
+  }
+  if (cache.has(key)) {
+    hits++
+    return { result: cache.get(key) as T, hit: true }
+  }
+  const result = convert()
+  misses++
+  if (result != null) cache.set(key, result)
+  return { result, hit: false }
+}

package/src/wasm-mesher/worker/mesherWasmTickSchedule.ts

@@ -0,0 +1,44 @@
+//@ts-nocheck
+/**
+ * Mesh ticks. Bulk work is polled on an interval. An urgent dirty kicks the
+ * same runner on the next turn, and a kick during an in-progress tick reruns
+ * after that tick yields instead of waiting for the next poll.
+ */
+
+export const BULK_MESH_INTERVAL_MS = 50
+
+export function createMeshTickScheduler(run: () => Promise<void> | void) {
+  let running = false
+  let rerun = false
+  let timer: ReturnType<typeof setTimeout> | null = null
+
+  const pump = async () => {
+    timer = null
+    if (running) {
+      rerun = true
+      return
+    }
+    running = true
+    try {
+      do {
+        rerun = false
+        await run()
+      } while (rerun)
+    } finally {
+      running = false
+    }
+  }
+
+  return {
+    kick() {
+      if (running) {
+        rerun = true
+        return
+      }
+      if (timer != null) return
+      timer = setTimeout(() => {
+        void pump()
+      }, 0)
+    }
+  }
+}

package/src/wasm-mesher/worker/mesherWasmTopologyPostCache.ts

@@ -0,0 +1,63 @@
+//@ts-nocheck
+/**
+ * Topology-keyed cache for the per-section visGraph + block-entity post-pass.
+ *
+ * Wave-2 covering remeshes carry the same `topologyRevision` as wave-1, so the
+ * 4096-cell walk can be reused. A new revision always recomputes. Legacy /
+ * unversioned jobs (no revision) never cache.
+ */
+
+export const TOPOLOGY_POST_CACHE_LIMIT = 1024
+
+export type TopologyPostPayload = {
+  visibilitySet: unknown
+  signs: Record<string, unknown>
+  heads: Record<string, unknown>
+  banners: Record<string, unknown>
+}
+
+type CacheEntry = {
+  topologyRevision: number
+  payload: TopologyPostPayload
+}
+
+const cache = new Map<string, CacheEntry>()
+
+export function getOrComputeTopologyPost<T extends TopologyPostPayload>(
+  key: string,
+  topologyRevision: number | undefined,
+  compute: () => T
+): { payload: T; hit: boolean } {
+  if (topologyRevision == null) {
+    return { payload: compute(), hit: false }
+  }
+  const existing = cache.get(key)
+  if (existing && existing.topologyRevision === topologyRevision) {
+    cache.delete(key)
+    cache.set(key, existing)
+    return { payload: existing.payload as T, hit: true }
+  }
+  const payload = compute()
+  cache.set(key, { topologyRevision, payload })
+  evictIfNeeded()
+  return { payload, hit: false }
+}
+
+export function clearTopologyPostCacheColumn(x: number, z: number): void {
+  for (const key of [...cache.keys()]) {
+    const [sx, , sz] = key.split(',').map(Number)
+    if (sx === x && sz === z) cache.delete(key)
+  }
+}
+
+export function clearTopologyPostCache(): void {
+  cache.clear()
+}
+
+function evictIfNeeded(): void {
+  while (cache.size > TOPOLOGY_POST_CACHE_LIMIT) {
+    const oldest = cache.keys().next().value
+    if (oldest == null) break
+    cache.delete(oldest)
+  }
+}

package/src/worldView/types.ts

@@ -37,6 +37,7 @@ export interface LoadChunkData {
 export interface UnloadChunkData {
   x: number
   z: number
+  preserveClientLight?: boolean
 }
 
 /**
@@ -144,6 +145,8 @@ export type WorldViewEvents = {
   entityMoved: (data: any) => void
   playerEntity: (data: any) => void
   time: (data: number) => void
+  /** 0 = full moon … 7 (vanilla order). Hosts should re-emit on day change (`bot.time.moonPhase`). */
+  moonPhase: (phase: number) => void
   renderDistance: (viewDistance: number) => void
   blockEntities: (data: Record<string, any> | { blockEntities: Record<string, any> }) => void
   markAsLoaded: (data: ChunkPos) => void

package/src/worldView/worldView.geometryReload.test.ts

@@ -0,0 +1,68 @@
+//@ts-nocheck
+import { describe, expect, it, vi } from 'vitest'
+import { WorldView } from './worldView'
+
+const column = () => ({ toJson: () => '{}', minY: 0, worldHeight: 256 })
+function setup(getColumnAt = vi.fn(async () => column())) {
+  const view = new WorldView({ getColumnAt, setBlockStateId: vi.fn() }, 4)
+  view.loadedChunks = { '0,0': true, '16,0': true }
+  return { view, getColumnAt }
+}
+
+describe('geometry-only column reload', () => {
+  it('retains membership and requests light preservation', async () => {
+    const { view } = setup()
+    const unload = vi.fn()
+    const load = vi.fn()
+    view.on('unloadChunk', unload)
+    view.on('loadChunk', load)
+    await view.reloadColumnGeometry()
+    expect(view.loadedChunks).toEqual({ '0,0': true, '16,0': true })
+    expect(unload.mock.calls.map(([data]) => data)).toEqual([
+      { x: 0, z: 0, preserveClientLight: true },
+      { x: 16, z: 0, preserveClientLight: true }
+    ])
+    expect(load).toHaveBeenCalledTimes(2)
+  })
+
+  it('does not resurrect a column unloaded during an asynchronous fetch', async () => {
+    let resolve!: (value: ReturnType<typeof column>) => void
+    const pending = new Promise<ReturnType<typeof column>>(r => {
+      resolve = r
+    })
+    const { view } = setup(vi.fn(() => pending))
+    view.loadedChunks = { '0,0': true }
+    const load = vi.fn()
+    view.on('loadChunk', load)
+    const reload = view.reloadColumnGeometry()
+    expect(view.reloadColumnGeometry()).toBe(reload)
+    view.unloadChunk({ x: 0, z: 0 })
+    resolve(column())
+    await reload
+    expect(load).not.toHaveBeenCalled()
+    expect(view.loadedChunks['0,0']).toBeUndefined()
+  })
+
+  it('cleans up failed columns and continues loading the rest', async () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      const get = vi.fn().mockRejectedValueOnce(new Error('fetch failed')).mockResolvedValue(column())
+      const { view } = setup(get)
+      const load = vi.fn()
+      view.on('loadChunk', load)
+      await view.reloadColumnGeometry()
+      expect(view.loadedChunks).toEqual({ '16,0': true })
+      expect(load).toHaveBeenCalledTimes(1)
+      expect(warn).toHaveBeenCalledOnce()
+    } finally {
+      warn.mockRestore()
+    }
+  })
+
+  it('truly unloads columns outside the current range or missing from the world', async () => {
+    const { view } = setup(vi.fn(async () => null) as any)
+    view.loadedChunks['160,0'] = true
+    await view.reloadColumnGeometry()
+    expect(view.loadedChunks).toEqual({})
+  })
+})

package/src/worldView/worldView.spiral.test.ts

@@ -11,7 +11,7 @@ describe('WorldView._loadChunks spiral guard', () => {
     }
     const view = new WorldView(world, 8, new Vec3(0, 64, 0))
     view.addWaitTime = 0
-    view.loadChunk = vi.fn(async () => {})
+    view.loadChunk = vi.fn(async () => true)
 
     const positions = [new Vec3(0, 0, 0)]
     const spiralA = view._loadChunks(positions, new Vec3(0, 64, 0))

package/src/worldView/worldView.ts

@@ -115,6 +115,8 @@ export class WorldView extends (EventEmitter as new () => TypedEmitter<WorldView
   gotPanicLastTime = false
   panicChunksReload = () => {}
   loadedChunks: Record<ChunkPosKey, boolean> = {}
+  private columnUnloadEpoch = new Map<string, number>()
+  private geometryReload?: Promise<void>
   inLoading = false
   chunkReceiveTimes: number[] = []
   lastChunkReceiveTime = 0
@@ -201,6 +203,9 @@ export class WorldView extends (EventEmitter as new () => TypedEmitter<WorldView
     if (bot?.time?.timeOfDay !== undefined) {
       this.emit('time', bot.time.timeOfDay)
     }
+    if (typeof bot?.time?.moonPhase === 'number') {
+      this.emit('moonPhase', bot.time.moonPhase)
+    }
     if (bot?.entity) {
       this.emit('playerEntity', bot.entity)
     }
@@ -273,7 +278,9 @@ export class WorldView extends (EventEmitter as new () => TypedEmitter<WorldView
   /**
    * Load a chunk at the given position.
    */
-  async loadChunk(pos: { x: number; z: number; y?: number }, isLightUpdate = false, reason = 'spiral'): Promise<void> {
+  async loadChunk(pos: { x: number; z: number; y?: number }, isLightUpdate = false, reason = 'spiral'): Promise<boolean> {
+    const key = `${pos.x},${pos.z}`
+    const epoch = this.columnUnloadEpoch.get(key) ?? 0
     const [botX, botZ] = chunkPos(this.lastPos)
     const dx = Math.abs(botX - Math.floor(pos.x / 16))
     const dz = Math.abs(botZ - Math.floor(pos.z / 16))
@@ -281,6 +288,14 @@ export class WorldView extends (EventEmitter as new () => TypedEmitter<WorldView
     if (dx <= this.viewDistance && dz <= this.viewDistance) {
       const column = await this.world.getColumnAt(pos.y !== undefined ? (pos as Vec3) : new Vec3(pos.x, 0, pos.z))
 
+      // An asynchronous fetch must not resurrect a truly unloaded column.
+      const [currentX, currentZ] = chunkPos(this.lastPos)
+      if (
+        (this.columnUnloadEpoch.get(key) ?? 0) !== epoch ||
+        Math.abs(currentX - Math.floor(pos.x / 16)) > this.viewDistance ||
+        Math.abs(currentZ - Math.floor(pos.z / 16)) > this.viewDistance
+      )
+        return false
       if (column) {
         const chunk = column.toJson()
         const worldConfig: WorldSizeParams = {
@@ -304,10 +319,41 @@ export class WorldView extends (EventEmitter as new () => TypedEmitter<WorldView
           reason,
           time: Date.now()
         })
+        return true
       } else if (this.isPlayground) {
         this.emit('markAsLoaded', { x: pos.x, z: pos.z })
       }
     }
+    return false
+  }
+
+  reloadColumnGeometry(): Promise<void> {
+    this.geometryReload ??= this.runColumnGeometryReload().finally(() => {
+      this.geometryReload = undefined
+    })
+    return this.geometryReload
+  }
+
+  private async runColumnGeometryReload(): Promise<void> {
+    const coords = Object.keys(this.loadedChunks)
+      .filter(key => this.loadedChunks[key])
+      .map(key => key.split(',').map(Number) as [number, number])
+    coords.sort(([ax, az], [bx, bz]) => (ax - this.lastPos.x) ** 2 + (az - this.lastPos.z) ** 2 - (bx - this.lastPos.x) ** 2 - (bz - this.lastPos.z) ** 2)
+    for (const [x, z] of coords) this.emit('unloadChunk', { x, z, preserveClientLight: true })
+    for (const [x, z] of coords) {
+      const key = `${x},${z}`
+      if (!this.loadedChunks[key]) continue
+      const epoch = this.columnUnloadEpoch.get(key) ?? 0
+      let reloaded = false
+      try {
+        reloaded = await this.loadChunk({ x, z }, false, 'geometry-reload')
+      } catch (error) {
+        console.warn(`Failed to reload column geometry ${key}`, error)
+      }
+      if (!reloaded && this.loadedChunks[key] && (this.columnUnloadEpoch.get(key) ?? 0) === epoch) {
+        this.unloadChunk({ x, z })
+      }
+    }
   }
 
   /**
@@ -335,6 +381,8 @@ export class WorldView extends (EventEmitter as new () => TypedEmitter<WorldView
    * Unload a specific chunk.
    */
   unloadChunk(pos: { x: number; z: number }): void {
+    const key = `${pos.x},${pos.z}`
+    this.columnUnloadEpoch.set(key, (this.columnUnloadEpoch.get(key) ?? 0) + 1)
     this.emit('unloadChunk', { x: pos.x, z: pos.z })
     delete this.loadedChunks[`${pos.x},${pos.z}`]
     delete this.debugChunksInfo[`${pos.x},${pos.z}`]