minecraft-renderer 0.1.83 → 0.1.85

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

@@ -10,6 +10,16 @@ import { collectBlockEntityMetadata, type SignMeta, type HeadMeta, type BannerMe
 import { SectionRequestTracker } from './mesherWasmRequestTracker'
 import { sectionYsForLightColumnDirty } from './mesherWasmLightDirty'
 import { CONVERSION_CACHE_LIMIT, clearConversionCache, getOrConvertColumn, invalidateConversion, setConversionCacheLimit } from './mesherWasmConversionCache'
+import { PendingChunkBuffer } from './mesherWasmChunkBuffer'
+import {
+  PendingNeighborHealTracker,
+  SIDE_NEIGHBOR_OFFSETS,
+  collectChunksForColumnUnion,
+  columnDataAvailable,
+  countParsedCache3x3,
+  countWorldColumns3x3,
+  type PacketCaches
+} from './mesherWasmNeighborhood'
 
 let wasm: typeof import('../runtime-build/wasm_mesher.js') | null = null
 let wasmInitialized = false
@@ -44,6 +54,9 @@ function processUpdateLightV17(rawPacket: Uint8Array, numSections: number): void
     })
     invalidateConversion(x, z)
     dirtyColumnSectionsForLightUpdate(x, z)
+    const hadColumn = !!world?.getColumn(x, z)
+    syncV17LightToColumn(x, z)
+    if (!hadColumn) pendingLightDirtyColumns.add(rawCacheKey(x, z))
   } catch (err) {
     console.warn('[WASM Mesher] parseUpdateLightV17 failed:', err)
   }
@@ -248,6 +261,44 @@ interface UpdateLightV17Entry {
   blockLight: Uint8Array
 }
 const updateLightV17Cache = new Map<string, UpdateLightV17Entry>()
+/** Columns that received `update_light` before the worker column existed. */
+const pendingLightDirtyColumns = new Set<string>()
+const _syncLightPos = new Vec3(0, 0, 0)
+
+function resolveUpdateLightV17Entry(x: number, z: number, chunk: any | undefined, worldMinY: number, worldMaxY: number): UpdateLightV17Entry | undefined {
+  const cached = updateLightV17Cache.get(rawCacheKey(x, z))
+  if (cached?.blockLight?.length) return cached
+  if (!chunk) return cached
+  const { result } = getOrConvertColumn(x, z, chunk, version, worldMinY, worldMaxY, () => convertChunkToWasm(chunk, version, x, z, worldMinY, worldMaxY), chunk)
+  return { blockLight: result.blockLight, skyLight: result.skyLight }
+}
+
+/** Write cached 1.17 `update_light` arrays into the worker prismarine column. */
+function syncV17LightToColumn(x: number, z: number): boolean {
+  if (!world) return false
+  const col = world.getColumn(x, z)
+  const entry = updateLightV17Cache.get(rawCacheKey(x, z))
+  if (!col || !entry) return false
+
+  const CHUNK_SIZE = 16
+  const minY = config?.worldMinY ?? 0
+  const maxY = config?.worldMaxY ?? 256
+  const { blockLight, skyLight } = entry
+
+  for (let y = minY; y < maxY; y++) {
+    for (let lz = 0; lz < CHUNK_SIZE; lz++) {
+      for (let lx = 0; lx < CHUNK_SIZE; lx++) {
+        const idx = lx + lz * CHUNK_SIZE + (y - minY) * CHUNK_SIZE * CHUNK_SIZE
+        if (idx >= blockLight.length) continue
+        _syncLightPos.set(lx, y, lz)
+        col.setBlockLight(_syncLightPos, blockLight[idx]!)
+        col.setSkyLight(_syncLightPos, skyLight[idx]!)
+      }
+    }
+  }
+
+  return true
+}
 
 // 1.16 path: pre-extracted section bytes + bit mask. Bit mask in 1.16
 // is a varint that fits in i32 (only 16 sections), so we accept it as a
@@ -263,6 +314,77 @@ interface ParsedV16Entry {
 }
 const parsedV16Cache = new Map<string, ParsedV16Entry>()
 
