minecraft-renderer 0.1.41 → 0.1.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-renderer",
-  "version": "0.1.41",
+  "version": "0.1.42",
   "description": "The most Modular Minecraft world renderer with Three.js WebGL backend",
   "type": "module",
   "main": "./dist/index.js",

package/src/wasm-mesher/runtime-build/wasm_mesher.d.ts

@@ -27,6 +27,24 @@ export function generateGeometryFromDump118(section_x: number, section_y: number
  */
 export function generateGeometryFromMapChunkV18Plus(raw_packet: Uint8Array, num_sections: number, max_bits_per_block: number, max_bits_per_biome: number, protocol: number, section_x: number, section_y: number, section_z: number, section_height: number, world_min_y: number, world_max_y: number, section_data_start_y: number, invisible_blocks: Uint16Array, transparent_blocks: Uint16Array, no_ao_blocks: Uint16Array, cull_identical_blocks: Uint16Array, occluding_blocks: Uint16Array, enable_lighting: boolean, smooth_lighting: boolean, sky_light_value: number): any;
 
+/**
+ * Fused multi-column parse+mesh for 1.18+ raw map_chunk.
+ *
+ * Parses multiple raw packets inside Rust and meshes them in a single
+ * `mesher.generate_multi` call with correct per-neighbor AO/lighting.
+ * No typed arrays are materialised on the JS heap.
+ *
+ * `raw_packets` — `Array<Uint8Array>`, one raw packet per column.
+ * Reuses the existing JS-side per-column buffers (zero concat, zero alloc).
+ *
+ * `num_sections_list` — per-column section count (terrain height varies).
+ *
+ * Invariant: `chunk_xs[0]` / `chunk_zs[0]` is the **target** column whose
+ * geometry is emitted. Neighbour columns provide border data to the mesher
+ * but do not contribute directly to the output.
+ */
+export function generateGeometryFromMapChunkV18PlusMulti(raw_packets: Array<any>, num_sections_list: Uint32Array, max_bits_per_block: number, max_bits_per_biome: number, protocol: number, chunk_xs: Int32Array, chunk_zs: Int32Array, section_x: number, section_y: number, section_z: number, section_height: number, world_min_y: number, world_max_y: number, section_data_start_y: number, invisible_blocks: Uint16Array, transparent_blocks: Uint16Array, no_ao_blocks: Uint16Array, cull_identical_blocks: Uint16Array, occluding_blocks: Uint16Array, enable_lighting: boolean, smooth_lighting: boolean, sky_light_value: number): any;
+
 /**
  * Fused parse+mesh for 1.16 / 1.17 chunk sections.
  *
@@ -41,6 +59,27 @@ export function generateGeometryFromMapChunkV18Plus(raw_packet: Uint8Array, num_
  */
 export function generateGeometryFromParsedV16V17(chunk_data: Uint8Array, bit_map_lo_hi: Uint32Array, num_sections: number, max_bits_per_block: number, biomes_cells: Int32Array, default_biome: number, sky_light: Uint8Array, block_light: Uint8Array, section_x: number, section_y: number, section_z: number, section_height: number, world_min_y: number, world_max_y: number, section_data_start_y: number, invisible_blocks: Uint16Array, transparent_blocks: Uint16Array, no_ao_blocks: Uint16Array, cull_identical_blocks: Uint16Array, occluding_blocks: Uint16Array, enable_lighting: boolean, smooth_lighting: boolean, sky_light_value: number): any;
 
+/**
+ * Fused multi-column parse+mesh for 1.16 / 1.17 chunk sections.
+ *
+ * Parses multiple columns inside Rust and meshes them in one
+ * `mesher.generate_multi` call.  Block states and biomes never leave WASM
+ * memory; light arrays are passed by reference from the JS-side
+ * update-light caches.
+ *
+ * `chunk_data_list` — `Array<Uint8Array>`, one chunk_data buffer per column.
+ * `bit_map_lo_hi` — flat `&[u32]` of length `chunkCount * 2`; each pair
+ *                    (lo, hi) is the section mask for one column.
+ * `num_sections_list` — per-column section count.
+ * `biomes_cells_list` — `Array<Int32Array>`, may contain empty arrays for
+ *                        columns without captured biomes.
+ * `sky_light_list` / `block_light_list` — `Array<Uint8Array>`, may contain
+ *   empty arrays for columns where update_light has not arrived yet.
+ *
+ * Invariant: `chunk_xs[0]` / `chunk_zs[0]` is the target column.
+ */
+export function generateGeometryFromParsedV16V17Multi(chunk_data_list: Array<any>, bit_map_lo_hi: Uint32Array, num_sections_list: Uint32Array, max_bits_per_block: number, biomes_cells_list: Array<any>, default_biome: number, sky_light_list: Array<any>, block_light_list: Array<any>, chunk_xs: Int32Array, chunk_zs: Int32Array, section_x: number, section_y: number, section_z: number, section_height: number, world_min_y: number, world_max_y: number, section_data_start_y: number, invisible_blocks: Uint16Array, transparent_blocks: Uint16Array, no_ao_blocks: Uint16Array, cull_identical_blocks: Uint16Array, occluding_blocks: Uint16Array, enable_lighting: boolean, smooth_lighting: boolean, sky_light_value: number): any;
+
 /**
  * Main entry point for generating geometry
  *
@@ -177,6 +216,8 @@ export interface InitOutput {
   readonly parseMapChunkV18Plus: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
   readonly parseChunkSectionsV16V17: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => any;
   readonly generateGeometryFromParsedV16V17: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number) => any;
+  readonly generateGeometryFromMapChunkV18PlusMulti: (a: any, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number) => any;
+  readonly generateGeometryFromParsedV16V17Multi: (a: any, b: number, c: number, d: number, e: number, f: number, g: any, h: number, i: any, j: any, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number, h1: number) => any;
   readonly parseUpdateLightV17: (a: number, b: number, c: number) => any;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;

package/src/wasm-mesher/runtime-build/wasm_mesher.js

@@ -71,6 +71,11 @@ function debugString(val) {
     return className;
 }
 
+function getArrayI32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getInt32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayU16FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
@@ -89,6 +94,14 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
+let cachedInt32ArrayMemory0 = null;
+function getInt32ArrayMemory0() {
+    if (cachedInt32ArrayMemory0 === null || cachedInt32ArrayMemory0.byteLength === 0) {
+        cachedInt32ArrayMemory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachedInt32ArrayMemory0;
+}
+
 function getStringFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return decodeText(ptr, len);
@@ -328,6 +341,66 @@ export function generateGeometryFromMapChunkV18Plus(raw_packet, num_sections, ma
     return ret;
 }
 
+/**
+ * Fused multi-column parse+mesh for 1.18+ raw map_chunk.
+ *
+ * Parses multiple raw packets inside Rust and meshes them in a single
+ * `mesher.generate_multi` call with correct per-neighbor AO/lighting.
+ * No typed arrays are materialised on the JS heap.
+ *
+ * `raw_packets` — `Array<Uint8Array>`, one raw packet per column.
+ * Reuses the existing JS-side per-column buffers (zero concat, zero alloc).
+ *
+ * `num_sections_list` — per-column section count (terrain height varies).
+ *
+ * Invariant: `chunk_xs[0]` / `chunk_zs[0]` is the **target** column whose
+ * geometry is emitted. Neighbour columns provide border data to the mesher
+ * but do not contribute directly to the output.
+ * @param {Array<any>} raw_packets
+ * @param {Uint32Array} num_sections_list
+ * @param {number} max_bits_per_block
+ * @param {number} max_bits_per_biome
+ * @param {number} protocol
+ * @param {Int32Array} chunk_xs
+ * @param {Int32Array} chunk_zs
+ * @param {number} section_x
+ * @param {number} section_y
+ * @param {number} section_z
+ * @param {number} section_height
+ * @param {number} world_min_y
+ * @param {number} world_max_y
+ * @param {number} section_data_start_y
+ * @param {Uint16Array} invisible_blocks
+ * @param {Uint16Array} transparent_blocks
+ * @param {Uint16Array} no_ao_blocks
+ * @param {Uint16Array} cull_identical_blocks
+ * @param {Uint16Array} occluding_blocks
+ * @param {boolean} enable_lighting
+ * @param {boolean} smooth_lighting
+ * @param {number} sky_light_value
+ * @returns {any}
+ */
+export function generateGeometryFromMapChunkV18PlusMulti(raw_packets, num_sections_list, max_bits_per_block, max_bits_per_biome, protocol, chunk_xs, chunk_zs, section_x, section_y, section_z, section_height, world_min_y, world_max_y, section_data_start_y, invisible_blocks, transparent_blocks, no_ao_blocks, cull_identical_blocks, occluding_blocks, enable_lighting, smooth_lighting, sky_light_value) {
+    const ptr0 = passArray32ToWasm0(num_sections_list, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray32ToWasm0(chunk_xs, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray32ToWasm0(chunk_zs, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passArray16ToWasm0(invisible_blocks, wasm.__wbindgen_malloc);
+    const len3 = WASM_VECTOR_LEN;
+    const ptr4 = passArray16ToWasm0(transparent_blocks, wasm.__wbindgen_malloc);
+    const len4 = WASM_VECTOR_LEN;
+    const ptr5 = passArray16ToWasm0(no_ao_blocks, wasm.__wbindgen_malloc);
+    const len5 = WASM_VECTOR_LEN;
+    const ptr6 = passArray16ToWasm0(cull_identical_blocks, wasm.__wbindgen_malloc);
+    const len6 = WASM_VECTOR_LEN;
+    const ptr7 = passArray16ToWasm0(occluding_blocks, wasm.__wbindgen_malloc);
+    const len7 = WASM_VECTOR_LEN;
+    const ret = wasm.generateGeometryFromMapChunkV18PlusMulti(raw_packets, ptr0, len0, max_bits_per_block, max_bits_per_biome, protocol, ptr1, len1, ptr2, len2, section_x, section_y, section_z, section_height, world_min_y, world_max_y, section_data_start_y, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, enable_lighting, smooth_lighting, sky_light_value);
+    return ret;
+}
+
 /**
  * Fused parse+mesh for 1.16 / 1.17 chunk sections.
  *
@@ -389,6 +462,74 @@ export function generateGeometryFromParsedV16V17(chunk_data, bit_map_lo_hi, num_
     return ret;
 }
 
+/**
+ * Fused multi-column parse+mesh for 1.16 / 1.17 chunk sections.
+ *
+ * Parses multiple columns inside Rust and meshes them in one
+ * `mesher.generate_multi` call.  Block states and biomes never leave WASM
+ * memory; light arrays are passed by reference from the JS-side
+ * update-light caches.
+ *
+ * `chunk_data_list` — `Array<Uint8Array>`, one chunk_data buffer per column.
+ * `bit_map_lo_hi` — flat `&[u32]` of length `chunkCount * 2`; each pair
+ *                    (lo, hi) is the section mask for one column.
+ * `num_sections_list` — per-column section count.
+ * `biomes_cells_list` — `Array<Int32Array>`, may contain empty arrays for
+ *                        columns without captured biomes.
+ * `sky_light_list` / `block_light_list` — `Array<Uint8Array>`, may contain
+ *   empty arrays for columns where update_light has not arrived yet.
+ *
+ * Invariant: `chunk_xs[0]` / `chunk_zs[0]` is the target column.
+ * @param {Array<any>} chunk_data_list
+ * @param {Uint32Array} bit_map_lo_hi
+ * @param {Uint32Array} num_sections_list
+ * @param {number} max_bits_per_block
+ * @param {Array<any>} biomes_cells_list
+ * @param {number} default_biome
+ * @param {Array<any>} sky_light_list
+ * @param {Array<any>} block_light_list
+ * @param {Int32Array} chunk_xs
+ * @param {Int32Array} chunk_zs
+ * @param {number} section_x
+ * @param {number} section_y
+ * @param {number} section_z
+ * @param {number} section_height
+ * @param {number} world_min_y
+ * @param {number} world_max_y
+ * @param {number} section_data_start_y
+ * @param {Uint16Array} invisible_blocks
+ * @param {Uint16Array} transparent_blocks
+ * @param {Uint16Array} no_ao_blocks
+ * @param {Uint16Array} cull_identical_blocks
+ * @param {Uint16Array} occluding_blocks
+ * @param {boolean} enable_lighting
+ * @param {boolean} smooth_lighting
+ * @param {number} sky_light_value
+ * @returns {any}
+ */
+export function generateGeometryFromParsedV16V17Multi(chunk_data_list, bit_map_lo_hi, num_sections_list, max_bits_per_block, biomes_cells_list, default_biome, sky_light_list, block_light_list, chunk_xs, chunk_zs, section_x, section_y, section_z, section_height, world_min_y, world_max_y, section_data_start_y, invisible_blocks, transparent_blocks, no_ao_blocks, cull_identical_blocks, occluding_blocks, enable_lighting, smooth_lighting, sky_light_value) {
+    const ptr0 = passArray32ToWasm0(bit_map_lo_hi, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray32ToWasm0(num_sections_list, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray32ToWasm0(chunk_xs, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passArray32ToWasm0(chunk_zs, wasm.__wbindgen_malloc);
+    const len3 = WASM_VECTOR_LEN;
+    const ptr4 = passArray16ToWasm0(invisible_blocks, wasm.__wbindgen_malloc);
+    const len4 = WASM_VECTOR_LEN;
+    const ptr5 = passArray16ToWasm0(transparent_blocks, wasm.__wbindgen_malloc);
+    const len5 = WASM_VECTOR_LEN;
+    const ptr6 = passArray16ToWasm0(no_ao_blocks, wasm.__wbindgen_malloc);
+    const len6 = WASM_VECTOR_LEN;
+    const ptr7 = passArray16ToWasm0(cull_identical_blocks, wasm.__wbindgen_malloc);
+    const len7 = WASM_VECTOR_LEN;
+    const ptr8 = passArray16ToWasm0(occluding_blocks, wasm.__wbindgen_malloc);
+    const len8 = WASM_VECTOR_LEN;
+    const ret = wasm.generateGeometryFromParsedV16V17Multi(chunk_data_list, ptr0, len0, ptr1, len1, max_bits_per_block, biomes_cells_list, default_biome, sky_light_list, block_light_list, ptr2, len2, ptr3, len3, section_x, section_y, section_z, section_height, world_min_y, world_max_y, section_data_start_y, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, enable_lighting, smooth_lighting, sky_light_value);
+    return ret;
+}
+
 /**
  * Main entry point for generating geometry
  *
@@ -750,6 +891,30 @@ function __wbg_get_imports() {
     imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
         throw new Error(getStringFromWasm0(arg0, arg1));
     };
+    imports.wbg.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
+        const ret = arg0[arg1 >>> 0];
+        return ret;
+    };
+    imports.wbg.__wbg_instanceof_Int32Array_b6281022039fba32 = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof Int32Array;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_instanceof_Uint8Array_da54ccc9d3e09434 = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof Uint8Array;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
     imports.wbg.__wbg_length_22ac23eaec9d8053 = function(arg0) {
         const ret = arg0.length;
         return ret;
@@ -758,6 +923,10 @@ function __wbg_get_imports() {
         const ret = arg0.length;
         return ret;
     };
+    imports.wbg.__wbg_length_ab53989976907f11 = function(arg0) {
+        const ret = arg0.length;
+        return ret;
+    };
     imports.wbg.__wbg_new_1ba21ce319a06297 = function() {
         const ret = new Object();
         return ret;
@@ -766,6 +935,10 @@ function __wbg_get_imports() {
         const ret = new Array();
         return ret;
     };
+    imports.wbg.__wbg_new_with_length_1e8603a5c71d4e06 = function(arg0) {
+        const ret = new Int32Array(arg0 >>> 0);
+        return ret;
+    };
     imports.wbg.__wbg_new_with_length_aa5eaf41d35235e5 = function(arg0) {
         const ret = new Uint8Array(arg0 >>> 0);
         return ret;
@@ -774,6 +947,12 @@ function __wbg_get_imports() {
         const ret = new Uint16Array(arg0 >>> 0);
         return ret;
     };
+    imports.wbg.__wbg_prototypesetcall_dd07c344a74d4bfd = function(arg0, arg1, arg2) {
+        Int32Array.prototype.set.call(getArrayI32FromWasm0(arg0, arg1), arg2);
+    };
+    imports.wbg.__wbg_prototypesetcall_dfe9b766cdc1f1fd = function(arg0, arg1, arg2) {
+        Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+    };
     imports.wbg.__wbg_set_169e13b608078b7b = function(arg0, arg1, arg2) {
         arg0.set(getArrayU8FromWasm0(arg1, arg2));
     };
@@ -822,6 +1001,7 @@ function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
     cachedDataViewMemory0 = null;
+    cachedInt32ArrayMemory0 = null;
     cachedUint16ArrayMemory0 = null;
     cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;

package/src/wasm-mesher/runtime-build/wasm_mesher_bg.wasm.d.ts

@@ -14,6 +14,8 @@ export const generateGeometryFromMapChunkV18Plus: (a: number, b: number, c: numb
 export const parseMapChunkV18Plus: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
 export const parseChunkSectionsV16V17: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => any;
 export const generateGeometryFromParsedV16V17: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number) => any;
+export const generateGeometryFromMapChunkV18PlusMulti: (a: any, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number) => any;
+export const generateGeometryFromParsedV16V17Multi: (a: any, b: number, c: number, d: number, e: number, f: number, g: any, h: number, i: any, j: any, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number, h1: number) => any;
 export const parseUpdateLightV17: (a: number, b: number, c: number) => any;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;

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

@@ -519,6 +519,167 @@ const meshColumnFromParsedV16V17 = (
   }
 }
 
+// ---------------------------------------------------------------------------
+// Fused multi-column helpers.
+// Zero-alloc: reuse existing TypedArray buffers from caches, no concat.
+// ---------------------------------------------------------------------------
+
+const meshMultiColumnsFromRawV18Plus = (
+  chunksToUse: Array<{ x: number, z: number, chunk: any }>,
+  x: number,
+  z: number,
+  worldMinY: number,
+  worldMaxY: number,
+  meta: ReturnType<typeof getBlockMeta>
+): any | null => {
+  if (!wasm || !(wasm as any).generateGeometryFromMapChunkV18PlusMulti) return null
+  const chunkCount = chunksToUse.length
+  if (chunkCount === 0) return null
+
+  const rawPackets: Uint8Array[] = []
+  const numSectionsList = new Uint32Array(chunkCount)
+  const chunkXs = new Int32Array(chunkCount)
+  const chunkZs = new Int32Array(chunkCount)
+  let protocol = 0
+
+  for (let i = 0; i < chunkCount; i++) {
+    const raw = rawMapChunkCache.get(rawCacheKey(chunksToUse[i].x, chunksToUse[i].z))
+    if (!raw || raw.protocol < 757) return null
+    rawPackets.push(raw.rawPacket)
+    numSectionsList[i] = raw.numSections
+    chunkXs[i] = chunksToUse[i].x
+    chunkZs[i] = chunksToUse[i].z
+    if (i === 0) protocol = raw.protocol
+  }
+
+  const columnHeight = worldMaxY - worldMinY
+  try {
+    return (wasm as any).generateGeometryFromMapChunkV18PlusMulti(
+      rawPackets,
+      numSectionsList,
+      MAX_BITS_PER_BLOCK,
+      MAX_BITS_PER_BIOME,
+      protocol,
+      chunkXs,
+      chunkZs,
+      x, worldMinY, z, columnHeight,
+      worldMinY, worldMaxY,
+      worldMinY,
+      meta.invisibleBlocks,
+      meta.transparentBlocks,
+      meta.noAoBlocks,
+      meta.cullIdenticalBlocks,
+      meta.occludingBlocks,
+      config?.enableLighting !== false,
+      config?.smoothLighting !== false,
+      config?.skyLight || 15
+    )
+  } catch (err) {
+    console.warn('[WASM Mesher] generateGeometryFromMapChunkV18PlusMulti failed:', err)
+    return null
+  }
+}
+
+const meshMultiColumnsFromParsedV16V17 = (
+  chunksToUse: Array<{ x: number, z: number, chunk: any }>,
+  x: number,
+  z: number,
+  worldMinY: number,
+  worldMaxY: number,
+  meta: ReturnType<typeof getBlockMeta>
+): any | null => {
+  if (!wasm || !(wasm as any).generateGeometryFromParsedV16V17Multi) return null
+  const chunkCount = chunksToUse.length
+  if (chunkCount === 0) return null
+
+  // Determine which cache family owns all columns. Homogeneity is
+  // guaranteed by the server protocol version: v16 and v17 caches are
+  // never populated simultaneously within a session.
+  let family: 'v17' | 'v16' | null = null
+  for (let i = 0; i < chunkCount; i++) {
+    const key = rawCacheKey(chunksToUse[i].x, chunksToUse[i].z)
+    if (parsedV17Cache.has(key)) {
+      if (family === 'v16') return null
+      family = 'v17'
+    } else if (parsedV16Cache.has(key)) {
+      if (family === 'v17') return null
+      family = 'v16'
+    } else {
+      return null
+    }
+  }
+  if (!family) return null
+
+  const chunkDataList: Uint8Array[] = []
+  const biomesList: Int32Array[] = []
+  const skyLightList: Uint8Array[] = []
+  const blockLightList: Uint8Array[] = []
+  const numSectionsList = new Uint32Array(chunkCount)
+  const chunkXs = new Int32Array(chunkCount)
+  const chunkZs = new Int32Array(chunkCount)
+  const bitMapLoHi = new Uint32Array(chunkCount * 2)
+  let maxBitsPerBlock = 15
+
+  for (let i = 0; i < chunkCount; i++) {
+    const key = rawCacheKey(chunksToUse[i].x, chunksToUse[i].z)
+    if (family === 'v17') {
+      const entry = parsedV17Cache.get(key)!
+      chunkDataList.push(entry.chunkData)
+      biomesList.push(entry.biomes ?? new Int32Array(0))
+      numSectionsList[i] = entry.numSections
+      bitMapLoHi[i * 2] = entry.bitMapLoHi[0]
+      bitMapLoHi[i * 2 + 1] = entry.bitMapLoHi[1]
+      if (i === 0) maxBitsPerBlock = entry.maxBitsPerBlock
+      const light = updateLightV17Cache.get(key)
+      skyLightList.push(light?.skyLight ?? new Uint8Array(0))
+      blockLightList.push(light?.blockLight ?? new Uint8Array(0))
+    } else {
+      const entry = parsedV16Cache.get(key)!
+      chunkDataList.push(entry.chunkData)
+      biomesList.push(entry.biomes ?? new Int32Array(0))
+      numSectionsList[i] = 16
+      const bm = entry.bitMap >>> 0
+      bitMapLoHi[i * 2] = bm
+      bitMapLoHi[i * 2 + 1] = 0
+      const light = updateLightV16Cache.get(key)
+      skyLightList.push(light?.skyLight ?? new Uint8Array(0))
+      blockLightList.push(light?.blockLight ?? new Uint8Array(0))
+    }
+    chunkXs[i] = chunksToUse[i].x
+    chunkZs[i] = chunksToUse[i].z
+  }
+
+  const columnHeight = worldMaxY - worldMinY
+  try {
+    return (wasm as any).generateGeometryFromParsedV16V17Multi(
+      chunkDataList,
+      bitMapLoHi,
+      numSectionsList,
+      maxBitsPerBlock,
+      biomesList,
+      1,
+      skyLightList,
+      blockLightList,
+      chunkXs,
+      chunkZs,
+      x, worldMinY, z, columnHeight,
+      worldMinY, worldMaxY,
+      worldMinY,
+      meta.invisibleBlocks,
+      meta.transparentBlocks,
+      meta.noAoBlocks,
+      meta.cullIdenticalBlocks,
+      meta.occludingBlocks,
+      config?.enableLighting !== false,
+      config?.smoothLighting !== false,
+      config?.skyLight || 15
+    )
+  } catch (err) {
+    console.warn('[WASM Mesher] generateGeometryFromParsedV16V17Multi failed:', err)
+    return null
+  }
+}
+
 const handleMessage = async (data: any) => {
   const globalVar: any = globalThis
 
@@ -885,6 +1046,8 @@ function processColumnTick() {
         let t1 = 0
         let usedFusedPath = false
 
+        const meta = getBlockMeta(version)
+
         // ------------------------------------------------------------------
         // Fused fast-path: for single-column meshing (no neighbours), parse
         // and mesh in ONE WASM call so no typed arrays leave Rust memory.
@@ -894,7 +1057,6 @@ function processColumnTick() {
           const rawEntry = rawMapChunkCache.get(rawCacheKey(x, z))
           const v17Entry = parsedV17Cache.get(rawCacheKey(x, z))
           const v16Entry = parsedV16Cache.get(rawCacheKey(x, z))
-          const meta = getBlockMeta(version)
 
           if (rawEntry) {
             wasmResult = meshColumnFromRawV18Plus(rawEntry, x, z, worldMinY, worldMaxY, meta)
@@ -922,7 +1084,23 @@ function processColumnTick() {
             t1 = performance.now()
             wasmPhase = t1 - t0
             preTargetConvert = wasmPhase
-            // prePhase stays 0 — no JS conversion loop ran.
+          }
+        }
+
+        // ------------------------------------------------------------------
+        // Fused multi-column fast-path: parse+mesh all columns in one WASM
+        // call with zero JS typed-array allocation.
+        // Falls back to the old two-step path when the cache is incomplete
+        // or any helper returns null.
+        // ------------------------------------------------------------------
+        if (!wasmResult && chunkCount > 1) {
+          wasmResult = meshMultiColumnsFromRawV18Plus(chunksToUse, x, z, worldMinY, worldMaxY, meta)
+                    ?? meshMultiColumnsFromParsedV16V17(chunksToUse, x, z, worldMinY, worldMaxY, meta)
+          if (wasmResult) {
+            usedFusedPath = true
+            t1 = performance.now()
+            wasmPhase = t1 - t0
+            preTargetConvert = wasmPhase
           }
         }