minecraft-renderer 0.1.79 → 0.1.81

package/src/three/tests/globalBlockBuffer.test.ts

@@ -0,0 +1,217 @@
+//@ts-nocheck
+import { describe, expect, test } from 'vitest'
+import * as THREE from 'three'
+import { GlobalBlockBuffer } from '../globalBlockBuffer'
+import { buildVisibleCubeSpans } from '../cubeDrawSpans'
+import { createCubeBlockMaterial } from '../shaders/cubeBlockShader'
+import { packWord3 } from '../../wasm-mesher/bridge/shaderCubeBridge'
+
+type BufferInternals = {
+  pendingRanges: Array<{ start: number; end: number }>
+}
+
+function getInternals(buffer: GlobalBlockBuffer): BufferInternals {
+  return buffer as unknown as BufferInternals
+}
+
+function drainUploads(buffer: GlobalBlockBuffer): void {
+  while (getInternals(buffer).pendingRanges.length) buffer.uploadDirtyRange()
+}
+
+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]!
+    words[i * 4 + 1] = 0
+    words[i * 4 + 2] = 0
+    words[i * 4 + 3] = packWord3(0, 0)
+  }
+  return words
+}
+
+function finishCurrentMove(buffer: GlobalBlockBuffer): void {
+  drainUploads(buffer)
+  buffer.compactStep()
+}
+
+test('GlobalBlockBuffer: new section gated until upload completes', () => {
+  const scene = new THREE.Scene()
+  const mat = createCubeBlockMaterial()
+  const buffer = new GlobalBlockBuffer(mat, scene)
+
+  buffer.addSection('a', makeSectionWords([1]), 1)
+  expect(buffer.getSectionDrawStart('a')).toBeUndefined()
+
+  drainUploads(buffer)
+  expect(buffer.getSectionDrawStart('a')).toBe(0)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalBlockBuffer: remesh double-buffers old geometry until upload', () => {
+  const scene = new THREE.Scene()
+  const mat = createCubeBlockMaterial()
+  const buffer = new GlobalBlockBuffer(mat, scene)
+
+  buffer.addSection('a', makeSectionWords([10]), 1)
+  drainUploads(buffer)
+  const oldStart = buffer.getSectionSlot('a')!.start
+
+  buffer.addSection('a', makeSectionWords([20]), 1)
+  expect(buffer.getSectionDrawStart('a')).toBe(oldStart)
+  expect(buffer.hasPendingReplace()).toBe(true)
+
+  const w0 = buffer.mesh.geometry.getAttribute('a_w0').array as Uint32Array
+  expect(w0[oldStart]).toBe(10)
+
+  const epochBefore = buffer.getUploadEpoch()
+  drainUploads(buffer)
+  buffer.compactStep()
+  expect(buffer.hasPendingReplace()).toBe(false)
+  expect(buffer.getUploadEpoch()).toBeGreaterThan(epochBefore)
+  finishCurrentMove(buffer)
+  expect(buffer.getSectionDrawStart('a')).toBe(buffer.getSectionSlot('a')!.start)
+  expect(w0[buffer.getSectionSlot('a')!.start]).toBe(20)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalBlockBuffer: remesh before previous upload completes keeps fully-uploaded fallback', () => {
+  const scene = new THREE.Scene()
+  const mat = createCubeBlockMaterial()
+  const buffer = new GlobalBlockBuffer(mat, scene)
+
+  buffer.addSection('a', makeSectionWords([10]), 1)
+  drainUploads(buffer)
+  buffer.compactStep()
+  const slotA = buffer.getSectionSlot('a')!.start
+
+  buffer.addSection('a', makeSectionWords([20]), 1)
+  expect(buffer.hasPendingReplace()).toBe(true)
+  expect(buffer.hasPendingUploads()).toBe(true)
+
+  buffer.addSection('a', makeSectionWords([30]), 1)
+
+  const drawStart = buffer.getSectionDrawStart('a')
+  const drawCount = buffer.getSectionDrawCount('a')!
+  expect(drawStart).toBe(slotA)
+  expect(buffer.isRangeFullyUploaded(drawStart!, drawStart! + drawCount - 1)).toBe(true)
+
+  const spans = buildVisibleCubeSpans(
+    [{ start: drawStart!, count: drawCount }],
+    buffer.getHighWatermark(),
+    false,
+    (start, end) => buffer.isRangeFullyUploaded(start, end),
+    buffer.getPendingDirtyRanges()
+  )
+  expect(spans.length).toBeGreaterThan(0)
+  expect(spans.some(s => s.start <= drawStart! && s.start + s.count > drawStart!)).toBe(true)
+
+  const w0 = buffer.mesh.geometry.getAttribute('a_w0').array as Uint32Array
+  expect(w0[slotA]).toBe(10)
+
+  drainUploads(buffer)
+  buffer.compactStep()
+  finishCurrentMove(buffer)
+  const slotC = buffer.getSectionSlot('a')!.start
+  expect(buffer.getSectionDrawStart('a')).toBe(slotC)
+  expect(w0[slotC]).toBe(30)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalBlockBuffer: remesh stays drawable when slot kept (updateSection flow)', () => {
+  const scene = new THREE.Scene()
+  const mat = createCubeBlockMaterial()
+  const buffer = new GlobalBlockBuffer(mat, scene)
+
+  buffer.addSection('a', makeSectionWords([10]), 1)
+  drainUploads(buffer)
+  expect(buffer.getSectionDrawStart('a')).toBe(0)
+
+  // updateSection forRemesh: do NOT removeSection before addSection
+  buffer.addSection('a', makeSectionWords([20]), 1)
+  expect(buffer.getSectionDrawStart('a')).toBeDefined()
+  expect(buffer.hasPendingReplace()).toBe(true)
+
+  drainUploads(buffer)
+  buffer.compactStep()
+  expect(buffer.hasPendingReplace()).toBe(false)
+  finishCurrentMove(buffer)
+  expect(buffer.getSectionDrawStart('a')).toBe(buffer.getSectionSlot('a')!.start)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalBlockBuffer: pre-remove before remesh leaves drawable hole until upload', () => {
+  const scene = new THREE.Scene()
+  const mat = createCubeBlockMaterial()
+  const buffer = new GlobalBlockBuffer(mat, scene)
+
+  buffer.addSection('a', makeSectionWords([10]), 1)
+  drainUploads(buffer)
+
+  buffer.removeSection('a')
+  buffer.addSection('a', makeSectionWords([20]), 1)
+  expect(buffer.getSectionDrawStart('a')).toBeUndefined()
+  expect(buffer.hasPendingReplace()).toBe(false)
+
+  drainUploads(buffer)
+  expect(buffer.getSectionDrawStart('a')).toBeDefined()
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalBlockBuffer: canUseFullDrawShortcut false while uploads pending', () => {
+  const scene = new THREE.Scene()
+  const mat = createCubeBlockMaterial()
+  const buffer = new GlobalBlockBuffer(mat, scene)
+
+  buffer.addSection('a', makeSectionWords([1, 2, 3]), 3)
+  expect(buffer.canUseFullDrawShortcut()).toBe(false)
+
+  drainUploads(buffer)
+  expect(buffer.canUseFullDrawShortcut()).toBe(true)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalBlockBuffer: uploadEpoch increments on partial upload advance', () => {
+  const scene = new THREE.Scene()
+  const mat = createCubeBlockMaterial()
+  const buffer = new GlobalBlockBuffer(mat, scene)
+
+  const faceCount = 20_000
+  const words = new Uint32Array(faceCount * 4)
+  for (let i = 0; i < faceCount; i++) {
+    words[i * 4] = i + 1
+  }
+  buffer.addSection('a', words, faceCount)
+  const epoch0 = buffer.getUploadEpoch()
+  buffer.uploadDirtyRange()
+  expect(buffer.getUploadEpoch()).toBe(epoch0 + 1)
+  expect(buffer.hasPendingUploads()).toBe(true)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalBlockBuffer: uploadEpoch increments when dirty range drains', () => {
+  const scene = new THREE.Scene()
+  const mat = createCubeBlockMaterial()
+  const buffer = new GlobalBlockBuffer(mat, scene)
+
+  const epoch0 = buffer.getUploadEpoch()
+  buffer.addSection('a', makeSectionWords([1]), 1)
+  drainUploads(buffer)
+  expect(buffer.getUploadEpoch()).toBeGreaterThan(epoch0)
+
+  buffer.dispose()
+  mat.dispose()
+})

