minecraft-renderer 0.1.79 → 0.1.80

package/src/wasm-mesher/tests/shaderCubeInstances.test.ts

@@ -13,7 +13,7 @@ import {
   packWord2Empty,
   packWord3,
   SHADER_CUBES_FORMAT_VERSION,
-  SHADER_CUBES_WORDS_PER_FACE,
+  SHADER_CUBES_WORDS_PER_FACE
 } from '../bridge/shaderCubeBridge'
 import { GlobalBlockBuffer } from '../../three/globalBlockBuffer'
 import { buildVisibleCubeSpans } from '../../three/cubeDrawSpans'
@@ -54,20 +54,22 @@ test('packWord2: AO diagonal flip sets bit 12', () => {
     visible_faces: 1 << 0, // up only
     ao_data: [[0, 1, 2, 3]], // 0+3 >= 1+2 → flip
     light_data: [[1, 1, 1, 1]],
-    light_combined: [[255, 255, 255, 255]],
+    light_combined: [[255, 255, 255, 255]]
   }
   const { textureIndexMapping, tintPalette } = requireShaderCubeResources()
   const model = {
-    elements: [{
-      faces: {
-        up: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
-        down: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
-        east: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
-        west: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
-        south: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
-        north: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
-      },
-    }],
+    elements: [
+      {
+        faces: {
+          up: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
+          down: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
+          east: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
+          west: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
+          south: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
+          north: { texture: { u: 0, v: 0, su: 16, sv: 16 } }
+        }
+      }
+    ]
   }
   const ok = tryBuildShaderCubeInstances(
     block,
@@ -77,9 +79,9 @@ test('packWord2: AO diagonal flip sets bit 12', () => {
       sectionOrigin: { x: 0, y: 0, z: 0 },
       sectionHeight: 16,
       tintPalette,
-      textureIndexMapping,
+      textureIndexMapping
     },
-    words,
+    words
   )
   expect(ok).toBe(true)
   expect(words.length).toBe(SHADER_CUBES_WORDS_PER_FACE)
@@ -93,20 +95,22 @@ test('packWord0: section-local lx/ly/lz and face id', () => {
     visible_faces: 1 << 2, // east
     ao_data: [[3, 3, 3, 3]],
     light_data: [[0.5, 0.5, 0.5, 0.5]],
-    light_combined: [[128, 128, 128, 128]],
+    light_combined: [[128, 128, 128, 128]]
   }
   const { textureIndexMapping, tintPalette } = requireShaderCubeResources()
   const model = {
-    elements: [{
-      faces: {
-        up: { texture: { u: 16, v: 0, su: 16, sv: 16 } },
-        down: { texture: { u: 16, v: 0, su: 16, sv: 16 } },
-        east: { texture: { u: 16, v: 0, su: 16, sv: 16 } },
-        west: { texture: { u: 16, v: 0, su: 16, sv: 16 } },
-        south: { texture: { u: 16, v: 0, su: 16, sv: 16 } },
-        north: { texture: { u: 16, v: 0, su: 16, sv: 16 } },
-      },
-    }],
+    elements: [
+      {
+        faces: {
+          up: { texture: { u: 16, v: 0, su: 16, sv: 16 } },
+          down: { texture: { u: 16, v: 0, su: 16, sv: 16 } },
+          east: { texture: { u: 16, v: 0, su: 16, sv: 16 } },
+          west: { texture: { u: 16, v: 0, su: 16, sv: 16 } },
+          south: { texture: { u: 16, v: 0, su: 16, sv: 16 } },
+          north: { texture: { u: 16, v: 0, su: 16, sv: 16 } }
+        }
+      }
+    ]
   }
   tryBuildShaderCubeInstances(
     block,
@@ -116,9 +120,9 @@ test('packWord0: section-local lx/ly/lz and face id', () => {
       sectionOrigin: { x: 0, y: 16, z: 0 },
       sectionHeight: 16,
       tintPalette,
-      textureIndexMapping,
+      textureIndexMapping
     },
-    words,
+    words
   )
   const w0 = words[0]!
   expect(w0 & 0xf).toBe(10) // lx
@@ -130,35 +134,24 @@ test('packWord0: section-local lx/ly/lz and face id', () => {
 test('isShaderCubeBlock: rejects model rotation and sectionHeight !== 16', () => {
   const { textureIndexMapping } = requireShaderCubeResources()
   const baseModel = {
-    elements: [{
-      faces: {
-        up: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
-        down: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
-        east: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
-        west: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
-        south: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
-        north: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
-      },
-    }],
+    elements: [
+      {
+        faces: {
+          up: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
+          down: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
+          east: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
+          west: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
+          south: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
+          north: { texture: { u: 0, v: 0, su: 16, sv: 16 } }
+        }
+      }
+    ]
   }
-  expect(isShaderCubeBlock(
-    { blockName: 'stone', blockProps: {}, isCube: true, model: baseModel },
-    baseModel,
-    16,
-    textureIndexMapping,
-  )).toBe(true)
-  expect(isShaderCubeBlock(
-    { blockName: 'stone', blockProps: {}, isCube: true, model: baseModel },
-    baseModel,
-    24,
-    textureIndexMapping,
-  )).toBe(false)
-  expect(isShaderCubeBlock(
-    { blockName: 'stone', blockProps: {}, isCube: true, model: { ...baseModel, y: 90 } },
-    { ...baseModel, y: 90 },
-    16,
-    textureIndexMapping,
-  )).toBe(false)
+  expect(isShaderCubeBlock({ blockName: 'stone', blockProps: {}, isCube: true, model: baseModel }, baseModel, 16, textureIndexMapping)).toBe(true)
+  expect(isShaderCubeBlock({ blockName: 'stone', blockProps: {}, isCube: true, model: baseModel }, baseModel, 24, textureIndexMapping)).toBe(false)
+  expect(
+    isShaderCubeBlock({ blockName: 'stone', blockProps: {}, isCube: true, model: { ...baseModel, y: 90 } }, { ...baseModel, y: 90 }, 16, textureIndexMapping)
+  ).toBe(false)
 })
 
 test('renderWasmOutputToGeometry: stone emits shaderCubes and skips legacy vertices when enabled', () => {
@@ -168,16 +161,11 @@ test('renderWasmOutputToGeometry: stone emits shaderCubes and skips legacy verti
     visible_faces: (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4) | (1 << 5),
     ao_data: Array.from({ length: 6 }, () => [3, 3, 3, 3]),
     light_data: Array.from({ length: 6 }, () => [1, 1, 1, 1]),
-    light_combined: Array.from({ length: 6 }, () => [255, 255, 255, 255]),
+    light_combined: Array.from({ length: 6 }, () => [255, 255, 255, 255])
   }
-  const out = renderWasmOutputToGeometry(
-    { blocks: [block], block_count: 1, block_iterations: 0 },
-    VERSION,
-    '0,0,0',
-    { x: 8, y: 8, z: 8 },
-    undefined,
-    { shaderCubes: true },
-  )
+  const out = renderWasmOutputToGeometry({ blocks: [block], block_count: 1, block_iterations: 0 }, VERSION, '0,0,0', { x: 8, y: 8, z: 8 }, undefined, {
+    shaderCubes: true
+  })
   expect(out.shaderCubes?.count).toBe(6)
   expect(out.shaderCubes?.formatVersion).toBe(SHADER_CUBES_FORMAT_VERSION)
   expect(out.shaderCubes?.words.length).toBe(6 * SHADER_CUBES_WORDS_PER_FACE)
@@ -195,16 +183,11 @@ test('renderWasmOutputToGeometry: shaderCubes false keeps legacy path for stone'
     block_state_id: STONE,
     visible_faces: 1 << 0,
     ao_data: [[3, 3, 3, 3]],
-    light_data: [[1, 1, 1, 1]],
+    light_data: [[1, 1, 1, 1]]
   }
-  const out = renderWasmOutputToGeometry(
-    { blocks: [block], block_count: 1, block_iterations: 0 },
-    VERSION,
-    '0,0,0',
-    { x: 8, y: 8, z: 8 },
-    undefined,
-    { shaderCubes: false },
-  )
+  const out = renderWasmOutputToGeometry({ blocks: [block], block_count: 1, block_iterations: 0 }, VERSION, '0,0,0', { x: 8, y: 8, z: 8 }, undefined, {
+    shaderCubes: false
+  })
   expect(out.shaderCubes).toBeUndefined()
   expect(out.geometry.positions.length).toBeGreaterThan(0)
 })
@@ -223,7 +206,7 @@ const SIX_FACE_TEXTURES = {
   east: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
   west: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
   south: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
-  north: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
+  north: { texture: { u: 0, v: 0, su: 16, sv: 16 } }
 }
 
 function aoCorner0FromWord0(w0: number): number {
@@ -237,7 +220,7 @@ test('south face: AO corners remapped to shader order (elemFaces [0,3,1,2] → s
     visible_faces: 1 << 4, // south
     ao_data: [[0, 3, 1, 2]],
     light_data: [[1, 1, 1, 1]],
-    light_combined: [[10, 20, 30, 40]],
+    light_combined: [[10, 20, 30, 40]]
   }
   const { textureIndexMapping, tintPalette } = requireShaderCubeResources()
   const model = { elements: [{ faces: SIX_FACE_TEXTURES }] }
@@ -246,7 +229,7 @@ test('south face: AO corners remapped to shader order (elemFaces [0,3,1,2] → s
     { blockName: 'stone', blockProps: {}, isCube: true, model },
     model,
     { sectionOrigin: { x: 0, y: 0, z: 0 }, sectionHeight: 16, tintPalette, textureIndexMapping },
-    words,
+    words
   )
   // Shader vi=0 must get elemFaces ao[2]=1, not ao[0]=0
   expect(aoCorner0FromWord0(words[0]!)).toBe(1)
@@ -263,7 +246,7 @@ test('south face: diagonal flip uses remapped AO (differs from raw elemFaces for
     visible_faces: 1 << 4,
     ao_data: [ao],
     light_data: [[1, 1, 1, 1]],
-    light_combined: [[255, 255, 255, 255]],
+    light_combined: [[255, 255, 255, 255]]
   }
   const { textureIndexMapping, tintPalette } = requireShaderCubeResources()
   const model = { elements: [{ faces: SIX_FACE_TEXTURES }] }
@@ -271,25 +254,13 @@ test('south face: diagonal flip uses remapped AO (differs from raw elemFaces for
     sectionOrigin: { x: 0, y: 0, z: 0 },
     sectionHeight: 16,
     tintPalette,
-    textureIndexMapping,
+    textureIndexMapping
   }
-  tryBuildShaderCubeInstances(
-    block,
-    { blockName: 'stone', blockProps: {}, isCube: true, model },
-    model,
-    opts,
-    wordsFlip,
-  )
+  tryBuildShaderCubeInstances(block, { blockName: 'stone', blockProps: {}, isCube: true, model }, model, opts, wordsFlip)
   expect(wordsFlip[2]! & (1 << WORD2.DIAGONAL_FLAG_SHIFT)).not.toBe(0)
 
   // elemFaces [3,0,0,3] → remapped [0,3,3,0]: 0+0 < 3+3 → no diagonal flip
-  tryBuildShaderCubeInstances(
-    { ...block, ao_data: [[3, 0, 0, 3]] },
-    { blockName: 'stone', blockProps: {}, isCube: true, model },
-    model,
-    opts,
-    wordsNoFlip,
-  )
+  tryBuildShaderCubeInstances({ ...block, ao_data: [[3, 0, 0, 3]] }, { blockName: 'stone', blockProps: {}, isCube: true, model }, model, opts, wordsNoFlip)
   expect(wordsNoFlip[2]! & (1 << WORD2.DIAGONAL_FLAG_SHIFT)).toBe(0)
 })
 
@@ -300,7 +271,7 @@ test('doAO false: full bright AO/light and no diagonal flip', () => {
     visible_faces: 1 << 0,
     ao_data: [[0, 0, 0, 0]],
     light_data: [[0, 0, 0, 0]],
-    light_combined: [[0, 0, 0, 0]],
+    light_combined: [[0, 0, 0, 0]]
   }
   const { textureIndexMapping, tintPalette } = requireShaderCubeResources()
   const model = { elements: [{ faces: SIX_FACE_TEXTURES }] }
@@ -313,9 +284,9 @@ test('doAO false: full bright AO/light and no diagonal flip', () => {
       sectionHeight: 16,
       tintPalette,
       textureIndexMapping,
-      doAO: false,
+      doAO: false
     },
-    words,
+    words
   )
   expect(aoCorner0FromWord0(words[0]!)).toBe(3)
   for (let i = 0; i < 4; i++) {
@@ -324,7 +295,7 @@ test('doAO false: full bright AO/light and no diagonal flip', () => {
   expect(words[2]! & (1 << WORD2.DIAGONAL_FLAG_SHIFT)).toBe(0)
 })
 
-const SECTION_ORIGIN_ROUND_TRIP_CASES: Array<{ x: number, y: number, z: number }> = [
+const SECTION_ORIGIN_ROUND_TRIP_CASES: Array<{ x: number; y: number; z: number }> = [
   { x: 0, y: 16, z: 32 },
   { x: 0, y: 0, z: 0 },
   { x: 524288, y: 0, z: 524288 },
@@ -332,33 +303,30 @@ const SECTION_ORIGIN_ROUND_TRIP_CASES: Array<{ x: number, y: number, z: number }
   { x: 33000000, y: 0, z: 33000000 },
   { x: -524288, y: 0, z: -524288 },
   { x: -1000000, y: 0, z: -1000000 },
-  { x: 1000000, y: 0, z: -1000000 },
+  { x: 1000000, y: 0, z: -1000000 }
 ]
 
-test.each(SECTION_ORIGIN_ROUND_TRIP_CASES)(
-  'section base coords round-trip in word2/word3 at origin (%#)',
-  (sectionOrigin) => {
-    const words: number[] = []
-    const block = {
-      position: [10, 17, 4] as [number, number, number],
-      visible_faces: 1 << 2,
-      ao_data: [[3, 3, 3, 3]],
-      light_data: [[1, 1, 1, 1]],
-      light_combined: [[255, 255, 255, 255]],
-    }
-    const { textureIndexMapping, tintPalette } = requireShaderCubeResources()
-    const model = { elements: [{ faces: SIX_FACE_TEXTURES }] }
-    tryBuildShaderCubeInstances(
-      block,
-      { blockName: 'stone', blockProps: {}, isCube: true, model },
-      model,
-      { sectionOrigin, sectionHeight: 16, tintPalette, textureIndexMapping },
-      words,
-    )
-    const base = decodeSectionBaseFromWords(words[2]!, words[3]!)
-    expect(base).toEqual(sectionOrigin)
-  },
-)
+test.each(SECTION_ORIGIN_ROUND_TRIP_CASES)('section base coords round-trip in word2/word3 at origin (%#)', sectionOrigin => {
+  const words: number[] = []
+  const block = {
+    position: [10, 17, 4] as [number, number, number],
+    visible_faces: 1 << 2,
+    ao_data: [[3, 3, 3, 3]],
+    light_data: [[1, 1, 1, 1]],
+    light_combined: [[255, 255, 255, 255]]
+  }
+  const { textureIndexMapping, tintPalette } = requireShaderCubeResources()
+  const model = { elements: [{ faces: SIX_FACE_TEXTURES }] }
+  tryBuildShaderCubeInstances(
+    block,
+    { blockName: 'stone', blockProps: {}, isCube: true, model },
+    model,
+    { sectionOrigin, sectionHeight: 16, tintPalette, textureIndexMapping },
+    words
+  )
+  const base = decodeSectionBaseFromWords(words[2]!, words[3]!)
+  expect(base).toEqual(sectionOrigin)
+})
 
 test('packWord2Empty: bit 18 set regardless of high X/Z bits in word2', () => {
   const empty = packWord2Empty()
@@ -376,7 +344,7 @@ test('section index relative decode past 2^20: exact integer subtract', () => {
     visible_faces: 1 << 2,
     ao_data: [[3, 3, 3, 3]],
     light_data: [[1, 1, 1, 1]],
-    light_combined: [[255, 255, 255, 255]],
+    light_combined: [[255, 255, 255, 255]]
   }
   const { textureIndexMapping, tintPalette } = requireShaderCubeResources()
   const model = { elements: [{ faces: SIX_FACE_TEXTURES }] }
@@ -388,9 +356,9 @@ test('section index relative decode past 2^20: exact integer subtract', () => {
       sectionOrigin: { x: sectionBlockX, y: 0, z: 0 },
       sectionHeight: 16,
       tintPalette,
-      textureIndexMapping,
+      textureIndexMapping
     },
-    words,
+    words
   )
   const base = decodeSectionBaseFromWords(words[2]!, words[3]!)
   const sX = base.x / 16
@@ -404,10 +372,7 @@ test('GlobalBlockBuffer: free-list reuses slot with EMPTY sentinel', () => {
   const mat = createCubeBlockMaterial()
   const buffer = new GlobalBlockBuffer(mat, scene)
 
-  const words = new Uint32Array([
-    1, 2, 0, packWord3(0, 0),
-    3, 4, 0, packWord3(0, 0),
-  ])
+  const words = new Uint32Array([1, 2, 0, packWord3(0, 0), 3, 4, 0, packWord3(0, 0)])
   buffer.addSection('a', words, 2)
   expect(buffer.mesh.geometry.instanceCount).toBe(2)
 
@@ -425,24 +390,24 @@ test('GlobalBlockBuffer: free-list reuses slot with EMPTY sentinel', () => {
 })
 
 type BufferInternals = {
-  pendingRanges: Array<{ start: number, end: number }>
-  pendingMove: { key: string, oldStart: number, newStart: number, count: number } | null
+  pendingRanges: Array<{ start: number; end: number }>
+  pendingMove: { key: string; oldStart: number; newStart: number; count: number } | null
 }
 
 /** True if some queued (not-yet-uploaded) dirty range covers [start, end] — i.e. it WILL hit the GPU. */
-function rangeQueuedForUpload (buffer: GlobalBlockBuffer, start: number, end: number): boolean {
+function rangeQueuedForUpload(buffer: GlobalBlockBuffer, start: number, end: number): boolean {
   return getBufferInternals(buffer).pendingRanges.some(r => r.start <= end && r.end >= start)
 }
 
-function getBufferInternals (buffer: GlobalBlockBuffer): BufferInternals {
+function getBufferInternals(buffer: GlobalBlockBuffer): BufferInternals {
   return buffer as unknown as BufferInternals
 }
 
-function drainAllUploads (buffer: GlobalBlockBuffer): void {
+function drainAllUploads(buffer: GlobalBlockBuffer): void {
   while (getBufferInternals(buffer).pendingRanges.length) buffer.uploadDirtyRange()
 }
 
-function makeSectionWords (faceW0: number[]): Uint32Array {
+function makeSectionWords(faceW0: number[]): Uint32Array {
   const words = new Uint32Array(faceW0.length * 4)
   for (let i = 0; i < faceW0.length; i++) {
     words[i * 4] = faceW0[i]!
@@ -453,7 +418,7 @@ function makeSectionWords (faceW0: number[]): Uint32Array {
   return words
 }
 
-function readSectionFaceWords (buffer: GlobalBlockBuffer, key: string): number[] {
+function readSectionFaceWords(buffer: GlobalBlockBuffer, key: string): number[] {
   const slot = buffer.getSectionSlot(key)
   if (!slot) throw new Error(`missing section ${key}`)
   const geo = buffer.mesh.geometry
@@ -469,12 +434,12 @@ function readSectionFaceWords (buffer: GlobalBlockBuffer, key: string): number[]
   return out
 }
 
-function finishCurrentMove (buffer: GlobalBlockBuffer): void {
+function finishCurrentMove(buffer: GlobalBlockBuffer): void {
   drainAllUploads(buffer)
   buffer.compactStep()
 }
 
-function isEmptyFace (buffer: GlobalBlockBuffer, index: number): boolean {
+function isEmptyFace(buffer: GlobalBlockBuffer, index: number): boolean {
   const w2 = (buffer.mesh.geometry.getAttribute('a_w2') as THREE.InstancedBufferAttribute).array as Uint32Array
   return (w2[index]! & (1 << WORD2.EMPTY_SHIFT)) !== 0
 }
@@ -730,10 +695,7 @@ test('GlobalBlockBuffer: pendingMove draw start uses oldStart for visible spans'
   expect(buffer.getSectionDrawStart('c')).toBe(move!.oldStart)
   expect(buffer.getSectionDrawStart('c')).not.toBe(slotStart)
 
-  const spans = buildVisibleCubeSpans(
-    [{ start: buffer.getSectionDrawStart('c')!, count: 1 }],
-    buffer.getHighWatermark(),
-  )
+  const spans = buildVisibleCubeSpans([{ start: buffer.getSectionDrawStart('c')!, count: 1 }], buffer.getHighWatermark())
   expect(spans[0]?.start).toBe(move!.oldStart)
 
   buffer.dispose()

package/src/wasm-mesher/tests/splitColumnWasmOutput.test.ts

@@ -1,10 +1,6 @@
 //@ts-nocheck
 import { test, expect } from 'vitest'
-import {
-  splitColumnWasmOutputToSections,
-  renderWasmOutputToGeometry,
-  WasmGeometryOutput,
-} from '../bridge/render-from-wasm'
+import { splitColumnWasmOutputToSections, renderWasmOutputToGeometry, WasmGeometryOutput } from '../bridge/render-from-wasm'
 
 const VERSION = '1.16.5'
 const STONE = 1 // 1.16.5 stone state id
@@ -38,7 +34,7 @@ function makeSeamFixture(): WasmGeometryOutput {
         // info is baked in here at the per-block level.
         visible_faces: FACE_DOWN | SIDE_FACES,
         ao_data: [],
-        light_data: [],
+        light_data: []
       })
       blocks.push({
         position: [x, 16, z],
@@ -47,7 +43,7 @@ function makeSeamFixture(): WasmGeometryOutput {
         // other side).
         visible_faces: FACE_UP | SIDE_FACES,
         ao_data: [],
-        light_data: [],
+        light_data: []
       })
     }
   }
@@ -58,12 +54,12 @@ function makeSeamFixture(): WasmGeometryOutput {
     block_state_id: STONE,
     visible_faces: FACE_UP | FACE_DOWN | SIDE_FACES,
     ao_data: [],
-    light_data: [],
+    light_data: []
   })
   return {
     blocks,
     block_count: blocks.length,
-    block_iterations: 0,
+    block_iterations: 0
   }
 }
 
@@ -71,15 +67,15 @@ test('splitColumnWasmOutputToSections: per-section split is equivalent to manual
   const fullColumn = makeSeamFixture()
 
   const requested = [
-    { x: 0, y: 0, z: 0 },   // contains Y=15 row only
-    { x: 0, y: 16, z: 0 },  // contains Y=16 row only
-    { x: 0, y: 32, z: 0 },  // empty section
-    { x: 0, y: 64, z: 0 },  // contains the isolated block at Y=64
+    { x: 0, y: 0, z: 0 }, // contains Y=15 row only
+    { x: 0, y: 16, z: 0 }, // contains Y=16 row only
+    { x: 0, y: 32, z: 0 }, // empty section
+    { x: 0, y: 64, z: 0 } // contains the isolated block at Y=64
   ]
 
   const split = splitColumnWasmOutputToSections(fullColumn, requested, {
     version: VERSION,
-    shaderCubes: false,
+    shaderCubes: false
   })
 
   expect(split.size).toBe(4)
@@ -98,13 +94,13 @@ test('splitColumnWasmOutputToSections: per-section split is equivalent to manual
       {
         blocks: sectionBlocks,
         block_count: sectionBlocks.length,
-        block_iterations: fullColumn.block_iterations,
+        block_iterations: fullColumn.block_iterations
       },
       VERSION,
       `${r.x},${r.y},${r.z}`,
       { x: r.x + 8, y: r.y + 8, z: r.z + 8 },
       undefined,
-      { shaderCubes: false },
+      { shaderCubes: false }
     )
     const got = split.get(`${r.x},${r.y},${r.z}`)!.exported
     expect(got.key).toBe(reference.key)
@@ -149,7 +145,7 @@ test('splitColumnWasmOutputToSections: empty requested-keys list returns empty m
   const fullColumn = makeSeamFixture()
   const out = splitColumnWasmOutputToSections(fullColumn, [], {
     version: VERSION,
-    shaderCubes: false,
+    shaderCubes: false
   })
   expect(out.size).toBe(0)
 })
@@ -158,11 +154,7 @@ test('splitColumnWasmOutputToSections: blocks outside requested sections are dro
   const fullColumn = makeSeamFixture()
   // Only request the empty Y=32 section. Y=15/16/64 blocks must NOT
   // leak into it.
-  const out = splitColumnWasmOutputToSections(
-    fullColumn,
-    [{ x: 0, y: 32, z: 0 }],
-    { version: VERSION, shaderCubes: false },
-  )
+  const out = splitColumnWasmOutputToSections(fullColumn, [{ x: 0, y: 32, z: 0 }], { version: VERSION, shaderCubes: false })
   const empty = out.get('0,32,0')!
   expect(empty.exported.geometry.positions).toEqual([])
   expect(empty.exported.geometry.indices).toEqual([])