+const pendingChunks = new PendingChunkBuffer()
+const pendingNeighborHeal = new PendingNeighborHealTracker()
+let blindMeshWarnCount = 0
+const BLIND_MESH_WARN_LIMIT = 5
+
+const packetCaches = (): PacketCaches => ({
+  raw: rawMapChunkCache,
+  v17: parsedV17Cache,
+  v16: parsedV16Cache
+})
+
+function notifyColumnsAwaitingNeighbor(neighborX: number, neighborZ: number) {
+  for (const col of pendingNeighborHeal.takeColumnsAwaitingNeighbor(neighborX, neighborZ)) {
+    postMessage({ type: 'neighborDataArrived', x: col.x, z: col.z, workerIndex })
+  }
+}
+
+function onColumnDataArrived(x: number, z: number) {
+  notifyColumnsAwaitingNeighbor(x, z)
+}
+
+function warnGenuinelyBlindMesh(columnX: number, columnZ: number, missingSides: number) {
+  if (missingSides <= 0) return
+  blindMeshWarnCount++
+  if (blindMeshWarnCount <= BLIND_MESH_WARN_LIMIT) {
+    console.warn(`[mesher] column ${columnX},${columnZ} meshed with ${missingSides}/4 side neighbors missing from both pipelines — genuinely blind mesh`)
+  } else if (blindMeshWarnCount === BLIND_MESH_WARN_LIMIT + 1) {
+    console.warn(`[mesher] genuinely blind mesh warnings suppressed after ${BLIND_MESH_WARN_LIMIT} occurrences`)
+  }
+}
+
+function processChunkMessage(data: { x: number; z: number; chunk: any; customBlockModels?: any }) {
+  world.addColumn(data.x, data.z, data.chunk)
+  // --- Light sync (folded in from main): apply any light that arrived before
+  //     this column's data. Doing it here (not inline in the handler) means
+  //     chunks replayed from pendingChunks via drainPendingChunks() also get
+  //     their buffered light applied.
+  syncV17LightToColumn(data.x, data.z)
+  const lightKey = rawCacheKey(data.x, data.z)
+  if (pendingLightDirtyColumns.delete(lightKey) || updateLightV17Cache.has(lightKey)) {
+    dirtyColumnSectionsForLightUpdate(data.x, data.z)
+  }
+  if (data.customBlockModels) {
+    const chunkKey = `${data.x},${data.z}`
+    world.customBlockModels.set(chunkKey, data.customBlockModels)
+  }
+  const sectionH = SECTION_HEIGHT
+  const minY = config?.worldMinY ?? 0
+  const maxY = config?.worldMaxY ?? 256
+  const column = world.getColumn(data.x, data.z)
+  let hasAnySection = false
+  for (let y = minY; y < maxY; y += sectionH) {
+    if (column?.getSection?.(new Vec3(0, y, 0))) {
+      hasAnySection = true
+      break
+    }
+  }
+  if (!hasAnySection) {
+    const emptyHeightmap = new Int16Array(256).fill(EMPTY_COLUMN_HEIGHTMAP_SENTINEL)
+    postMessage({ type: 'heightmap', key: `${data.x >> 4},${data.z >> 4}`, heightmap: emptyHeightmap }, [emptyHeightmap.buffer])
+  }
+}
+
+function drainPendingChunks() {
+  if (!world) return
+  pendingChunks.drain(msg => {
+    processChunkMessage(msg)
+    onColumnDataArrived(msg.x, msg.z)
+  })
+}
+
 // 1.16 sky/block light cache — same shape as the v17 entry, populated by
 // `processUpdateLightV16` (which calls the shared `parseUpdateLightV17`
 // WASM export). Separate map for the same isolation reasons as
