minecraft-renderer 0.1.38 → 0.1.39

package/src/mesher/mesherWasm.ts

@@ -1,10 +1,20 @@
 //@ts-nocheck
 import { Vec3 } from 'vec3'
 import { convertChunkToWasm } from '../wasm-lib/convertChunk'
-import { renderWasmOutputToGeometry } from '../wasm-lib/render-from-wasm'
+import { extractColumnHeightmap, splitColumnWasmOutputToSections } from '../wasm-lib/render-from-wasm'
 import { setBlockStatesData as setMesherData } from './models'
-import { defaultMesherConfig, type MesherGeometryOutput, IS_FULL_WORLD_SECTION, SECTION_HEIGHT } from './shared'
+import { defaultMesherConfig, type MesherGeometryOutput, SECTION_HEIGHT } from './shared'
 import { worldColumnKey, World } from './world'
+import { handleGetHeightmap, EMPTY_COLUMN_HEIGHTMAP_SENTINEL } from './computeHeightmap'
+import { collectBlockEntityMetadata, type SignMeta, type HeadMeta, type BannerMeta } from './blockEntityMetadata'
+import { SectionRequestTracker } from './mesherWasmRequestTracker'
+import {
+  CONVERSION_CACHE_LIMIT,
+  clearConversionCache,
+  getOrConvertColumn,
+  invalidateConversion,
+  setConversionCacheLimit,
+} from './mesherWasmConversionCache'
 
 let wasm: typeof import('../../wasm/wasm_mesher.js') | null = null
 let wasmInitialized = false
@@ -41,6 +51,10 @@ let config = defaultMesherConfig
 let version = '1.16.5'
 let world: World // chunkKey -> chunk data
 let dirtySections = new Map<string, number>()