package/src/three/tests/globalLegacyBuffer.test.ts

@@ -1,10 +1,10 @@
 //@ts-nocheck
 import { describe, expect, test } from 'vitest'
 import * as THREE from 'three'
-import { GlobalLegacyBuffer, MAX_OPAQUE_SPANS } from '../globalLegacyBuffer'
+import { GlobalLegacyBuffer, MAX_OPAQUE_SPANS, carveSpansAroundPendingRanges } from '../globalLegacyBuffer'
 import { createGlobalLegacyBlockMaterial } from '../shaders/legacyBlockShader'
 
-function makeQuadGeometry (): {
+function makeQuadGeometry(): {
   positions: Float32Array
   colors: Float32Array
   skyLights: Float32Array
@@ -13,50 +13,35 @@ function makeQuadGeometry (): {
   indices: Uint32Array
 } {
   return {
-    positions: new Float32Array([
-      -1, 0, -1,
-      1, 0, -1,
-      1, 0, 1,
-      -1, 0, 1,
-    ]),
-    colors: new Float32Array([
-      1, 1, 1,
-      1, 1, 1,
-      1, 1, 1,
-      1, 1, 1,
-    ]),
+    positions: new Float32Array([-1, 0, -1, 1, 0, -1, 1, 0, 1, -1, 0, 1]),
+    colors: new Float32Array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),
     skyLights: new Float32Array([1, 1, 1, 1]),
     blockLights: new Float32Array([0, 0, 0, 0]),
-    uvs: new Float32Array([
-      0, 0,
-      1, 0,
-      1, 1,
-      0, 1,
-    ]),
-    indices: new Uint32Array([0, 1, 2, 0, 2, 3]),
+    uvs: new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]),
+    indices: new Uint32Array([0, 1, 2, 0, 2, 3])
   }
 }
 
 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
   growCapacity: (minQuads: number) => void
 }
 