@@ -625,7 +747,7 @@ const meshMultiColumnsFromParsedV16V17 = (
       bitMapLoHi[i * 2] = entry.bitMapLoHi[0]
       bitMapLoHi[i * 2 + 1] = entry.bitMapLoHi[1]
       if (i === 0) maxBitsPerBlock = entry.maxBitsPerBlock
-      const light = updateLightV17Cache.get(key)
+      const light = resolveUpdateLightV17Entry(chunksToUse[i].x, chunksToUse[i].z, chunksToUse[i].chunk, worldMinY, worldMaxY)
       skyLightList.push(light?.skyLight ?? new Uint8Array(0))
       blockLightList.push(light?.blockLight ?? new Uint8Array(0))
     } else {
@@ -707,6 +829,7 @@ const handleMessage = async (data: any) => {
       await initWasm()
       allDataReady = true
       workerIndex = data.workerIndex
+      drainPendingChunks()
       break
     }
     case 'dirty': {
@@ -718,39 +841,17 @@ const handleMessage = async (data: any) => {
       // Invalidate BEFORE replacing the column reference so a stale entry
       // can never outlive the old chunk object.
       invalidateConversion(data.x, data.z)
-      if (!world) break
-      world.addColumn(data.x, data.z, data.chunk)
-      if (data.customBlockModels) {
-        const chunkKey = `${data.x},${data.z}`
-        world.customBlockModels.set(chunkKey, data.customBlockModels)
-      }
-      // Safety-net heightmap push for fully empty columns. With WASM
-      // mesher as the sole path, the main thread no longer requests
-      // `getHeightmap` on chunk load — heightmaps come from
-      // `processColumnTick`. But a fully empty column (no sections, or
-      // all sections missing) never enters that path because
-      // `setSectionDirty` short-circuits when `chunk.getSection(pos)` is
-      // falsy, so `processColumnTick` never sees it. Without this push
-      // downstream consumers (e.g. `rain.ts`) would have no heightmap
-      // entry for such columns. We send a cheap sentinel-filled
-      // `Int16Array(256).fill(-32768)` — no JS heightmap scan — only when
-      // we detect zero sections; non-empty columns get their real
-      // heightmap from the next `processColumnTick`.
-      const sectionH = SECTION_HEIGHT
-      const minY = config?.worldMinY ?? 0
-      const maxY = config?.worldMaxY ?? 256
-      const column = world.getColumn(data.x, data.z)
-      let hasAnySection = false
-      for (let y = minY; y < maxY; y += sectionH) {
-        if (column?.getSection?.(new Vec3(0, y, 0))) {
-          hasAnySection = true
-          break
-        }
-      }
-      if (!hasAnySection) {
-        const emptyHeightmap = new Int16Array(256).fill(EMPTY_COLUMN_HEIGHTMAP_SENTINEL)
-        postMessage({ type: 'heightmap', key: `${data.x >> 4},${data.z >> 4}`, heightmap: emptyHeightmap }, [emptyHeightmap.buffer])
+      if (!world) {
+        pendingChunks.enqueue({
+          x: data.x,
+          z: data.z,
+          chunk: data.chunk,
+          customBlockModels: data.customBlockModels
+        })
+        break
       }
+      processChunkMessage(data)
+      onColumnDataArrived(data.x, data.z)
       break
     }
     case 'unloadChunk': {
@@ -760,9 +861,11 @@ const handleMessage = async (data: any) => {
       updateLightV17Cache.delete(rawCacheKey(data.x, data.z))
       parsedV16Cache.delete(rawCacheKey(data.x, data.z))
       updateLightV16Cache.delete(rawCacheKey(data.x, data.z))
+      pendingLightDirtyColumns.delete(rawCacheKey(data.x, data.z))
       if (!world) break
       world.removeColumn(data.x, data.z)
       world.customBlockModels.delete(`${data.x},${data.z}`)
+      pendingNeighborHeal.clearColumn(data.x, data.z)
       requestTracker.clearColumn(data.x, data.z)
       for (const key of [...dirtySections.keys()]) {
         const [sx, , sz] = key.split(',').map(Number)
@@ -809,6 +912,7 @@ const handleMessage = async (data: any) => {
         numSections: data.numSections as number
       })
       invalidateConversion(data.x, data.z)
+      onColumnDataArrived(data.x, data.z)
       break
     }
     case 'setParsedMapChunkV17': {
@@ -822,6 +926,7 @@ const handleMessage = async (data: any) => {
         biomes: data.biomes as Int32Array | undefined
       })
       invalidateConversion(data.x, data.z)
+      onColumnDataArrived(data.x, data.z)
       break
     }
     case 'setUpdateLightV17': {
@@ -846,6 +951,7 @@ const handleMessage = async (data: any) => {
         biomes: data.biomes as Int32Array
       })
       invalidateConversion(data.x, data.z)
+      onColumnDataArrived(data.x, data.z)
       break
     }
     case 'setUpdateLightV16': {
@@ -863,8 +969,12 @@ const handleMessage = async (data: any) => {
       rawMapChunkCache.clear()
       parsedV17Cache.clear()
       updateLightV17Cache.clear()
+      pendingLightDirtyColumns.clear()
       parsedV16Cache.clear()
       updateLightV16Cache.clear()
+      pendingChunks.clear()
+      pendingNeighborHeal.clear()
+      blindMeshWarnCount = 0
       globalVar.mcData = null
       globalVar.loadedData = null
       allDataReady = false
@@ -936,23 +1046,8 @@ self.onmessage = ({ data }) => {
 // Section height is always 16 in column mode (the only WASM path).
 const getSectionHeight = () => SECTION_HEIGHT
 
-// 3x3 X/Z neighbor set for column meshing. Y-agnostic because full-column
-// meshing converts the entire world Y range in one go.
 function collectChunksForColumn(x: number, z: number) {
-  const result = [] as Array<{ x: number; z: number; chunk: any }>
-  const target = world.getColumn(x, z)
-  if (target) result.push({ x, z, chunk: target })
-  const offsets = [-16, 0, 16]
-  for (const dx of offsets) {
-    for (const dz of offsets) {
-      if (dx === 0 && dz === 0) continue
-      const nx = x + dx
-      const nz = z + dz
-      const c = world.getColumn(nx, nz)
-      if (c) result.push({ x: nx, z: nz, chunk: c })
-    }
-  }
-  return result
+  return collectChunksForColumnUnion(x, z, (nx, nz) => world.getColumn(nx, nz), packetCaches())
 }
 
 function makeEmptyColumnGeometry(sx: number, sy: number, sz: number, sectionHeight: number, hadErrors: boolean): MesherGeometryOutput {
@@ -1031,6 +1126,9 @@ function processColumnTick() {
     let preCacheMisses = 0
     let hadError = false
     let columnMeshPath = 'none'
+    let chunkCount = 0
+    let worldColumns3x3 = 0
+    let parsedCache3x3 = 0
     // Outer-scope timestamps so we can finalize `processTime` and
     // `postPhase` AFTER the per-section emit loop runs (the loop builds
     // typed arrays, walks block-entity metadata, and calls postMessage —
@@ -1045,7 +1143,21 @@ function processColumnTick() {
       const t0 = start
       try {
         const chunksToUse = collectChunksForColumn(x, z)
-        const chunkCount = chunksToUse.length
+        chunkCount = chunksToUse.length
+        const caches = packetCaches()
+        worldColumns3x3 = countWorldColumns3x3(x, z, (nx, nz) => world.getColumn(nx, nz))
+        parsedCache3x3 = countParsedCache3x3(x, z, caches)
+
+        let missingSideCount = 0
+        for (const [dx, dz] of SIDE_NEIGHBOR_OFFSETS) {
+          const nx = x + dx
+          const nz = z + dz
+          if (!columnDataAvailable(nx, nz, (cx, cz) => world.getColumn(cx, cz), caches)) {
+            pendingNeighborHeal.recordMissingSide(x, z, nx, nz)
+            missingSideCount++
+          }
+        }
+        warnGenuinelyBlindMesh(x, z, missingSideCount)
 
         let wasmResult: any
         let t1 = 0
@@ -1068,7 +1180,7 @@ function processColumnTick() {
             wasmResult = meshColumnFromRawV18Plus(rawEntry, x, z, worldMinY, worldMaxY, meta)
             if (wasmResult) columnMeshPath = 'v18_fused'
           } else if (v17Entry) {
-            const v17Light = updateLightV17Cache.get(rawCacheKey(x, z))
+            const v17Light = resolveUpdateLightV17Entry(x, z, targetChunk, worldMinY, worldMaxY)
             wasmResult = meshColumnFromParsedV16V17(
               v17Entry.chunkData,
               v17Entry.bitMapLoHi,
@@ -1135,11 +1247,13 @@ function processColumnTick() {
 
         if (!wasmResult) {
           // --- Old two-step path (multi-column or fused fallback) ---
-          const conversions = chunksToUse.map(({ x: cx, z: cz, chunk }) => {
+          const conversions: ChunkConversionResult[] = []
+          const meshChunks: typeof chunksToUse = []
+          for (const { x: cx, z: cz, chunk } of chunksToUse) {
             const cs = performance.now()
             const rawEntry = rawMapChunkCache.get(rawCacheKey(cx, cz))
             const v17Entry = parsedV17Cache.get(rawCacheKey(cx, cz))
-            const v17Light = updateLightV17Cache.get(rawCacheKey(cx, cz))
+            const v17Light = resolveUpdateLightV17Entry(cx, cz, chunk, worldMinY, worldMaxY)
             const v16Entry = parsedV16Cache.get(rawCacheKey(cx, cz))
             const v16Light = updateLightV16Cache.get(rawCacheKey(cx, cz))
 
@@ -1163,6 +1277,9 @@ function processColumnTick() {
             if (!conv) {
               // JS-fallback (column walk) — still cached, since this is the
               // expensive path the conversion cache was built for.
+              // Cache-only neighbors (pipeline B without world.columns) are
+              // skipped — fused multi should have handled them already.
+              if (!chunk) continue
               const cached = getOrConvertColumn(
                 cx,
                 cz,
@@ -1186,12 +1303,18 @@ function processColumnTick() {
               preNeighborConvert += ce - cs
               preNeighborCount++
             }
-            return conv
-          })
+            conversions.push(conv)
+            meshChunks.push({ x: cx, z: cz, chunk })
+          }
+
+          const twoStepChunkCount = conversions.length
+          if (twoStepChunkCount === 0) {
+            throw new Error(`[WASM Mesher] no convertible columns for ${x},${z}`)
+          }
 
           const { invisibleBlocks, transparentBlocks, noAoBlocks, cullIdenticalBlocks, occludingBlocks } = conversions[0]
 
-          if (chunkCount === 1 || !(wasm as any).generate_geometry_multi) {
+          if (twoStepChunkCount === 1 || !(wasm as any).generate_geometry_multi) {
             const { blockStates, blockLight, skyLight, biomesArray } = conversions[0]
             t1 = performance.now()
             wasmResult = wasm.generate_geometry(
@@ -1219,17 +1342,17 @@ function processColumnTick() {
           } else {
             const tBuildStart = performance.now()
             const perChunkLen = conversions[0].blockStates.length
-            const xs = new Int32Array(chunkCount)
-            const zs = new Int32Array(chunkCount)
-            const blockStatesAll = new Uint16Array(perChunkLen * chunkCount)
-            const blockLightAll = new Uint8Array(perChunkLen * chunkCount)
-            const skyLightAll = new Uint8Array(perChunkLen * chunkCount)
-            const biomesAll = new Uint8Array(perChunkLen * chunkCount)
-
-            for (let i = 0; i < chunkCount; i++) {
+            const xs = new Int32Array(twoStepChunkCount)
+            const zs = new Int32Array(twoStepChunkCount)
+            const blockStatesAll = new Uint16Array(perChunkLen * twoStepChunkCount)
+            const blockLightAll = new Uint8Array(perChunkLen * twoStepChunkCount)
+            const skyLightAll = new Uint8Array(perChunkLen * twoStepChunkCount)
+            const biomesAll = new Uint8Array(perChunkLen * twoStepChunkCount)
+
+            for (let i = 0; i < twoStepChunkCount; i++) {
               const c = conversions[i]
-              xs[i] = chunksToUse[i].x
-              zs[i] = chunksToUse[i].z
+              xs[i] = meshChunks[i].x
+              zs[i] = meshChunks[i].z
               blockStatesAll.set(c.blockStates, perChunkLen * i)
               blockLightAll.set(c.blockLight, perChunkLen * i)
               skyLightAll.set(c.skyLight, perChunkLen * i)
@@ -1497,7 +1620,11 @@ function processColumnTick() {
           preTypedArrayBuild: !attributed ? preTypedArrayBuild : 0,
           preOther: !attributed ? preOther : 0,
           preCacheHits: !attributed ? preCacheHits : 0,
-          preCacheMisses: !attributed ? preCacheMisses : 0
+          preCacheMisses: !attributed ? preCacheMisses : 0,
+          chunkCount: !attributed ? chunkCount : 0,
+          worldColumns3x3: !attributed ? worldColumns3x3 : 0,
+          parsedCache3x3: !attributed ? parsedCache3x3 : 0,
+          columnMeshPath: !attributed ? columnMeshPath : 'none'
         })
         attributed = true
       }

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

@@ -0,0 +1,28 @@
+//@ts-nocheck
+export type PendingChunkMessage = {
+  x: number
+  z: number
+  chunk: any
+  customBlockModels?: any
+}
+
+export class PendingChunkBuffer {
+  private pending: PendingChunkMessage[] = []
+
+  enqueue(msg: PendingChunkMessage) {
+    this.pending.push(msg)
+  }
+
+  drain(apply: (msg: PendingChunkMessage) => void) {
+    const batch = this.pending.splice(0)
+    for (const msg of batch) apply(msg)
+  }
+
+  get size() {
+    return this.pending.length
+  }
+
+  clear() {
+    this.pending.length = 0
+  }
+}

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

@@ -0,0 +1,125 @@
+//@ts-nocheck
+export type ColumnChunkEntry = { x: number; z: number; chunk: any | null }
+
+export interface PacketCacheSet {
+  has: (key: string) => boolean
+}
+
+export interface PacketCaches {
+  raw: PacketCacheSet
+  v17: PacketCacheSet
+  v16: PacketCacheSet
+}
+
+export function columnCacheKey(x: number, z: number) {
+  return `${x},${z}`
+}
+
+export function columnHasPacketCache(x: number, z: number, caches: PacketCaches): boolean {
+  const k = columnCacheKey(x, z)
+  return caches.raw.has(k) || caches.v17.has(k) || caches.v16.has(k)
+}
+
+export function columnDataAvailable(x: number, z: number, getColumn: (x: number, z: number) => any | null | undefined, caches: PacketCaches): boolean {
+  return !!getColumn(x, z) || columnHasPacketCache(x, z, caches)
+}
+
+export function countWorldColumns3x3(x: number, z: number, getColumn: (x: number, z: number) => any | null | undefined): number {
+  let count = 0
+  for (const dx of [-16, 0, 16]) {
+    for (const dz of [-16, 0, 16]) {
+      if (getColumn(x + dx, z + dz)) count++
+    }
+  }
+  return count
+}
+
+export function countParsedCache3x3(x: number, z: number, caches: PacketCaches): number {
+  let count = 0
+  for (const dx of [-16, 0, 16]) {
+    for (const dz of [-16, 0, 16]) {
+      if (columnHasPacketCache(x + dx, z + dz, caches)) count++
+    }
+  }
+  return count
+}
+
+export function collectChunksForColumnUnion(
+  x: number,
+  z: number,
+  getColumn: (x: number, z: number) => any | null | undefined,
+  caches: PacketCaches
+): ColumnChunkEntry[] {
+  const result: ColumnChunkEntry[] = []
+  const seen = new Set<string>()
+
+  const add = (nx: number, nz: number) => {
+    const key = columnCacheKey(nx, nz)
+    if (seen.has(key)) return
+    seen.add(key)
+    const chunk = getColumn(nx, nz) ?? null
+    if (chunk || columnHasPacketCache(nx, nz, caches)) {
+      result.push({ x: nx, z: nz, chunk })
+    }
+  }
+
+  add(x, z)
+  for (const dx of [-16, 0, 16]) {
+    for (const dz of [-16, 0, 16]) {
+      if (dx === 0 && dz === 0) continue
+      add(x + dx, z + dz)
+    }
+  }
+  return result
+}
+
+export const SIDE_NEIGHBOR_OFFSETS = [
+  [-16, 0],
+  [16, 0],
+  [0, -16],
+  [0, 16]
+] as const
+
+export class PendingNeighborHealTracker {
+  // Neighbor column key -> columns that meshed without this neighbor.
+  private awaiting = new Map<string, Set<string>>()
+
+  private colKey(x: number, z: number) {
+    return columnCacheKey(x, z)
+  }
+
+  recordMissingSide(columnX: number, columnZ: number, missingNeighborX: number, missingNeighborZ: number) {
+    const neighborKey = this.colKey(missingNeighborX, missingNeighborZ)
+    const columnKey = this.colKey(columnX, columnZ)
+    let set = this.awaiting.get(neighborKey)
+    if (!set) {
+      set = new Set()
+      this.awaiting.set(neighborKey, set)
+    }
+    set.add(columnKey)
+  }
+
+  takeColumnsAwaitingNeighbor(neighborX: number, neighborZ: number): Array<{ x: number; z: number }> {
+    const key = this.colKey(neighborX, neighborZ)
+    const waiting = this.awaiting.get(key)
+    if (!waiting || waiting.size === 0) return []
+    this.awaiting.delete(key)
+    return [...waiting].map(k => {
+      const [sx, sz] = k.split(',').map(Number)
+      return { x: sx, z: sz }
+    })
+  }
+
+  clearColumn(x: number, z: number) {
+    const columnKey = this.colKey(x, z)
+    for (const [neighborKey, set] of this.awaiting) {
+      set.delete(columnKey)
+      if (set.size === 0) this.awaiting.delete(neighborKey)
+    }
+    this.awaiting.delete(columnKey)
+  }
+
+  clear() {
+    this.awaiting.clear()
+  }
+}