minecraft-renderer 0.1.78 → 0.1.79

package/package.json

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

package/src/three/chunkMeshManager.ts

@@ -140,6 +140,9 @@ export class ChunkMeshManager {
   private readonly _legacyCullBoxMin = new THREE.Vector3()
   private readonly _legacyCullBoxMax = new THREE.Vector3()
   private readonly _visibleSectionSpans: Array<{ key: string, distSq: number }> = []
+  /** Sections with geometry in global legacy opaque and/or blend buffers — cull/raycast scan only these. */
+  private readonly legacyCullSections = new Map<string, { worldX: number, worldY: number, worldZ: number }>()
+  private _lastCullFingerprint = ''
   /** Drives per-frame cull + span rebuild; cleared after updateSectionCullAndSort. */
   cullDirty = true
   private readonly _lastCullCamPos = new THREE.Vector3()
@@ -384,6 +387,45 @@ export class ChunkMeshManager {
     return this.activeSections.has(sectionKey)
   }
 
+  private registerLegacyCullSection (sectionKey: string, worldX: number, worldY: number, worldZ: number): void {
+    this.legacyCullSections.set(sectionKey, { worldX, worldY, worldZ })
+  }
+
+  private maybeUnregisterLegacyCullSection (sectionKey: string): void {
+    const inOpaque = this.globalLegacyBuffer?.hasSection(sectionKey) ?? false
+    const inBlend = this.globalLegacyBlendBuffer?.hasSection(sectionKey) ?? false
+    if (!inOpaque && !inBlend) {
+      this.legacyCullSections.delete(sectionKey)
+    }
+  }
+
+  private updatePooledLegacyCullState (
+    cameraWorldX: number,
+    cameraWorldY: number,
+    cameraWorldZ: number,
+  ): void {
+    for (const poolEntry of this.activeSections.values()) {
+      const sectionKey = poolEntry.sectionKey
+      if (!sectionKey) continue
+      const sectionObject = this.sectionObjects[sectionKey]
+      if (!sectionObject) continue
+
+      updateLegacySectionCullState(
+        poolEntry.mesh,
+        sectionObject.worldX ?? 0,
+        sectionObject.worldY ?? 0,
+        sectionObject.worldZ ?? 0,
+        cameraWorldX,
+        cameraWorldY,
+        cameraWorldZ,
+        this._legacyCullFrustum,
+        this._legacyCullBox,
+        this._legacyCullBoxMin,
+        this._legacyCullBoxMax,
+      )
+    }
+  }
+
   /**
    * Shared section visibility + span groups for global legacy and cube buffers.
    */
@@ -394,8 +436,9 @@ export class ChunkMeshManager {
     const visible = this._visibleSectionSpans
     visible.length = 0
 
-    for (const [sectionKey, sectionObject] of Object.entries(this.sectionObjects)) {
-      if (sectionObject.worldX === undefined || !sectionObject.visible) continue
+    for (const [sectionKey] of this.legacyCullSections) {
+      const sectionObject = this.sectionObjects[sectionKey]
+      if (!sectionObject?.visible || sectionObject.worldX === undefined) continue
       const { visible: inFrustum, distSq } = sectionIntersectsFrustum(
         sectionObject.worldX,
         sectionObject.worldY ?? 0,
@@ -413,13 +456,27 @@ export class ChunkMeshManager {
       }
     }
 
-    this.globalLegacyBuffer?.updateDrawSpans(visible, 'opaque')
-    this.globalLegacyBlendBuffer?.updateDrawSpans(visible, 'sortedBlend')
-
+    const opaqueBuf = this.globalLegacyBuffer
+    const blendBuf = this.globalLegacyBlendBuffer
     const gb = this.globalBlockBuffer
+
+    const opaqueKeys: string[] = []
+    for (const entry of visible) {
+      if (opaqueBuf?.hasSection(entry.key)) opaqueKeys.push(entry.key)
+    }
+    opaqueKeys.sort()
+
+    const blendVisible = visible.filter(v => blendBuf?.hasSection(v.key))
+    blendVisible.sort((a, b) => b.distSq - a.distSq)
+    const blendKeys = blendVisible.map(v => v.key)
+
+    const cubeVisibleKeys: string[] = []
+    const visibleSlots: Array<{ start: number, count: number }> = []
     if (gb) {
-      const visibleSlots: Array<{ start: number, count: number }> = []
       gb.forEachSectionSlot((key, slot) => {
+        const sectionObject = this.sectionObjects[key]
+        // Keep in sync with legacy gate (line 440).
+        if (!sectionObject?.visible) return
         const entry = this.shaderSectionRaycastBoxes.get(key)
         if (!entry) {
           return
@@ -439,35 +496,39 @@ export class ChunkMeshManager {
         if (!inFrustum) {
           return
         }
+        cubeVisibleKeys.push(key)
         const drawStart = gb.getSectionDrawStart(key)
         if (drawStart !== undefined) {
           visibleSlots.push({ start: drawStart, count: slot.count })
         }
       })
-      const spans = buildVisibleCubeSpans(visibleSlots, gb.getHighWatermark())
-      gb.setVisibleSpans(spans)
     }
+    cubeVisibleKeys.sort()
 
-    for (const poolEntry of this.activeSections.values()) {
-      const sectionKey = poolEntry.sectionKey
-      if (!sectionKey) continue
-      const sectionObject = this.sectionObjects[sectionKey]
-      if (!sectionObject) continue
+    const fingerprint = [
+      opaqueKeys.join(','),
+      blendKeys.join(','),
+      cubeVisibleKeys.join(','),
+      opaqueBuf?.getLayoutVersion() ?? 0,
+      blendBuf?.getLayoutVersion() ?? 0,
+      gb?.getLayoutVersion() ?? 0,
+    ].join('|')
 
-      updateLegacySectionCullState(
-        poolEntry.mesh,
-        sectionObject.worldX ?? 0,
-        sectionObject.worldY ?? 0,
-        sectionObject.worldZ ?? 0,
-        cameraWorldX,
-        cameraWorldY,
-        cameraWorldZ,
-        this._legacyCullFrustum,
-        this._legacyCullBox,
-        this._legacyCullBoxMin,
-        this._legacyCullBoxMax,
-      )
+    if (fingerprint === this._lastCullFingerprint) {
+      this.updatePooledLegacyCullState(cameraWorldX, cameraWorldY, cameraWorldZ)
+      return
     }
+    this._lastCullFingerprint = fingerprint
+
+    opaqueBuf?.updateDrawSpans(visible, 'opaque')
+    blendBuf?.updateDrawSpans(visible, 'sortedBlend')
+
+    if (gb) {
+      const spans = buildVisibleCubeSpans(visibleSlots, gb.getHighWatermark())
+      gb.setVisibleSpans(spans)
+    }
+
+    this.updatePooledLegacyCullState(cameraWorldX, cameraWorldY, cameraWorldZ)
   }
 
   markCullDirty (): void {
@@ -609,13 +670,16 @@ export class ChunkMeshManager {
       const wy = section.worldY
       const wz = section.worldZ
       if (wx !== undefined && wy !== undefined && wz !== undefined) {
-        this.getGlobalLegacyBuffer().addSection(
+        const added = this.getGlobalLegacyBuffer().addSection(
           sectionKey,
           { positions, colors, skyLights, blockLights, uvs, indices },
           wx,
           wy,
           wz,
         )
+        if (added) {
+          this.registerLegacyCullSection(sectionKey, wx, wy, wz)
+        }
       }
       delete section.deferredLegacyOpaque
     }
@@ -626,13 +690,16 @@ export class ChunkMeshManager {
       const wy = section.worldY
       const wz = section.worldZ
       if (wx !== undefined && wy !== undefined && wz !== undefined) {
-        this.getGlobalLegacyBlendBuffer().addSection(
+        const added = this.getGlobalLegacyBlendBuffer().addSection(
           sectionKey,
           { positions, colors, skyLights, blockLights, uvs, indices },
           wx,
           wy,
           wz,
         )
+        if (added) {
+          this.registerLegacyCullSection(sectionKey, wx, wy, wz)
+        }
       }
       delete section.deferredLegacyBlend
       section.hasBlendMesh = false
@@ -660,15 +727,13 @@ export class ChunkMeshManager {
     const far = raycaster.far
     const halfExtent = LEGACY_SECTION_HALF_EXTENT + 0.01
     const candidates: string[] = []
-    for (const [key, section] of Object.entries(this.sectionObjects)) {
-      if (section.worldX === undefined) continue
+    for (const [key] of this.legacyCullSections) {
+      const section = this.sectionObjects[key]
+      if (!section || section.worldX === undefined) continue
       const dx = section.worldX - origin.x
       const dy = (section.worldY ?? 0) - origin.y
       const dz = (section.worldZ ?? 0) - origin.z
       if (dx * dx + dy * dy + dz * dz > maxDistSq) continue
-      const inOpaque = this.globalLegacyBuffer?.hasSection(key) ?? false
-      const inBlend = this.globalLegacyBlendBuffer?.hasSection(key) ?? false
-      if (!inOpaque && !inBlend) continue
       if (!sectionAabbIntersectsRay(
         section.worldX,
         section.worldY ?? 0,
@@ -912,7 +977,9 @@ export class ChunkMeshManager {
           geometryData.sy,
           geometryData.sz,
         )
-        if (!added) {
+        if (added) {
+          this.registerLegacyCullSection(sectionKey, geometryData.sx, geometryData.sy, geometryData.sz)
+        } else {
           const poolEntry = this.acquirePooledSectionMesh(sectionKey)
           if (!poolEntry) return null
           legacyMesh = this.uploadLegacyPooledMesh(poolEntry, geometryData, geometryData.sx, geometryData.sy, geometryData.sz)
@@ -960,7 +1027,9 @@ export class ChunkMeshManager {
           geometryData.sy,
           geometryData.sz,
         )
-        if (!added) {
+        if (added) {
+          this.registerLegacyCullSection(sectionKey, geometryData.sx, geometryData.sy, geometryData.sz)
+        } else {
           console.warn(`ChunkMeshManager: blend invariant violation for section ${sectionKey}, using pooled mesh fallback`)
           const poolEntry = this.acquirePooledSectionMesh(sectionKey)
           if (!poolEntry) return null
@@ -1197,6 +1266,7 @@ export class ChunkMeshManager {
       sectionObject.visible = true
     }
     delete this.waitingChunksToDisplay[chunkKey]
+    this.markCullDirty()
   }
 
   // Re-check every parked entry; each has its own grace window via `ageMs`.
@@ -1359,6 +1429,7 @@ export class ChunkMeshManager {
       this.globalBlockBuffer?.removeSection(sectionKey)
       this.globalLegacyBuffer?.removeSection(sectionKey)
       this.globalLegacyBlendBuffer?.removeSection(sectionKey)
+      this.maybeUnregisterLegacyCullSection(sectionKey)
       this.unregisterShaderSectionRaycastBox(sectionKey)
       this.markCullDirty()
       delete sectionObject.deferredLegacyOpaque

package/src/three/globalBlockBuffer.ts

@@ -69,6 +69,7 @@ export class GlobalBlockBuffer {
   private tierCAttrs: TierCAttrState | null = null
   private tierCGl: WebGL2RenderingContext | null = null
   private debugOverlay = false
+  private layoutVersion = 0
 
   constructor (
     material: THREE.ShaderMaterial,
@@ -225,6 +226,11 @@ export class GlobalBlockBuffer {
     this.sectionSlots.set(sectionKey, slot)
     this.markDirty(slot.start, slot.start + faceCount - 1)
     this.mesh.geometry.instanceCount = this.highWatermark
+    this.layoutVersion++
+  }
+
+  getLayoutVersion (): number {
+    return this.layoutVersion
   }
 
   hasSection (sectionKey: string): boolean {
@@ -288,6 +294,7 @@ export class GlobalBlockBuffer {
     this.insertFreeSlot(slot)
     this.shrinkHighWatermark()
     this.mesh.geometry.instanceCount = this.highWatermark
+    this.layoutVersion++
   }
 
   /** One interior-hole move per frame when fragmentation exceeds threshold; deferred shrink. */
@@ -318,6 +325,7 @@ export class GlobalBlockBuffer {
     this.sectionSlots.set(section.key, { start: newStart, count: section.count })
     this.markDirty(newStart, newStart + section.count - 1)
     this.pendingMove = { key: section.key, oldStart, newStart, count: section.count }
+    this.layoutVersion++
   }
 
   uploadDirtyRange (): void {

package/src/three/globalLegacyBuffer.ts

@@ -1,5 +1,14 @@
 //@ts-nocheck
 import * as THREE from 'three'
+import {
+  createLegacyMultiDrawScratch,
+  detectLegacyMultiDrawCaps,
+  drawLegacySpans,
+  logLegacyMultiDrawTierOnce,
+  type LegacyDrawSpan,
+  type LegacyMultiDrawCaps,
+  type LegacyMultiDrawScratch,
+} from './legacyMultiDraw'
 import { computeCameraRelativeUniforms, type RenderOrigin } from './shaders/legacyBlockShader'
 
 const VERTS_PER_QUAD = 4
@@ -11,6 +20,9 @@ const FLOATS_PER_LIGHT_VERT = 1
 const DEFAULT_INITIAL_CAPACITY_QUADS = 128_000
 const DEFAULT_GROWTH_INCREMENT_QUADS = 128_000
 const MAX_UPLOAD_QUADS_PER_FRAME = 5_000
+const FRAGMENTATION_THRESHOLD = 0.25
+
+type PendingMove = { key: string, oldStart: number, newStart: number, count: number }
 
 /** CPU bytes per allocated quad slot (all legacy vertex/index attrs). */
 export const LEGACY_BYTES_PER_QUAD =
@@ -44,6 +56,8 @@ export type LegacySectionGeometryData = LegacySectionGeometry & {
   sz: number
 }
 
+export type { LegacyDrawSpan } from './legacyMultiDraw'
+
 /**
  * Single GPU mesh for legacy quads (opaque+cutout or transparent blend).
  * Camera-relative via per-vertex a_origin (relative to render origin) + u_originDelta uniforms.
@@ -67,6 +81,12 @@ export class GlobalLegacyBuffer {
   private pendingRanges: Array<{ start: number, end: number }> = []
   private readonly _spanScratch: Array<{ start: number, count: number }> = []
   private renderOrigin: RenderOrigin = { x: 0, y: 0, z: 0 }
+  private layoutVersion = 0
+  private pendingMove: PendingMove | null = null
+  private visibleIndexSpans: LegacyDrawSpan[] = []
+  private readonly _drawScratch: LegacyMultiDrawScratch = createLegacyMultiDrawScratch()
+  private multiDrawCaps: LegacyMultiDrawCaps | null = null
+  private debugOverlay = false
 
   constructor (
     material: THREE.ShaderMaterial,
@@ -114,6 +134,38 @@ export class GlobalLegacyBuffer {
     this.mesh.position.set(0, 0, 0)
     scene.add(this.mesh)
     this.syncDefaultDrawGroups()
+
+    this.mesh.onAfterRender = (renderer, _scene, _camera, _geometry, material) => {
+      if (this.visibleIndexSpans.length === 0) return
+      const gl = renderer.getContext() as WebGL2RenderingContext
+      if (!this.multiDrawCaps) {
+        this.multiDrawCaps = detectLegacyMultiDrawCaps(gl)
+        logLegacyMultiDrawTierOnce(this.multiDrawCaps.tier, this.debugOverlay)
+      }
+      drawLegacySpans(gl, this.multiDrawCaps, this.visibleIndexSpans, this._drawScratch)
+    }
+  }
+
+  setDebugOverlay (enabled: boolean): void {
+    this.debugOverlay = enabled
+  }
+
+  /**
+   * Suppress three's full-buffer indexed draw; onAfterRender issues visible spans only.
+   * setDrawRange(0,0) skips bindingStates.setup — use a minimal non-zero range so
+   * program/VAO/ELEMENT_ARRAY_BUFFER stay bound while three draws ~nothing.
+   * Draws one triangle from index 0 (usually harmless; if quad 0 is culled, one stray tri).
+   */
+  suppressThreeDraw (): void {
+    this.mesh.geometry.setDrawRange(0, 3)
+  }
+
+  setVisibleIndexSpans (spans: LegacyDrawSpan[]): void {
+    this.visibleIndexSpans = spans
+  }
+
+  getVisibleIndexSpans (): readonly LegacyDrawSpan[] {
+    return this.visibleIndexSpans
   }
 
   private syncDefaultDrawGroups (): void {
@@ -171,14 +223,14 @@ export class GlobalLegacyBuffer {
     this.uvs.set(geo.uvs, dstUvBase)
 
     const originOff = dstFloatBase
-    const rx = this.renderOrigin.x
-    const ry = this.renderOrigin.y
-    const rz = this.renderOrigin.z
+    const ox = sx - this.renderOrigin.x
+    const oy = sy - this.renderOrigin.y
+    const oz = sz - this.renderOrigin.z
     for (let v = 0; v < vertCount; v++) {
       const o = originOff + v * FLOATS_PER_VERT
-      this.aOrigin[o] = sx - rx
-      this.aOrigin[o + 1] = sy - ry
-      this.aOrigin[o + 2] = sz - rz
+      this.aOrigin[o] = ox
+      this.aOrigin[o + 1] = oy
+      this.aOrigin[o + 2] = oz
     }
 
     const dstIndexBase = slot.start * INDICES_PER_QUAD
@@ -190,15 +242,60 @@ export class GlobalLegacyBuffer {
     this.sectionSlots.set(sectionKey, slot)
     this.markDirty(slot.start, slot.start + quadCount - 1)
     this.syncDefaultDrawGroups()
+    this.layoutVersion++
     return true
   }
 
+  getLayoutVersion (): number {
+    return this.layoutVersion
+  }
+
+  getSectionDrawStart (sectionKey: string): number | undefined {
+    const slot = this.sectionSlots.get(sectionKey)
+    if (!slot) return undefined
+    if (this.pendingMove?.key === sectionKey) return this.pendingMove.oldStart
+    return slot.start
+  }
+
+  getPendingMove (): PendingMove | null {
+    return this.pendingMove
+  }
+
+  /** One interior-hole move per frame when fragmentation exceeds threshold; deferred shrink. */
+  compactStep (): void {
+    if (this.pendingMove) {
+      const { newStart, count } = this.pendingMove
+      if (this.rangeFullyUploaded(newStart, newStart + count - 1)) {
+        this.finalizePendingMove()
+      }
+      return
+    }
+
+    if (this.highWatermark === 0) return
+    const interiorFree = this.interiorFreeQuads()
+    if (interiorFree / this.highWatermark <= FRAGMENTATION_THRESHOLD) return
+
+    const section = this.findMovableSection(MAX_UPLOAD_QUADS_PER_FRAME)
+    if (!section) return
+
+    const hole = this.findLowestInteriorHole(section.start, section.count)
+    if (!hole) return
+
+    const reserved = this.reserveFreeSlotAt(hole.index, section.count)
+    const oldStart = section.start
+    const newStart = reserved.start
+
+    this.copySectionRange(oldStart, newStart, section.count)
+    this.sectionSlots.set(section.key, { start: newStart, count: section.count })
+    this.markDirty(newStart, newStart + section.count - 1)
+    this.pendingMove = { key: section.key, oldStart, newStart, count: section.count }
+    this.layoutVersion++
+  }
+
   updateDrawSpans (visible: VisibleSectionSpan[], mode: 'opaque' | 'sortedBlend'): void {
-    const geometry = this.mesh.geometry
-    geometry.clearGroups()
+    this.visibleIndexSpans = []
 
     if (this.highWatermark === 0) {
-      geometry.setDrawRange(0, 0)
       return
     }
 
@@ -207,21 +304,30 @@ export class GlobalLegacyBuffer {
     let visibleQuadCount = 0
 
     for (const entry of visible) {
+      const drawStart = this.getSectionDrawStart(entry.key)
       const slot = this.sectionSlots.get(entry.key)
-      if (!slot) continue
-      spans.push({ start: slot.start, count: slot.count })
+      if (drawStart === undefined || !slot) continue
+      spans.push({ start: drawStart, count: slot.count })
       visibleQuadCount += slot.count
     }
 
     if (spans.length === 0) {
-      geometry.setDrawRange(0, 0)
       return
     }
 
+    const pushIndexSpan = (quadStart: number, quadCount: number): void => {
+      this.visibleIndexSpans.push({
+        indexStart: quadStart * INDICES_PER_QUAD,
+        indexCount: quadCount * INDICES_PER_QUAD,
+      })
+    }
+
     if (mode === 'opaque') {
       if (visibleQuadCount >= this.highWatermark * FULL_DRAW_VISIBLE_FRACTION) {
-        geometry.addGroup(0, this.highWatermark * INDICES_PER_QUAD, 0)
-        geometry.setDrawRange(0, this.highWatermark * INDICES_PER_QUAD)
+        this.visibleIndexSpans.push({
+          indexStart: 0,
+          indexCount: this.highWatermark * INDICES_PER_QUAD,
+        })
         return
       }
 
@@ -230,18 +336,17 @@ export class GlobalLegacyBuffer {
       this.capOpaqueSpans(spans)
 
       for (const span of spans) {
-        geometry.addGroup(span.start * INDICES_PER_QUAD, span.count * INDICES_PER_QUAD, 0)
+        pushIndexSpan(span.start, span.count)
       }
     } else {
       visible.sort((a, b) => b.distSq - a.distSq)
       for (const entry of visible) {
+        const drawStart = this.getSectionDrawStart(entry.key)
         const slot = this.sectionSlots.get(entry.key)
-        if (!slot) continue
-        geometry.addGroup(slot.start * INDICES_PER_QUAD, slot.count * INDICES_PER_QUAD, 0)
+        if (drawStart === undefined || !slot) continue
+        pushIndexSpan(drawStart, slot.count)
       }
     }
-
-    geometry.setDrawRange(0, this.highWatermark * INDICES_PER_QUAD)
   }
 
   private mergeOpaqueSpans (spans: Array<{ start: number, count: number }>): void {
@@ -328,6 +433,18 @@ export class GlobalLegacyBuffer {
     const slot = this.sectionSlots.get(sectionKey)
     if (!slot) return
 
+    if (this.pendingMove?.key === sectionKey) {
+      const { oldStart, count } = this.pendingMove
+      const oldIndexBase = oldStart * INDICES_PER_QUAD
+      const oldIndexLen = count * INDICES_PER_QUAD
+      for (let i = 0; i < oldIndexLen; i++) {
+        this.indices[oldIndexBase + i] = 0
+      }
+      this.markDirty(oldStart, oldStart + count - 1)
+      this.insertFreeSlot({ start: oldStart, count })
+      this.pendingMove = null
+    }
+
     const dstIndexBase = slot.start * INDICES_PER_QUAD
     const indexLen = slot.count * INDICES_PER_QUAD
     for (let i = 0; i < indexLen; i++) {
@@ -339,6 +456,7 @@ export class GlobalLegacyBuffer {
     this.insertFreeSlot(slot)
     this.shrinkHighWatermark()
     this.syncDefaultDrawGroups()
+    this.layoutVersion++
   }
 
   hasPendingUploads (): boolean {
@@ -505,6 +623,8 @@ export class GlobalLegacyBuffer {
     this.freeList.length = 0
     this.highWatermark = 0
     this.pendingRanges.length = 0
+    this.pendingMove = null
+    this.visibleIndexSpans = []
     this.syncDefaultDrawGroups()
   }
 
@@ -585,7 +705,125 @@ export class GlobalLegacyBuffer {
     }
   }
 
+  private interiorFreeQuads (): number {
+    let total = 0
+    for (const slot of this.freeList) {
+      if (slot.start < this.highWatermark) total += slot.count
+    }
+    return total
+  }
+
+  private findMovableSection (maxCount: number): { key: string, start: number, count: number } | undefined {
+    const sections: Array<{ key: string, start: number, count: number }> = []
+    for (const [key, slot] of this.sectionSlots) {
+      sections.push({ key, start: slot.start, count: slot.count })
+    }
+    if (sections.length === 0) return undefined
+
+    sections.sort((a, b) => {
+      if (b.start !== a.start) return b.start - a.start
+      return (b.start + b.count) - (a.start + a.count)
+    })
+
+    const tailmost = sections[0]!
+    if (tailmost.count <= maxCount && this.findLowestInteriorHole(tailmost.start, tailmost.count)) {
+      return tailmost
+    }
+
+    const candidates = sections
+      .filter(s => s.count <= maxCount)
+      .sort((a, b) => b.count - a.count)
+
+    for (const s of candidates) {
+      if (this.findLowestInteriorHole(s.start, s.count)) return s
+    }
+    return undefined
+  }
+
+  private findLowestInteriorHole (
+    sectionStart: number,
+    count: number,
+  ): { start: number, count: number, index: number } | undefined {
+    for (let i = 0; i < this.freeList.length; i++) {
+      const slot = this.freeList[i]!
+      if (slot.start < sectionStart && slot.count >= count) {
+        return { start: slot.start, count: slot.count, index: i }
+      }
+    }
+    return undefined
+  }
+
+  private reserveFreeSlotAt (index: number, count: number): { start: number, count: number } {
+    const slot = this.freeList[index]!
+    this.freeList.splice(index, 1)
+    if (slot.count === count) return { start: slot.start, count }
+    const used = { start: slot.start, count }
+    this.insertFreeSlot({ start: slot.start + count, count: slot.count - count })
+    return used
+  }
+
+  private copySectionRange (oldStart: number, newStart: number, quadCount: number): void {
+    const oldVertBase = oldStart * VERTS_PER_QUAD
+    const newVertBase = newStart * VERTS_PER_QUAD
+    const vertCount = quadCount * VERTS_PER_QUAD
+    const vertDelta = newVertBase - oldVertBase
+
+    const oldFloatBase = oldVertBase * FLOATS_PER_VERT
+    const newFloatBase = newVertBase * FLOATS_PER_VERT
+    const floatLen = vertCount * FLOATS_PER_VERT
+    this.positions.copyWithin(newFloatBase, oldFloatBase, oldFloatBase + floatLen)
+    this.colors.copyWithin(newFloatBase, oldFloatBase, oldFloatBase + floatLen)
+    this.aOrigin.copyWithin(newFloatBase, oldFloatBase, oldFloatBase + floatLen)
+
+    const oldLightBase = oldVertBase * FLOATS_PER_LIGHT_VERT
+    const newLightBase = newVertBase * FLOATS_PER_LIGHT_VERT
+    const lightLen = vertCount * FLOATS_PER_LIGHT_VERT
+    this.skyLights.copyWithin(newLightBase, oldLightBase, oldLightBase + lightLen)
+    this.blockLights.copyWithin(newLightBase, oldLightBase, oldLightBase + lightLen)
+
+    const oldUvBase = oldVertBase * FLOATS_PER_UV_VERT
+    const newUvBase = newVertBase * FLOATS_PER_UV_VERT
+    const uvLen = vertCount * FLOATS_PER_UV_VERT
+    this.uvs.copyWithin(newUvBase, oldUvBase, oldUvBase + uvLen)
+
+    const oldIndexBase = oldStart * INDICES_PER_QUAD
+    const newIndexBase = newStart * INDICES_PER_QUAD
+    const indexLen = quadCount * INDICES_PER_QUAD
+    for (let i = 0; i < indexLen; i++) {
+      this.indices[newIndexBase + i] = this.indices[oldIndexBase + i]! + vertDelta
+    }
+  }
+
+  private rangeFullyUploaded (start: number, end: number): boolean {
+    for (const r of this.pendingRanges) {
+      if (r.start <= end && r.end >= start) return false
+    }
+    return true
+  }
+
+  private finalizePendingMove (): void {
+    const move = this.pendingMove
+    if (!move) return
+
+    const { oldStart, count } = move
+    const oldIndexBase = oldStart * INDICES_PER_QUAD
+    const oldIndexLen = count * INDICES_PER_QUAD
+    for (let i = 0; i < oldIndexLen; i++) {
+      this.indices[oldIndexBase + i] = 0
+    }
+    this.insertFreeSlot({ start: oldStart, count })
+    this.shrinkHighWatermark()
+    if (oldStart < this.highWatermark) {
+      this.markDirty(oldStart, oldStart + count - 1)
+    }
+    this.syncDefaultDrawGroups()
+    this.pendingMove = null
+    this.layoutVersion++
+  }
+
   private growCapacity (minQuads: number): void {
+    if (this.pendingMove) this.finalizePendingMove()
+
     let newCap = this.capacityQuads
     while (newCap < minQuads) newCap += this.growthIncrementQuads