-function getInternals (buffer: GlobalLegacyBuffer): BufferInternals {
+function getInternals(buffer: GlobalLegacyBuffer): BufferInternals {
   return buffer as unknown as BufferInternals
 }
 
-function drainUploads (buffer: GlobalLegacyBuffer): void {
+function drainUploads(buffer: GlobalLegacyBuffer): void {
   while (getInternals(buffer).pendingRanges.length) buffer.uploadDirtyRange()
 }
 
-function finishCurrentMove (buffer: GlobalLegacyBuffer): void {
+function finishCurrentMove(buffer: GlobalLegacyBuffer): void {
   drainUploads(buffer)
   buffer.compactStep()
 }
 
-function readSectionIndices (buffer: GlobalLegacyBuffer, key: string): number[] {
+function readSectionIndices(buffer: GlobalLegacyBuffer, key: string): number[] {
   const slot = buffer.getSectionSlot(key)
   if (!slot) throw new Error(`missing section ${key}`)
   const indexAttr = buffer.mesh.geometry.index!.array as Uint32Array
@@ -207,7 +192,14 @@ test('GlobalLegacyBuffer: updateDrawSpans opaque merges nearby spans', () => {
 
   buffer.addSection('a', geo, 0, 0, 0)
   buffer.addSection('b', geo, 16, 0, 0)
-  buffer.updateDrawSpans([{ key: 'a', distSq: 1 }, { key: 'b', distSq: 4 }], 'opaque')
+  drainUploads(buffer)
+  buffer.updateDrawSpans(
+    [
+      { key: 'a', distSq: 1 },
+      { key: 'b', distSq: 4 }
+    ],
+    'opaque'
+  )
 
   const spans = buffer.getVisibleIndexSpans()
   expect(spans.length).toBe(1)
@@ -226,7 +218,15 @@ test('GlobalLegacyBuffer: updateDrawSpans opaque full draw when most quads visib
   buffer.addSection('a', geo, 0, 0, 0)
   buffer.addSection('b', geo, 16, 0, 0)
   buffer.addSection('c', geo, 32, 0, 0)
-  buffer.updateDrawSpans([{ key: 'a', distSq: 1 }, { key: 'b', distSq: 2 }, { key: 'c', distSq: 3 }], 'opaque')
+  drainUploads(buffer)
+  buffer.updateDrawSpans(
+    [
+      { key: 'a', distSq: 1 },
+      { key: 'b', distSq: 2 },
+      { key: 'c', distSq: 3 }
+    ],
+    'opaque'
+  )
 
   const spans = buffer.getVisibleIndexSpans()
   expect(spans.length).toBe(1)
@@ -245,10 +245,14 @@ test('GlobalLegacyBuffer: updateDrawSpans sortedBlend orders back-to-front', ()
 
   buffer.addSection('near', geo, 0, 0, 0)
   buffer.addSection('far', geo, 16, 0, 0)
-  buffer.updateDrawSpans([
-    { key: 'near', distSq: 1 },
-    { key: 'far', distSq: 100 },
-  ], 'sortedBlend')
+  drainUploads(buffer)
+  buffer.updateDrawSpans(
+    [
+      { key: 'near', distSq: 1 },
+      { key: 'far', distSq: 100 }
+    ],
+    'sortedBlend'
+  )
 
   const spans = buffer.getVisibleIndexSpans()
   expect(spans.length).toBe(2)
@@ -266,6 +270,7 @@ test('GlobalLegacyBuffer: updateDrawSpans skips missing keys', () => {
   const geo = makeQuadGeometry()
 
   buffer.addSection('a', geo, 0, 0, 0)
+  drainUploads(buffer)
   buffer.updateDrawSpans([{ key: 'missing', distSq: 1 }], 'opaque')
 
   expect(buffer.getVisibleIndexSpans().length).toBe(0)
@@ -281,6 +286,7 @@ test('GlobalLegacyBuffer: reset clears visible spans', () => {
   const geo = makeQuadGeometry()
 
   buffer.addSection('a', geo, 0, 0, 0)
+  drainUploads(buffer)
   buffer.updateDrawSpans([{ key: 'a', distSq: 1 }], 'opaque')
   expect(buffer.getVisibleIndexSpans().length).toBeGreaterThan(0)
 
@@ -291,14 +297,14 @@ test('GlobalLegacyBuffer: reset clears visible spans', () => {
   mat.dispose()
 })
 
-test('GlobalLegacyBuffer: updateDrawSpans opaque caps at MAX_OPAQUE_SPANS with full coverage', () => {
+test('GlobalLegacyBuffer: updateDrawSpans opaque does not bridge interior gaps', () => {
   const scene = new THREE.Scene()
   const mat = createGlobalLegacyBlockMaterial()
   const visibleSectionCount = MAX_OPAQUE_SPANS + 5
   const padQuads = 257
   const buffer = new GlobalLegacyBuffer(mat, scene, {
     initialCapacityQuads: visibleSectionCount * (padQuads + 1) + padQuads,
-    growthIncrementQuads: 1024,
+    growthIncrementQuads: 1024
   })
   const geo = makeQuadGeometry()
   const padGeo = {
@@ -308,13 +314,13 @@ test('GlobalLegacyBuffer: updateDrawSpans opaque caps at MAX_OPAQUE_SPANS with f
     skyLights: new Float32Array(padQuads * 4).fill(1),
     blockLights: new Float32Array(padQuads * 4).fill(0),
     uvs: new Float32Array(padQuads * 4 * 2),
-    indices: new Uint32Array(padQuads * 6),
+    indices: new Uint32Array(padQuads * 6)
   }
   for (let q = 0; q < padQuads; q++) {
     const vb = q * 4
     padGeo.indices.set([vb, vb + 1, vb + 2, vb, vb + 2, vb + 3], q * 6)
   }
-  const visible: Array<{ key: string, distSq: number }> = []
+  const visible: Array<{ key: string; distSq: number }> = []
 
   for (let i = 0; i < visibleSectionCount; i++) {
     const key = `s${i}`
@@ -331,10 +337,11 @@ test('GlobalLegacyBuffer: updateDrawSpans opaque caps at MAX_OPAQUE_SPANS with f
     expect(next.start - (cur.start + cur.count)).toBeGreaterThan(256)
   }
 
+  drainUploads(buffer)
   buffer.updateDrawSpans(visible, 'opaque')
 
   const spans = buffer.getVisibleIndexSpans()
-  expect(spans.length).toBe(MAX_OPAQUE_SPANS)
+  expect(spans.length).toBe(visibleSectionCount)
 
   const covered = new Set<number>()
   for (const span of spans) {
@@ -366,7 +373,7 @@ test('GlobalLegacyBuffer: addSection rejects non-quad geometry', () => {
     skyLights: new Float32Array(3).fill(1),
     blockLights: new Float32Array(3).fill(0),
     uvs: new Float32Array(6),
-    indices: new Uint32Array([0, 1, 2]),
+    indices: new Uint32Array([0, 1, 2])
   }
   expect(buffer.addSection('bad', bad, 0, 0, 0)).toBe(false)
 
@@ -469,10 +476,10 @@ test('GlobalLegacyBuffer: sortedBlend accepts more than MAX_OPAQUE_SPANS section
   const sectionCount = MAX_OPAQUE_SPANS + 6
   const buffer = new GlobalLegacyBuffer(mat, scene, {
     initialCapacityQuads: sectionCount + 4,
-    growthIncrementQuads: 64,
+    growthIncrementQuads: 64
   })
   const geo = makeQuadGeometry()
-  const visible: Array<{ key: string, distSq: number }> = []
+  const visible: Array<{ key: string; distSq: number }> = []
 
   for (let i = 0; i < sectionCount; i++) {
     const key = `s${i}`
@@ -480,6 +487,7 @@ test('GlobalLegacyBuffer: sortedBlend accepts more than MAX_OPAQUE_SPANS section
     visible.push({ key, distSq: sectionCount - i })
   }
 
+  drainUploads(buffer)
   buffer.updateDrawSpans(visible, 'sortedBlend')
   expect(buffer.getVisibleIndexSpans().length).toBe(sectionCount)
 
@@ -487,6 +495,257 @@ test('GlobalLegacyBuffer: sortedBlend accepts more than MAX_OPAQUE_SPANS section
   mat.dispose()
 })
 
+test('GlobalLegacyBuffer: new section gated until upload completes', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene)
+  const geo = makeQuadGeometry()
+
+  buffer.addSection('a', geo, 0, 0, 0)
+  expect(buffer.getSectionDrawStart('a')).toBeUndefined()
+  buffer.updateDrawSpans([{ key: 'a', distSq: 1 }], 'opaque')
+  expect(buffer.getVisibleIndexSpans().length).toBe(0)
+
+  drainUploads(buffer)
+  expect(buffer.getSectionDrawStart('a')).toBe(0)
+  buffer.updateDrawSpans([{ key: 'a', distSq: 1 }], 'opaque')
+  expect(buffer.getVisibleIndexSpans().length).toBe(1)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalLegacyBuffer: remesh double-buffers old geometry until upload', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene)
+  const geo = makeQuadGeometry()
+
+  buffer.addSection('a', geo, 0, 0, 0)
+  drainUploads(buffer)
+  const oldStart = buffer.getSectionSlot('a')!.start
+
+  buffer.addSection('a', geo, 16, 0, 0)
+  expect(buffer.getSectionDrawStart('a')).toBe(oldStart)
+  expect(buffer.hasPendingReplace()).toBe(true)
+
+  const indexAttr = buffer.mesh.geometry.index!.array as Uint32Array
+  expect(indexAttr[oldStart * 6 + 1]).not.toBe(0)
+
+  buffer.updateDrawSpans([{ key: 'a', distSq: 1 }], 'opaque')
+  expect(buffer.getVisibleIndexSpans()[0]!.indexStart).toBe(oldStart * 6)
+
+  const epochBefore = buffer.getUploadEpoch()
+  drainUploads(buffer)
+  buffer.compactStep()
+  expect(buffer.hasPendingReplace()).toBe(false)
+  expect(buffer.getUploadEpoch()).toBeGreaterThan(epochBefore)
+  finishCurrentMove(buffer)
+  expect(buffer.getSectionDrawStart('a')).toBe(buffer.getSectionSlot('a')!.start)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalLegacyBuffer: remesh before previous upload completes keeps fully-uploaded fallback', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene)
+  const geo = makeQuadGeometry()
+
+  buffer.addSection('a', geo, 0, 0, 0)
+  drainUploads(buffer)
+  buffer.compactStep()
+  const slotA = buffer.getSectionSlot('a')!.start
+
+  buffer.addSection('a', geo, 16, 0, 0)
+  expect(buffer.hasPendingReplace()).toBe(true)
+  expect(buffer.hasPendingUploads()).toBe(true)
+
+  buffer.addSection('a', geo, 32, 0, 0)
+
+  const drawStart = buffer.getSectionDrawStart('a')
+  const drawCount = buffer.getSectionDrawCount('a')!
+  expect(drawStart).toBe(slotA)
+  expect(buffer.isRangeFullyUploaded(drawStart!, drawStart! + drawCount - 1)).toBe(true)
+
+  buffer.updateDrawSpans([{ key: 'a', distSq: 1 }], 'opaque')
+  const spans = buffer.getVisibleIndexSpans()
+  expect(spans.length).toBeGreaterThan(0)
+  expect(spans.some(s => s.indexStart <= slotA * 6 && s.indexStart + s.indexCount > slotA * 6)).toBe(true)
+
+  const indexAttr = buffer.mesh.geometry.index!.array as Uint32Array
+  expect(indexAttr[slotA * 6 + 1]).not.toBe(0)
+
+  drainUploads(buffer)
+  buffer.compactStep()
+  finishCurrentMove(buffer)
+  const slotC = buffer.getSectionSlot('a')!.start
+  expect(buffer.getSectionDrawStart('a')).toBe(slotC)
+  expect(indexAttr[slotC * 6 + 1]).not.toBe(0)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalLegacyBuffer: full-draw blocked when uploads pending', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene, { initialCapacityQuads: 8, growthIncrementQuads: 8 })
+  const geo = makeQuadGeometry()
+
+  buffer.addSection('a', geo, 0, 0, 0)
+  buffer.addSection('b', geo, 16, 0, 0)
+  buffer.addSection('c', geo, 32, 0, 0)
+  drainUploads(buffer)
+  buffer.addSection('d', geo, 48, 0, 0)
+
+  buffer.updateDrawSpans(
+    [
+      { key: 'a', distSq: 1 },
+      { key: 'b', distSq: 2 },
+      { key: 'c', distSq: 3 }
+    ],
+    'opaque'
+  )
+
+  const spans = buffer.getVisibleIndexSpans()
+  expect(spans.length).toBeGreaterThan(0)
+  expect(spans.some(s => s.indexStart === 0 && s.indexCount === buffer.getHighWatermark() * 6)).toBe(false)
+  expect(spans.reduce((sum, s) => sum + s.indexCount, 0)).toBe(18)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalLegacyBuffer: full-draw allowed when buffer is clean', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene, { initialCapacityQuads: 4, growthIncrementQuads: 4 })
+  const geo = makeQuadGeometry()
+
+  buffer.addSection('a', geo, 0, 0, 0)
+  buffer.addSection('b', geo, 16, 0, 0)
+  buffer.addSection('c', geo, 32, 0, 0)
+  drainUploads(buffer)
+
+  buffer.updateDrawSpans(
+    [
+      { key: 'a', distSq: 1 },
+      { key: 'b', distSq: 2 },
+      { key: 'c', distSq: 3 }
+    ],
+    'opaque'
+  )
+
+  const spans = buffer.getVisibleIndexSpans()
+  expect(spans.length).toBe(1)
+  expect(spans[0]!.indexStart).toBe(0)
+  expect(spans[0]!.indexCount).toBe(buffer.getHighWatermark() * 6)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalLegacyBuffer: uploadEpoch increments on partial upload advance', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene)
+  const geo = makeQuadGeometry()
+
+  for (let i = 0; i < 6000; i++) {
+    buffer.addSection(`s${i}`, geo, i * 16, 0, 0)
+  }
+  const epoch0 = buffer.getUploadEpoch()
+  buffer.uploadDirtyRange()
+  expect(buffer.getUploadEpoch()).toBe(epoch0 + 1)
+  expect(buffer.hasPendingUploads()).toBe(true)
+  buffer.uploadDirtyRange()
+  expect(buffer.getUploadEpoch()).toBe(epoch0 + 2)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalLegacyBuffer: carveSpansAroundPendingRanges splits merged span', () => {
+  const carved = carveSpansAroundPendingRanges([{ start: 0, count: 100 }], [{ start: 40, end: 59 }])
+  expect(carved).toEqual([
+    { start: 0, count: 40 },
+    { start: 60, count: 40 }
+  ])
+})
+
+test('GlobalLegacyBuffer: uploadEpoch increments when dirty range drains', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene)
+  const geo = makeQuadGeometry()
+
+  const epoch0 = buffer.getUploadEpoch()
+  buffer.addSection('a', geo, 0, 0, 0)
+  drainUploads(buffer)
+  expect(buffer.getUploadEpoch()).toBeGreaterThan(epoch0)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalLegacyBuffer: mergeOpaqueSpans only merges adjacent slots', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene, { initialCapacityQuads: 16, growthIncrementQuads: 8 })
+  const geo = makeQuadGeometry()
+
+  buffer.addSection('a', geo, 0, 0, 0)
+  buffer.addSection('b', geo, 16, 0, 0)
+  buffer.addSection('c', geo, 32, 0, 0)
+  drainUploads(buffer)
+
+  buffer.updateDrawSpans(
+    [
+      { key: 'a', distSq: 1 },
+      { key: 'b', distSq: 2 },
+      { key: 'c', distSq: 3 }
+    ],
+    'opaque'
+  )
+  expect(buffer.getVisibleIndexSpans().length).toBe(1)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalLegacyBuffer: mergeOpaqueSpans skips gap with pending upload', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene, { initialCapacityQuads: 8, growthIncrementQuads: 8 })
+  const geo = makeQuadGeometry()
+
+  buffer.addSection('a', geo, 0, 0, 0)
+  buffer.addSection('b', geo, 16, 0, 0)
+  buffer.addSection('c', geo, 32, 0, 0)
+  drainUploads(buffer)
+  buffer.removeSection('b')
+  drainUploads(buffer)
+
+  buffer.addSection('b', geo, 16, 0, 0)
+  buffer.updateDrawSpans(
+    [
+      { key: 'a', distSq: 1 },
+      { key: 'c', distSq: 2 }
+    ],
+    'opaque'
+  )
+
+  const spans = buffer.getVisibleIndexSpans()
+  expect(spans.length).toBe(2)
+  expect(spans[0]!.indexCount).toBe(6)
+  expect(spans[1]!.indexCount).toBe(6)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
 test('GlobalLegacyBuffer: suppressThreeDraw uses minimal non-zero draw range', () => {
   const scene = new THREE.Scene()
   const mat = createGlobalLegacyBlockMaterial()