+// Kept in sync with `dirtySections` so column mode can filter outgoing
+// geometry/sectionFinished events to only the section keys requested by the
+// main thread, even though a full-column WASM call may generate more data.
+const requestTracker = new SectionRequestTracker()
 let allDataReady = false
 
 function sectionKey(x: number, y: number, z: number) {
@@ -70,6 +84,21 @@ function drainQueue(from: number, to: number) {
   queuedMessages = queuedMessages.slice(to)
 }
 
+// Single emit point for `sectionFinished`. Consumes one pending request from
+// `requestTracker` and posts via the existing batched `postMessage` queue.
+//
+// Column-mode is the ONLY WASM path now: an emit for a non-requested key is a
+// contract violation (`WorldRendererCommon` would throw on the main thread)
+// and we surface it via `console.warn` so it shows up in dev/CI without
+// killing the worker.
+const emitSectionFinished = (payload: { type: 'sectionFinished', key: string } & Record<string, any>) => {
+  const consumed = requestTracker.consumeOne(payload.key)
+  if (!consumed) {
+    console.warn(`[WASM Mesher] sectionFinished for non-requested key ${payload.key} (column-mode contract violation)`)
+  }
+  postMessage(payload)
+}
+
 let hadDirty = false
 function setSectionDirty(pos: Vec3, value = true) {
   if (hadDirty) return
@@ -82,7 +111,10 @@ function setSectionDirty(pos: Vec3, value = true) {
   const key = sectionKey(x, y, z)
   if (!value) {
     dirtySections.delete(key)
-    postMessage({ type: 'sectionFinished', key, workerIndex })
+    // The main thread waits for a sectionFinished response to dirty=false too.
+    // Record + consume it so request accounting stays balanced.
+    requestTracker.addRequest(key)
+    emitSectionFinished({ type: 'sectionFinished', key, workerIndex })
     return
   }
 
@@ -90,8 +122,11 @@ function setSectionDirty(pos: Vec3, value = true) {
   const chunk = world?.getColumn(x, z)
   if (chunk?.getSection(pos)) {
     dirtySections.set(key, (dirtySections.get(key) || 0) + 1)
+    requestTracker.addRequest(key)
   } else {
-    postMessage({ type: 'sectionFinished', key, workerIndex })
+    // Missing chunks still owe the main thread a sectionFinished response.
+    requestTracker.addRequest(key)
+    emitSectionFinished({ type: 'sectionFinished', key, workerIndex })
   }
 }
 
@@ -115,12 +150,15 @@ const handleMessage = async (data: any) => {
     world.config = { ...world.config, ...data.config }
     globalThis.world = world
     globalThis.Vec3 = Vec3
+    setConversionCacheLimit(config.disableConversionCache ? 0 : CONVERSION_CACHE_LIMIT)
   }
 
   switch (data.type) {
     case 'mesherData': {
       setMesherData(data.blockstatesModels, data.blocksAtlas, data.config.outputFormat === 'webgpu')
       ;(globalThis as any).__wasmBlockModelCache = new Map()
+      // Conservative: blockstates/version/world config may have changed.
+      clearConversionCache()
 
       await initWasm()
       allDataReady = true
@@ -133,14 +171,50 @@ const handleMessage = async (data: any) => {
       break
     }
     case 'chunk': {
+      // 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]
+        )
+      }
       break
     }
     case 'unloadChunk': {
+      invalidateConversion(data.x, data.z)
+      if (!world) break
       world.removeColumn(data.x, data.z)
       world.customBlockModels.delete(`${data.x},${data.z}`)
       if (Object.keys(world.columns).length === 0) softCleanup()
@@ -152,7 +226,12 @@ const handleMessage = async (data: any) => {
         world?.setBlockStateId(loc, data.stateId)
       }
 
-      const chunkKey = `${Math.floor(loc.x / 16) * 16},${Math.floor(loc.z / 16) * 16}`
+      const chunkX = Math.floor(loc.x / 16) * 16
+      const chunkZ = Math.floor(loc.z / 16) * 16
+      // In-place mutation preserves chunk identity; explicit invalidation
+      // is required so the next tick recomputes from current block state.
+      invalidateConversion(chunkX, chunkZ)
+      const chunkKey = `${chunkX},${chunkZ}`
       if (data.customBlockModels) {
         world?.customBlockModels.set(chunkKey, data.customBlockModels)
       }
@@ -161,13 +240,32 @@ const handleMessage = async (data: any) => {
     case 'reset': {
       world = undefined as any
       dirtySections.clear()
+      requestTracker.clear()
+      clearConversionCache()
       globalVar.mcData = null
       globalVar.loadedData = null
       allDataReady = false
       break
     }
-    // Note: getCustomBlockModel and getHeightmap not implemented in WASM version
-    // as they require World class functionality
+    case 'getHeightmap': {
+      // Fallback path. With WASM column mesher as the sole path, the main
+      // thread should be receiving heightmaps as `'heightmap'` push messages
+      // posted by `processColumnTick`. This handler stays as a safety net for
+      // cases where the WASM heightmap could not be extracted (length mismatch
+      // or missing field) — see the `extractColumnHeightmap` warn below.
+      console.warn(`[WASM Mesher] explicit getHeightmap request for ${data.x},${data.z} — push from processColumnTick missed?`)
+      if (!world) {
+        const emptyHeightmap = new Int16Array(256).fill(EMPTY_COLUMN_HEIGHTMAP_SENTINEL)
+        postMessage({ type: 'heightmap', key: `${Math.floor(data.x / 16)},${Math.floor(data.z / 16)}`, heightmap: emptyHeightmap })
+        break
+      }
+      const { key, heightmap } = handleGetHeightmap(world, data.x, data.z)
+      postMessage({ type: 'heightmap', key, heightmap }, [heightmap.buffer])
+
+      break
+    }
+    // Note: getCustomBlockModel not implemented in WASM version
+    // as it requires World class functionality
   }
 }
 
@@ -182,18 +280,16 @@ self.onmessage = ({ data }) => {
   handleMessage(data)
 }
 
-// Calculate section height based on IS_FULL_WORLD_SECTION
-const getSectionHeight = () => {
-  if (IS_FULL_WORLD_SECTION && config) {
-    return (config.worldMaxY || 256) - (config.worldMinY || 0)
-  }
-  return SECTION_HEIGHT
-}
+// Section height is always 16 in column mode (the only WASM path).
+const getSectionHeight = () => SECTION_HEIGHT
 
 
-function collectChunksForSection(x: number, y: number, z: number) {
+// 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 }>
-  result.push({ x, z, chunk: world.getColumn(x, z) })
+  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) {
@@ -204,53 +300,129 @@ function collectChunksForSection(x: number, y: number, z: number) {
       if (c) result.push({ x: nx, z: nz, chunk: c })
     }
   }
-  return result.filter(r => r.chunk)
+  return result
 }
 
-setInterval(async () => {
-  if (!allDataReady) return
-
-  // Ensure WASM is initialized
-  if (!wasmInitialized) {
-    await initWasm()
-    if (!wasmInitialized) return // Still not initialized, skip this cycle
+function makeEmptyColumnGeometry(sx: number, sy: number, sz: number, sectionHeight: number, hadErrors: boolean): MesherGeometryOutput {
+  return {
+    sectionYNumber: (sy - (config?.worldMinY || 0)) >> 4,
+    chunkKey: worldColumnKey(sx, sz),
+    sectionStartY: sy,
+    sectionEndY: sy + sectionHeight,
+    sectionStartX: sx,
+    sectionEndX: sx + 16,
+    sectionStartZ: sz,
+    sectionEndZ: sz + 16,
+    sx: sx + 8,
+    sy: sy + 8,
+    sz: sz + 8,
+    positions: new Float32Array(0),
+    normals: new Float32Array(0),
+    colors: new Float32Array(0),
+    uvs: new Float32Array(0),
+    indices: new Uint32Array(0),
+    indicesCount: 0,
+    using32Array: false,
+    tiles: {},
+    heads: {},
+    signs: {},
+    banners: {},
+    hadErrors,
+    blocksCount: 0,
   }
+}
 
-  if (dirtySections.size === 0) return
-
-  const sectionHeight = getSectionHeight()
+// Full-column meshing path — the sole WASM mesh path.
+// It groups dirty section keys by chunk column, runs one WASM call per column
+// over the full Y range, then splits the column output back into per-section
+// geometries. Only requested section keys are emitted back to the main thread.
+function processColumnTick() {
+  const worldMinY = config?.worldMinY ?? 0
+  const worldMaxY = config?.worldMaxY ?? 256
+  const columnHeight = worldMaxY - worldMinY
+  const sectionHeight = SECTION_HEIGHT
+
+  // Group dirty sections by chunk column (`${x},${z}` in world block
+  // coords — the same units used by section keys). This guarantees a
+  // single WASM call per column per tick even when multiple section keys
+  // of the same column are dirty.
+  const groups = new Map<string, { x: number, z: number, sections: Array<{ key: string, x: number, y: number, z: number, count: number }> }>()
+  for (const [key, count] of dirtySections) {
+    const [sx, sy, sz] = key.split(',').map(v => parseInt(v, 10))
+    const colKey = `${sx},${sz}`
+    let g = groups.get(colKey)
+    if (!g) {
+      g = { x: sx, z: sz, sections: [] }
+      groups.set(colKey, g)
+    }
+    g.sections.push({ key, x: sx, y: sy, z: sz, count })
+  }
+  dirtySections.clear()
 
-  for (const key of dirtySections.keys()) {
-    // for (const key of [] as string[]) {
-    const [x, y, z] = key.split(',').map(v => parseInt(v, 10))
-    const chunk = world.getColumn(x, z)
+  for (const group of groups.values()) {
+    const { x, z, sections } = group
+    const targetChunk = world.getColumn(x, z)
 
+    let exportedMap: Map<string, { exported: import('../three/worldGeometryExport').ExportedSection, blocksCount: number }> | null = null
     let processTime = 0
-    if (chunk?.getSection(new Vec3(x, y, z)) && wasm) {
-      const start = performance.now()
-
+    let prePhase = 0
+    let wasmPhase = 0
+    let postPhase = 0
+    let preTargetConvert = 0
+    let preNeighborConvert = 0
+    let preNeighborCount = 0
+    let preTypedArrayBuild = 0
+    let preOther = 0
+    let preCacheHits = 0
+    let preCacheMisses = 0
+    let hadError = false
+    // 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 —
+    // all of which are part of the worker's real cost and must be
+    // attributed to the column).
+    let columnStart = 0
+    let postStart = 0
+
+    if (targetChunk && wasm) {
+      columnStart = performance.now()
+      const start = columnStart
+      const t0 = start
       try {
-        // Convert chunk to WASM format (always recompute since section is dirty)
-        // If IS_FULL_WORLD_SECTION is false, only convert the specific section
-        const worldMinY = config?.worldMinY || 0
-        const worldMaxY = config?.worldMaxY || 256
-        const sectionY = IS_FULL_WORLD_SECTION ? undefined : y
-        const convertSectionHeight = IS_FULL_WORLD_SECTION ? undefined : sectionHeight
-
-        // Run WASM mesher for this section
-        const chunksToUse = collectChunksForSection(x, y, z)
+        const chunksToUse = collectChunksForColumn(x, z)
         const chunkCount = chunksToUse.length
 
-        const conversions = chunksToUse.map(({ x: cx, z: cz, chunk }) => convertChunkToWasm(
-          chunk,
-          version,
-          cx,
-          cz,
-          worldMinY,
-          worldMaxY,
-          sectionY,
-          convertSectionHeight
-        ))
+        const conversions = chunksToUse.map(({ x: cx, z: cz, chunk }) => {
+          const cs = performance.now()
+          const { result: conv, hit } = getOrConvertColumn(
+            cx,
+            cz,
+            chunk,
+            version,
+            worldMinY,
+            worldMaxY,
+            () => convertChunkToWasm(
+              chunk,
+              version,
+              cx,
+              cz,
+              worldMinY,
+              worldMaxY
+              // No sectionY/sectionHeight => full column conversion.
+            ),
+            chunk
+          )
+          const ce = performance.now()
+          if (hit) preCacheHits++
+          else preCacheMisses++
+          if (cx === x && cz === z) {
+            preTargetConvert += ce - cs
+          } else {
+            preNeighborConvert += ce - cs
+            preNeighborCount++
+          }
+          return conv
+        })
 
         const {
           invisibleBlocks,
@@ -260,12 +432,18 @@ setInterval(async () => {
           occludingBlocks,
         } = conversions[0]
 
-        let wasmResult
+        let wasmResult: any
+        let t1: number
         if (chunkCount === 1 || !(wasm as any).generate_geometry_multi) {
+          // Single-chunk path: no discrete typed-array build/copy step
+          // (the per-chunk arrays from convertChunkToWasm are passed
+          // straight through). preTypedArrayBuild stays 0.
           const { blockStates, blockLight, skyLight, biomesArray } = conversions[0]
+          t1 = performance.now()
           wasmResult = wasm.generate_geometry(
-            x, y, z, sectionHeight,
+            x, worldMinY, z, columnHeight,
             worldMinY, worldMaxY,
+            worldMinY,
             blockStates, blockLight, skyLight, biomesArray,
             invisibleBlocks, transparentBlocks, noAoBlocks, cullIdenticalBlocks, occludingBlocks,
             config?.enableLighting !== false,
@@ -273,6 +451,7 @@ setInterval(async () => {
             config?.skyLight || 15
           )
         } else {
+          const tBuildStart = performance.now()
           const perChunkLen = conversions[0].blockStates.length
           const xs = new Int32Array(chunkCount)
           const zs = new Int32Array(chunkCount)
@@ -290,10 +469,13 @@ setInterval(async () => {
             skyLightAll.set(c.skyLight, perChunkLen * i)
             biomesAll.set(c.biomesArray, perChunkLen * i)
           }
+          preTypedArrayBuild = performance.now() - tBuildStart
 
+          t1 = performance.now()
           wasmResult = (wasm as any).generate_geometry_multi(
-            x, y, z, sectionHeight,
+            x, worldMinY, z, columnHeight,
             worldMinY, worldMaxY,
+            worldMinY,
             xs, zs,
             blockStatesAll, blockLightAll, skyLightAll, biomesAll,
             invisibleBlocks, transparentBlocks, noAoBlocks, cullIdenticalBlocks, occludingBlocks,
@@ -303,102 +485,212 @@ setInterval(async () => {
           )
         }
 
+        const t2 = performance.now()
+        postStart = t2
 
-        // Convert WASM output to MesherGeometryOutput format
-        const sectionKeyStr = worldColumnKey(x, z)
-        const exportedSection = renderWasmOutputToGeometry(
+        // Split full-column output back into per-section ExportedSection
+        // entries — only for the section keys the main thread actually
+        // requested. Sections in the column that were NOT requested are
+        // intentionally skipped (the request tracker would warn if we
+        // emitted sectionFinished for them).
+        const requestedSectionKeys = sections.map(s => ({ x: s.x, y: s.y, z: s.z }))
+        exportedMap = splitColumnWasmOutputToSections(
           wasmResult,
-          version,
-          sectionKeyStr,
-          { x: x + 8, y: y + 8, z: z + 8 },
-          world
+          requestedSectionKeys,
+          { version, world, sectionHeight }
         )
 
-        // Convert to MesherGeometryOutput format
-        // Determine if we need Uint32Array based on max index
-        const maxIndex = Math.max(...exportedSection.geometry.indices)
-        const using32Array = maxIndex > 65535
-
-        // console.log('exportedSection.geometry', exportedSection.geometry)
-        const geometry: MesherGeometryOutput = {
-          sectionYNumber: (y - (config?.worldMinY || 0)) >> 4,
-          chunkKey: sectionKeyStr,
-          sectionStartY: y,
-          sectionEndY: y + sectionHeight,
-          sectionStartX: x,
-          sectionEndX: x + 16,
-          sectionStartZ: z,
-          sectionEndZ: z + 16,
-          sx: x + 8,
-          sy: y + 8,
-          sz: z + 8,
-          positions: new Float32Array(exportedSection.geometry.positions),
-          normals: new Float32Array(exportedSection.geometry.normals),
-          colors: new Float32Array(exportedSection.geometry.colors),
-          uvs: new Float32Array(exportedSection.geometry.uvs),
-          indices: using32Array
-            ? new Uint32Array(exportedSection.geometry.indices)
-            : new Uint16Array(exportedSection.geometry.indices),
-          indicesCount: exportedSection.geometry.indices.length,
-          using32Array,
-          tiles: {},
-          heads: {},
-          signs: {},
-          banners: {},
-          hadErrors: false,
-          blocksCount: wasmResult.block_count,
+        // Push heightmap from the WASM column output. With column meshing as
+        // the only WASM path, the main thread does not request heightmaps
+        // explicitly anymore — the worker is the source of truth and pushes
+        // a `'heightmap'` message every column tick. Key shape matches the
+        // legacy `handleGetHeightmap` contract: `${chunkX>>4},${chunkZ>>4}`.
+        const heightmapKey = `${x >> 4},${z >> 4}`
+        const wasmHeightmap = extractColumnHeightmap(wasmResult)
+        if (wasmHeightmap) {
+          postMessage({ type: 'heightmap', key: heightmapKey, heightmap: wasmHeightmap }, [wasmHeightmap.buffer])
+        } else {
+          console.warn(`[WASM Mesher] heightmap extraction returned null for column ${x},${z}, falling back to JS computeHeightmap`)
+          const fallback = handleGetHeightmap(world, x, z)
+          postMessage({ type: 'heightmap', key: fallback.key, heightmap: fallback.heightmap }, [fallback.heightmap.buffer])
         }
 
-        const transferable = [
-          geometry.positions?.buffer,
-          geometry.normals?.buffer,
-          geometry.colors?.buffer,
-          geometry.uvs?.buffer,
-          //@ts-ignore
-          geometry.indices?.buffer,
-        ].filter(Boolean)
-
-        postMessage({ type: 'geometry', key, geometry, workerIndex }, transferable)
-        processTime = performance.now() - start
+        prePhase = t1 - t0
+        wasmPhase = t2 - t1
+        preOther = Math.max(0, prePhase - (preTargetConvert + preNeighborConvert + preTypedArrayBuild))
+        // NOTE: `postPhase` and `processTime` are finalized AFTER the
+        // per-section emit loop below — see the `Finalize column phase
+        // numbers` block.
       } catch (err) {
-        console.error(`[WASM Mesher] Error processing section ${key}:`, err)
-        // Send error geometry
-        const errorGeometry: MesherGeometryOutput = {
-          sectionYNumber: (y - (config?.worldMinY || 0)) >> 4,
-          chunkKey: worldColumnKey(x, z),
-          sectionStartY: y,
-          sectionEndY: y + sectionHeight,
-          sectionStartX: x,
-          sectionEndX: x + 16,
-          sectionStartZ: z,
-          sectionEndZ: z + 16,
-          sx: x + 8,
-          sy: y + 8,
-          sz: z + 8,
-          positions: new Float32Array(0),
-          normals: new Float32Array(0),
-          colors: new Float32Array(0),
-          uvs: new Float32Array(0),
-          indices: new Uint32Array(0),
-          indicesCount: 0,
-          using32Array: false,
-          tiles: {},
-          heads: {},
-          signs: {},
-          banners: {},
-          hadErrors: true,
-          blocksCount: 0,
+        console.error(`[WASM Mesher] Error processing column ${x},${z}:`, err)
+        hadError = true
+      }
+    }
+
+    // Emit geometry + sectionFinished for each requested section. Column-
+    // level perf metrics are attributed to the first sectionFinished of
+    // the first requested section (others get zeros) so totals don't
+    // double-count.
+    //
+    // Coherent chunk appearance: column mode relies on the existing
+    // `_renderByChunks` / `chunkFinished` contract on the main thread.
+    // ChunkMeshManager batches sections per column and reveals them
+    // atomically once `WorldRendererCommon` sees the last
+    // `sectionFinished` for the column. No dedicated `columnFinished`
+    // worker message is needed.
+    // Pass 1: build geometry + postMessage for each requested section.
+    // We collect finished keys here and emit `sectionFinished` only in
+    // Pass 2 below, after `postPhase` / `processTime` have been
+    // finalized — otherwise the totals attached to the first event
+    // would miss the typed-array allocation, block-entity walk, and
+    // postMessage cost of every section in this column.
+    const finished: Array<{ key: string, count: number }> = []
+    for (const s of sections) {
+      const { key, x: sx, y: sy, z: sz, count } = s
+
+      if (exportedMap && !hadError) {
+        const entry = exportedMap.get(key)
+        const exported = entry?.exported
+        const sectionBlocksCount = entry?.blocksCount ?? 0
+        // Block entity metadata still needs a per-section world walk
+        // (signs/heads/banners), matching the legacy per-section path.
+        const signs: Record<string, SignMeta> = {}
+        const heads: Record<string, HeadMeta> = {}
+        const banners: Record<string, BannerMeta> = {}
+        const beTarget = { signs, heads, banners }
+        const beOpts = { disableBlockEntityTextures: world.config.disableBlockEntityTextures }
+        const cursor = new Vec3(0, 0, 0)
+        for (cursor.y = sy; cursor.y < sy + sectionHeight; cursor.y++) {
+          for (cursor.z = sz; cursor.z < sz + 16; cursor.z++) {
+            for (cursor.x = sx; cursor.x < sx + 16; cursor.x++) {
+              const b = world.getBlock(cursor)
+              if (!b) continue
+              collectBlockEntityMetadata(b, cursor.x, cursor.y, cursor.z, beTarget, beOpts)
+            }
+          }
         }
+
+        let geometry: MesherGeometryOutput
+        let transferable: any[] = []
+        if (exported && exported.geometry.indices.length > 0) {
+          const maxIndex = exported.geometry.indices.length > 0
+            ? Math.max(...exported.geometry.indices)
+            : 0
+          const using32Array = maxIndex > 65535
+          geometry = {
+            sectionYNumber: (sy - (config?.worldMinY || 0)) >> 4,
+            chunkKey: worldColumnKey(sx, sz),
+            sectionStartY: sy,
+            sectionEndY: sy + sectionHeight,
+            sectionStartX: sx,
+            sectionEndX: sx + 16,
+            sectionStartZ: sz,
+            sectionEndZ: sz + 16,
+            sx: sx + 8,
+            sy: sy + 8,
+            sz: sz + 8,
+            positions: new Float32Array(exported.geometry.positions),
+            normals: new Float32Array(exported.geometry.normals),
+            colors: new Float32Array(exported.geometry.colors),
+            uvs: new Float32Array(exported.geometry.uvs),
+            indices: using32Array
+              ? new Uint32Array(exported.geometry.indices)
+              : new Uint16Array(exported.geometry.indices),
+            indicesCount: exported.geometry.indices.length,
+            using32Array,
+            tiles: {},
+            heads,
+            signs,
+            banners,
+            hadErrors: false,
+            // Per-section block bucket size from the column split. The
+            // field is informational (used by `chunkMeshManager` for the
+            // `B:` debug overlay stat) and matches the per-section path's
+            // semantics: number of blocks that contributed faces to this
+            // section's geometry.
+            blocksCount: sectionBlocksCount,
+          }
+          transferable = [
+            geometry.positions?.buffer,
+            geometry.normals?.buffer,
+            geometry.colors?.buffer,
+            geometry.uvs?.buffer,
+            //@ts-ignore
+            geometry.indices?.buffer,
+          ].filter(Boolean)
+        } else {
+          geometry = makeEmptyColumnGeometry(sx, sy, sz, sectionHeight, false)
+          // Still attach block entity metadata so the main thread sees
+          // signs/heads/banners even for empty-mesh sections.
+          geometry.signs = signs
+          geometry.heads = heads
+          geometry.banners = banners
+        }
+        postMessage({ type: 'geometry', key, geometry, workerIndex }, transferable)
+      } else if (hadError) {
+        const errorGeometry = makeEmptyColumnGeometry(sx, sy, sz, sectionHeight, true)
         postMessage({ type: 'geometry', key, geometry: errorGeometry, workerIndex })
       }
+      // No targetChunk and no error: skip geometry message (mirrors
+      // legacy behavior for sections whose chunk has been unloaded
+      // mid-tick) but still emit sectionFinished below so the main
+      // thread's sectionsWaiting counter unblocks.
+      finished.push({ key, count })
     }
 
-    const dirtyTimes = dirtySections.get(key)
-    if (!dirtyTimes) throw new Error('dirtySections.get(key) is falsy')
-    for (let i = 0; i < dirtyTimes; i++) {
-      postMessage({ type: 'sectionFinished', key, workerIndex, processTime })
-      processTime = 0
+    // Finalize column phase numbers — now they include split + per-
+    // section typed-array build + block-entity walk + geometry
+    // postMessage cost.
+    if (columnStart > 0 && !hadError) {
+      const tEnd = performance.now()
+      if (postStart > 0) postPhase = tEnd - postStart
+      processTime = tEnd - columnStart
     }
-    dirtySections.delete(key)
+
+    // Pass 2: emit sectionFinished events. Column-level perf metrics
+    // are attributed to the first emitted sectionFinished (others get
+    // zeros) so totals don't double-count.
+    let attributed = false
+    for (const { key, count } of finished) {
+      for (let i = 0; i < count; i++) {
+        emitSectionFinished({
+          type: 'sectionFinished',
+          key,
+          workerIndex,
+          processTime: !attributed ? processTime : 0,
+          pre: !attributed ? prePhase : 0,
+          wasm: !attributed ? wasmPhase : 0,
+          post: !attributed ? postPhase : 0,
+          preTargetConvert: !attributed ? preTargetConvert : 0,
+          preNeighborConvert: !attributed ? preNeighborConvert : 0,
+          preNeighborCount: !attributed ? preNeighborCount : 0,
+          preTypedArrayBuild: !attributed ? preTypedArrayBuild : 0,
+          preOther: !attributed ? preOther : 0,
+          preCacheHits: !attributed ? preCacheHits : 0,
+          preCacheMisses: !attributed ? preCacheMisses : 0,
+        })
+        attributed = true
+      }
+    }
+  }
+}
+
+setInterval(async () => {
+  if (!allDataReady) return
+
+  // Ensure WASM is initialized
+  if (!wasmInitialized) {
+    await initWasm()
+    if (!wasmInitialized) return // Still not initialized, skip this cycle
+  }
+
+  if (dirtySections.size === 0) return
+
+  try {
+    processColumnTick()
+  } catch (err) {
+    console.error('[WASM Mesher] processColumnTick failed:', err)
+    // Swallow to avoid breaking the setInterval; individual columns
+    // already have their own try/catch.
   }
 }, 50)