minecraft-renderer 0.1.38 → 0.1.40

package/src/mesher/test/splitColumnWasmOutput.test.ts

@@ -0,0 +1,163 @@
+//@ts-nocheck
+import { test, expect } from 'vitest'
+import {
+  splitColumnWasmOutputToSections,
+  renderWasmOutputToGeometry,
+  WasmGeometryOutput,
+} from '../../wasm-lib/render-from-wasm'
+
+const VERSION = '1.16.5'
+const STONE = 1 // 1.16.5 stone state id
+
+// Face mask layout (matches FACE_DIRS in wasm-mesher / render-from-wasm.ts).
+const FACE_UP = 1 << 0
+const FACE_DOWN = 1 << 1
+const FACE_NORTH = 1 << 2
+const FACE_SOUTH = 1 << 3
+const FACE_WEST = 1 << 4
+const FACE_EAST = 1 << 5
+const SIDE_FACES = FACE_NORTH | FACE_SOUTH | FACE_WEST | FACE_EAST
+
+// Build a synthetic full-column WASM mesher output by hand. This avoids
+// pulling in `wasm-pack`/the Rust crate from this unit test — the helper
+// under test is pure JS, so an in-memory fixture is sufficient.
+//
+// Scenario: two adjacent stone blocks at world Y=15 and Y=16. Because
+// they are stacked and opaque, Rust mesher would emit:
+//   - (x,15,z): bottom face only, top face is suppressed by Y=16
+//   - (x,16,z): top face only,    bottom face is suppressed by Y=15
+// We hand-craft that output here.
+function makeSeamFixture(): WasmGeometryOutput {
+  const blocks: WasmGeometryOutput['blocks'] = []
+  for (let z = 0; z < 16; z++) {
+    for (let x = 0; x < 16; x++) {
+      blocks.push({
+        position: [x, 15, z],
+        block_state_id: STONE,
+        // Y=15 is occluded above by the Y=16 stone — the seam neighbor
+        // info is baked in here at the per-block level.
+        visible_faces: FACE_DOWN | SIDE_FACES,
+        ao_data: [],
+        light_data: [],
+      })
+      blocks.push({
+        position: [x, 16, z],
+        block_state_id: STONE,
+        // Y=16 is occluded below by the Y=15 stone (the seam from the
+        // other side).
+        visible_faces: FACE_UP | SIDE_FACES,
+        ao_data: [],
+        light_data: [],
+      })
+    }
+  }
+  // Add an isolated block in a third section, so we cover a section
+  // that has no seam interaction.
+  blocks.push({
+    position: [0, 64, 0],
+    block_state_id: STONE,
+    visible_faces: FACE_UP | FACE_DOWN | SIDE_FACES,
+    ao_data: [],
+    light_data: [],
+  })
+  return {
+    blocks,
+    block_count: blocks.length,
+    block_iterations: 0,
+  }
+}
+
+test('splitColumnWasmOutputToSections: per-section split is equivalent to manual filter+render at the y=15/16 seam', () => {
+  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
+  ]
+
+  const split = splitColumnWasmOutputToSections(fullColumn, requested, { version: VERSION })
+
+  expect(split.size).toBe(4)
+  for (const r of requested) {
+    expect(split.has(`${r.x},${r.y},${r.z}`)).toBe(true)
+  }
+
+  // Reference: do the same split manually (exactly what the helper is
+  // supposed to do internally) and confirm the rendered geometry
+  // matches byte-for-byte.
+  for (const r of requested) {
+    const yLo = r.y
+    const yHi = r.y + 16
+    const sectionBlocks = fullColumn.blocks.filter(b => b.position[1] >= yLo && b.position[1] < yHi)
+    const reference = renderWasmOutputToGeometry(
+      {
+        blocks: sectionBlocks,
+        block_count: sectionBlocks.length,
+        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
+    )
+    const got = split.get(`${r.x},${r.y},${r.z}`)!.exported
+    expect(got.key).toBe(reference.key)
+    expect(got.position).toEqual(reference.position)
+    expect(got.geometry.positions).toEqual(reference.geometry.positions)
+    expect(got.geometry.normals).toEqual(reference.geometry.normals)
+    expect(got.geometry.colors).toEqual(reference.geometry.colors)
+    expect(got.geometry.uvs).toEqual(reference.geometry.uvs)
+    expect(got.geometry.indices).toEqual(reference.geometry.indices)
+  }
+
+  // Empty section returns a real (non-undefined) entry with empty geometry
+  // buffers and zero blocksCount.
+  const emptyEntry = split.get('0,32,0')!
+  expect(emptyEntry).toBeDefined()
+  expect(emptyEntry.exported.geometry.positions).toEqual([])
+  expect(emptyEntry.exported.geometry.indices).toEqual([])
+  expect(emptyEntry.blocksCount).toBe(0)
+
+  // Seam preservation: the Y=15/16 sections produce non-empty geometry,
+  // and crucially the y=15 section does NOT contain the (Y=15 top-face)
+  // that would have been emitted if the helper failed to honor the
+  // already-baked-in `visible_faces` mask. The cleanest structural
+  // assertion is that the seam-sections each contain only the expected
+  // number of unique vertical faces. With FACE_UP/FACE_DOWN suppressed
+  // at the seam, each block in those sections contributes 1 horizontal
+  // face + 4 side faces = 5 quads; both sections also have identical
+  // block counts (256 blocks), so their vertex/index counts must match.
+  const lower = split.get('0,0,0')!.exported
+  const upper = split.get('0,16,0')!.exported
+  expect(lower.geometry.positions.length).toBeGreaterThan(0)
+  expect(upper.geometry.positions.length).toBeGreaterThan(0)
+  expect(lower.geometry.positions.length).toBe(upper.geometry.positions.length)
+  expect(lower.geometry.indices.length).toBe(upper.geometry.indices.length)
+  // blocksCount must reflect the per-section bucket size, not the column
+  // total. Both seam sections contain 256 blocks each.
+  expect(split.get('0,0,0')!.blocksCount).toBe(256)
+  expect(split.get('0,16,0')!.blocksCount).toBe(256)
+})
+
+test('splitColumnWasmOutputToSections: empty requested-keys list returns empty map', () => {
+  const fullColumn = makeSeamFixture()
+  const out = splitColumnWasmOutputToSections(fullColumn, [], { version: VERSION })
+  expect(out.size).toBe(0)
+})
+
+test('splitColumnWasmOutputToSections: blocks outside requested sections are dropped', () => {
+  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 }
+  )
+  const empty = out.get('0,32,0')!
+  expect(empty.exported.geometry.positions).toEqual([])
+  expect(empty.exported.geometry.indices).toEqual([])
+  expect(empty.blocksCount).toBe(0)
+})

package/src/three/chunkMeshManager.ts

@@ -57,6 +57,20 @@ export class ChunkMeshManager {
    * (`x,z`); flushed by `WorldRendererThree.finishChunk(chunkKey)`.
    */
   readonly waitingChunksToDisplay: Record<string, string[]> = {}
+  /**
+   * Chunks whose mesh batch is fully ready but kept invisible by the
+   * WASM near-first reveal gate because at least one nearer column is
+   * not yet finished. Value = enqueue timestamp (ms), used by the
+   * expected-delivery grace window in `isBlockedByNearer`.
+   */
+  readonly pendingNearReveal = new Map<string, number>()
+  private readonly nearRevealTimers = new Map<string, ReturnType<typeof setTimeout>>()
+  private readonly nearRevealGraceTimers = new Map<string, ReturnType<typeof setTimeout>>()
+  // Force-flush pending reveal after this many ms (last-resort safety).
+  private static readonly NEAR_REVEAL_TIMEOUT_MS = 5000
+  // Soft window during which the gate also waits for *expected* nearer
+  // columns that have not arrived yet (covers far-worker-beats-near-worker).
+  private static readonly EXPECTED_NEAR_GRACE_MS = 1500
   private poolSize!: number
   private maxPoolSize!: number
   private minPoolSize!: number
@@ -270,11 +284,14 @@ export class ChunkMeshManager {
     // chunk appear as a single 16xHx16 tile instead of streaming per-section.
     // Updates to chunks that are already finished bypass batching to avoid
     // flickering on block changes / lighting updates.
+    // For the WASM column path we force batching ON regardless of the user
+    // setting so the near-first reveal gate has sections to hold.
     const chunkCoords = sectionKey.split(',')
     const chunkKey = `${chunkCoords[0]},${chunkCoords[2]}`
     const renderByChunks = !!this.worldRenderer.displayOptions
       ?.inWorldRenderingConfig?._renderByChunks
-    if (renderByChunks && !this.worldRenderer.finishedChunks[chunkKey]) {
+    const forceBatchForWasm = !!this.worldRenderer.worldRendererConfig?.wasmMesher
+    if ((renderByChunks || forceBatchForWasm) && !this.worldRenderer.finishedChunks[chunkKey]) {
       sectionObject.visible = false
       sectionObject._waitingForChunkDisplay = true
       const list = this.waitingChunksToDisplay[chunkKey] ?? (this.waitingChunksToDisplay[chunkKey] = [])
@@ -287,9 +304,34 @@ export class ChunkMeshManager {
   /**
    * Reveal all sections of a chunk that were held invisible by the
    * "Batch Chunks Display" option. Called from `WorldRendererThree.finishChunk`.
+   *
+   * For the WASM path: if any nearer column is not yet finished, the
+   * reveal is deferred (parked in `pendingNearReveal`) and re-checked on
+   * the next chunkFinished / player-move / grace-expiry.
    */
   finishChunkDisplay (chunkKey: string): void {
     const sectionKeys = this.waitingChunksToDisplay[chunkKey]
+    if (!sectionKeys) {
+      // No held sections (empty column / non-batched path) — but the
+      // chunk just transitioned to finished, so re-check pending farther.
+      this.tryRevealPending()
+      return
+    }
+    if (this.isWasmGateActive() && this.isBlockedByNearer(chunkKey, 0)) {
+      this.pendingNearReveal.set(chunkKey, Date.now())
+      this.armNearRevealTimer(chunkKey)
+      this.armExpectedGraceTimer(chunkKey)
+      return
+    }
+    this.flushChunkDisplay(chunkKey)
+    this.tryRevealPending()
+  }
+
+  private flushChunkDisplay (chunkKey: string): void {
+    const sectionKeys = this.waitingChunksToDisplay[chunkKey]
+    this.pendingNearReveal.delete(chunkKey)
+    this.clearNearRevealTimer(chunkKey)
+    this.clearExpectedGraceTimer(chunkKey)
     if (!sectionKeys) return
     for (const sectionKey of sectionKeys) {
       const sectionObject = this.sectionObjects[sectionKey]
@@ -300,6 +342,134 @@ export class ChunkMeshManager {
     delete this.waitingChunksToDisplay[chunkKey]
   }
 
+  // Re-check every parked entry; each has its own grace window via `ageMs`.
+  // Single pass is enough — pending entries are already finished, so flushing
+  // one cannot un-block another via this code path (cascading happens via
+  // chunkFinished events and per-pending grace timers).
+  tryRevealPending (): void {
+    if (this.pendingNearReveal.size === 0) return
+    const now = Date.now()
+    for (const [chunkKey, enqueuedAt] of [...this.pendingNearReveal]) {
+      if (!this.isBlockedByNearer(chunkKey, now - enqueuedAt)) {
+        this.flushChunkDisplay(chunkKey)
+      }
+    }
+  }
+
+  // Drop gate state for an unloaded column and re-evaluate any farther
+  // chunks that may have been blocked by it.
+  onChunkRemovedFromGate (chunkKey: string): void {
+    this.pendingNearReveal.delete(chunkKey)
+    this.clearNearRevealTimer(chunkKey)
+    this.clearExpectedGraceTimer(chunkKey)
+    delete this.waitingChunksToDisplay[chunkKey]
+    this.tryRevealPending()
+  }
+
+  private isWasmGateActive (): boolean {
+    return !!this.worldRenderer.worldRendererConfig?.wasmMesher
+  }
+
+  /**
+   * True if some chunk-grid position strictly closer to the viewer than
+   * `chunkKey` is not yet `finishedChunks=true`.
+   *
+   * Two regimes by `ageMs` (time spent in `pendingNearReveal`):
+   * - Within `EXPECTED_NEAR_GRACE_MS`: walks every expected position in
+   *   the view-distance circle; missing-and-not-finished counts as a
+   *   blocker (catches "far worker beats near worker").
+   * - After grace: only actually-loaded-but-not-finished columns block,
+   *   so a never-arriving column does not freeze the view.
+   */
+  private isBlockedByNearer (chunkKey: string, ageMs: number): boolean {
+    const viewer = this.worldRenderer.viewerChunkPosition
+    if (!viewer) return false
+    const ownParts = chunkKey.split(',')
+    if (ownParts.length !== 2) return false
+    const ownX = Number(ownParts[0])
+    const ownZ = Number(ownParts[1])
+    const playerCx = Math.floor(viewer.x / 16)
+    const playerCz = Math.floor(viewer.z / 16)
+    const myDx = (ownX >> 4) - playerCx
+    const myDz = (ownZ >> 4) - playerCz
+    const myDist = myDx * myDx + myDz * myDz
+    if (myDist === 0) return false
+    const finishedChunks = this.worldRenderer.finishedChunks
+    const loadedChunks = this.worldRenderer.loadedChunks
+    const viewDist = this.worldRenderer.viewDistance
+    const inGrace = ageMs < ChunkMeshManager.EXPECTED_NEAR_GRACE_MS && viewDist > 0
+
+    if (inGrace) {
+      const viewDistSq = viewDist * viewDist
+      const limit = Math.min(viewDist, Math.ceil(Math.sqrt(Math.max(0, myDist - 1))))
+      for (let dCx = -limit; dCx <= limit; dCx++) {
+        for (let dCz = -limit; dCz <= limit; dCz++) {
+          const oDistSq = dCx * dCx + dCz * dCz
+          if (oDistSq >= myDist || oDistSq > viewDistSq) continue
+          const ox = (playerCx + dCx) << 4
+          const oz = (playerCz + dCz) << 4
+          const otherKey = `${ox},${oz}`
+          if (otherKey === chunkKey) continue
+          if (!finishedChunks[otherKey]) return true
+        }
+      }
+      return false
+    }
+
+    for (const otherKey in loadedChunks) {
+      if (otherKey === chunkKey || finishedChunks[otherKey]) continue
+      const parts = otherKey.split(',')
+      if (parts.length !== 2) continue
+      const odx = (Number(parts[0]) >> 4) - playerCx
+      const odz = (Number(parts[1]) >> 4) - playerCz
+      if (odx * odx + odz * odz < myDist) return true
+    }
+    return false
+  }
+
+  private armNearRevealTimer (chunkKey: string): void {
+    if (this.nearRevealTimers.has(chunkKey)) return
+    const timer = setTimeout(() => {
+      this.nearRevealTimers.delete(chunkKey)
+      if (!this.pendingNearReveal.has(chunkKey)) return
+      console.warn(`[chunk-reveal] safety timeout for ${chunkKey} — a nearer pending column never finished, force-revealing`)
+      this.flushChunkDisplay(chunkKey)
+      this.tryRevealPending()
+    }, ChunkMeshManager.NEAR_REVEAL_TIMEOUT_MS)
+    this.nearRevealTimers.set(chunkKey, timer)
+  }
+
+  private clearNearRevealTimer (chunkKey: string): void {
+    const timer = this.nearRevealTimers.get(chunkKey)
+    if (timer) {
+      clearTimeout(timer)
+      this.nearRevealTimers.delete(chunkKey)
+    }
+  }
+
+  /**
+   * Schedule a re-evaluation just after the grace window expires so that
+   * "expected but never arrived" positions stop blocking promptly,
+   * without waiting for the next chunkFinished / player-move event.
+   */
+  private armExpectedGraceTimer (chunkKey: string): void {
+    if (this.nearRevealGraceTimers.has(chunkKey)) return
+    const timer = setTimeout(() => {
+      this.nearRevealGraceTimers.delete(chunkKey)
+      if (!this.pendingNearReveal.has(chunkKey)) return
+      this.tryRevealPending()
+    }, ChunkMeshManager.EXPECTED_NEAR_GRACE_MS + 50)
+    this.nearRevealGraceTimers.set(chunkKey, timer)
+  }
+
+  private clearExpectedGraceTimer (chunkKey: string): void {
+    const timer = this.nearRevealGraceTimers.get(chunkKey)
+    if (timer) {
+      clearTimeout(timer)
+      this.nearRevealGraceTimers.delete(chunkKey)
+    }
+  }
+
   cleanupSection (sectionKey: string) {
     // Remove section object from scene
     const sectionObject = this.sectionObjects[sectionKey]
@@ -597,6 +767,12 @@ export class ChunkMeshManager {
     this.meshPool.length = 0
     this.activeSections.clear()
     this.chunkBoxMaterial.dispose()
+    // Drop any pending near-first reveal state and cancel safety timers.
+    this.pendingNearReveal.clear()
+    for (const timer of this.nearRevealTimers.values()) clearTimeout(timer)
+    this.nearRevealTimers.clear()
+    for (const timer of this.nearRevealGraceTimers.values()) clearTimeout(timer)
+    this.nearRevealGraceTimers.clear()
   }
 
   // Private helper methods

package/src/three/modules/cameraBobbing.ts

@@ -26,8 +26,15 @@ export class CameraBobbingModule implements RendererModuleController {
     if (!this.enabled) return
     const config = this.worldRenderer.displayOptions.inWorldRenderingConfig
     const { perspective } = this.worldRenderer.playerStateReactive
+    // Spectator (gm3) flies through blocks and does not "walk" — view bobbing
+    // there only makes the camera feel jittery/unstable. Keep it gated even
+    // when the user has `viewBobbing` enabled in settings.
+    const shouldBobCamera =
+      config.viewBobbing
+      && perspective === 'first_person'
+      && !this.worldRenderer.playerStateUtils.isSpectator()
 
-    if (config.viewBobbing && perspective === 'first_person') {
+    if (shouldBobCamera) {
       if (this.worldRenderer.playerStateReactive.walkDist !== this.lastBobWalkDist) {
         this.lastBobTickTime = performance.now()
         this.lastBobWalkDist = this.worldRenderer.playerStateReactive.walkDist

package/src/three/worldRendererThree.ts

@@ -1424,6 +1424,13 @@ export class WorldRendererThree extends WorldRendererCommon {
         this.chunkMeshManager.releaseSection(key)
       }
     }
+    // Drop near-first reveal state and re-check any farther chunks
+    // that may have been blocked by this column.
+    this.chunkMeshManager.onChunkRemovedFromGate(`${x},${z}`)
+  }
+
+  protected onViewerChunkPositionChanged(): void {
+    this.chunkMeshManager.tryRevealPending()
   }
 
   setSectionDirty(...args: Parameters<WorldRendererCommon['setSectionDirty']>) {

package/src/wasm-lib/render-from-wasm.ts

@@ -64,6 +64,7 @@ interface CachedBlockModel {
   blockProps: Record<string, any>
   models: any // BlockModelPartsResolved
   isCube: boolean
+  boundingBox: string
   // Precomputed per-model variant
   modelVariants: Array<{
     model: any
@@ -86,10 +87,51 @@ interface WasmBlockFaceData {
   light_data: number[][]
 }
 
-interface WasmGeometryOutput {
+export interface WasmGeometryOutput {
   blocks: WasmBlockFaceData[]
   block_count: number
   block_iterations: number
+  /**
+   * Per-(x,z) max non-invisible block Y for the meshed column, indexed as
+   * `z * 16 + x`. Sentinel value `-32768` = no block in that column.
+   *
+   * Populated by Rust `Mesher::generate_with_world` (see
+   * `wasm-mesher/src/mesher.rs`, field `heightmap`). serde_wasm_bindgen
+   * serializes `Vec<i16>` as a plain JS `number[]`, which is why the type
+   * here is `ArrayLike<number>` rather than `Int16Array` — the runtime
+   * adapter `extractColumnHeightmap` handles both shapes.
+   *
+   * Used at runtime by `mesherWasm.ts` `processColumnTick`: every column
+   * tick the WASM heightmap is extracted via `extractColumnHeightmap` and
+   * posted to the main thread as a `'heightmap'` message. JS
+   * `computeHeightmap` is now only a fallback (length mismatch / missing
+   * field) and a safety-net for empty columns at chunk load. Empty-column
+   * semantics are aligned: both Rust and JS use `-32768` (see
+   * `EMPTY_COLUMN_HEIGHTMAP_SENTINEL`).
+   */
+  heightmap?: ArrayLike<number> | null
+}
+
+/**
+ * Extract a 256-entry Int16Array heightmap from a full-column WASM mesher
+ * result, indexed as `z * 16 + x` (matching the JS `computeHeightmap`
+ * convention). Returns `null` when the WASM output does not carry a
+ * heightmap or carries one of unexpected length — in that case the
+ * caller MUST fall back to JS `computeHeightmap` rather than guess.
+ *
+ * This adapter is the single place that converts Rust's `Vec<i16>` heightmap
+ * shape into a transferable typed array. Tests exercise this same adapter so
+ * future runtime usage and parity assertions cannot drift apart.
+ */
+export function extractColumnHeightmap(
+  wasmOutput: { heightmap?: ArrayLike<number> | null } | null | undefined
+): Int16Array | null {
+  const raw = wasmOutput?.heightmap
+  if (!raw || raw.length !== 256) return null
+  if (raw instanceof Int16Array) return new Int16Array(raw)
+  const out = new Int16Array(256)
+  for (let i = 0; i < 256; i++) out[i] = raw[i]
+  return out
 }
 
 /**
@@ -181,6 +223,7 @@ function getCachedBlockModel(
       models,
       modelVariants,
       isCube,
+      boundingBox: blockObj.boundingBox,
     }
 
     cache.set(cacheKey, cached)
@@ -697,6 +740,11 @@ export function renderWasmOutputToGeometry(
         globalShift = vecsub3(globalShift, matmul3(globalMatrix, globalShift))
       }
 
+      // Mirror JS mesher: doAO = model.ao ?? block.boundingBox !== 'empty'.
+      // When false, faces are emitted full-bright without AO/light sampling and without
+      // triangle-flip reordering (matches JS `light = 1` and standard winding).
+      const doAO = (model as any).ao ?? cachedModel.boundingBox !== 'empty'
+
       for (const element of model.elements ?? []) {
         let localMatrix = null as any
         let localShift = null as any
@@ -723,8 +771,12 @@ export function renderWasmOutputToGeometry(
             Math.round(transformedDir[2]),
           ]
           const dirKey = `${transformedDirI[0]},${transformedDirI[1]},${transformedDirI[2]}`
+          // faceIdx may be undefined for diagonal-rotated faces (e.g. signs at 45/135/225/315 deg).
+          // Such faces are not representable in the 6-axis WASM visible_faces / ao_data / light_data
+          // arrays. We still emit them (mirrors JS mesher behavior); cullface and AO/light data
+          // lookups are skipped, and the model-lighting fallback below derives AO/light by
+          // sampling neighbors via transformedDirI (its rounded form, same as for cardinal axes).
           const faceIdx = dirKeyToIndex[dirKey]
-          if (faceIdx === undefined) continue
 
           const minx = element.from[0]
           const miny = element.from[1]
@@ -733,13 +785,13 @@ export function renderWasmOutputToGeometry(
           const maxy = element.to[1]
           const maxz = element.to[2]
 
-          if (matchingEFace.cullface) {
+          if (matchingEFace.cullface && faceIdx !== undefined) {
             if ((block.visible_faces & (1 << faceIdx)) === 0) {
               continue
             }
           }
 
-          const faceDataIndex = wasmFaceToDataIndex[faceIdx]
+          const faceDataIndex = faceIdx === undefined ? undefined : wasmFaceToDataIndex[faceIdx]
           const aoValuesRaw = faceDataIndex === undefined ? undefined : block.ao_data[faceDataIndex]
           const lightValuesRaw = faceDataIndex === undefined ? undefined : block.light_data[faceDataIndex]
 
@@ -787,8 +839,13 @@ export function renderWasmOutputToGeometry(
 
             let ao = 3
             let cornerLightResult = 15
+            let light: number
 
-            if (useModelLighting) {
+            if (!doAO) {
+              // JS parity: skip AO/light sampling, emit full-bright vertex.
+              computedAoValues[cornerIdx] = 3
+              light = 1
+            } else if (useModelLighting) {
               const cursor = new Vec3(bx, by, bz)
 
               const dx = pos[0] * 2 - 1
@@ -849,9 +906,11 @@ export function renderWasmOutputToGeometry(
               cornerLightResult = baseLight * 15
             }
 
-            const light = (ao + 1) / 4 * (cornerLightResult / 15)
+            if (doAO) {
+              light = (ao + 1) / 4 * (cornerLightResult / 15)
+            }
 
-            colors.push(tint[0] * light, tint[1] * light, tint[2] * light)
+            colors.push(tint[0] * light!, tint[1] * light!, tint[2] * light!)
 
             const baseu = (pos[3] - 0.5) * uvcs - (pos[4] - 0.5) * uvsn + 0.5
             const basev = (pos[3] - 0.5) * uvsn + (pos[4] - 0.5) * uvcs + 0.5
@@ -865,7 +924,7 @@ export function renderWasmOutputToGeometry(
           const aoValues = computedAoValues
 
           let tri1: number[], tri2: number[]
-          if (aoValues[0] + aoValues[3] >= aoValues[1] + aoValues[2]) {
+          if (doAO && aoValues[0] + aoValues[3] >= aoValues[1] + aoValues[2]) {
             tri1 = [baseIndex, baseIndex + 3, baseIndex + 2]
             tri2 = [baseIndex, baseIndex + 1, baseIndex + 3]
           } else {
@@ -915,15 +974,101 @@ export function renderWasmOutputToGeometry(
     },
   }
 
-  console.log(`[WASM] Final geometry summary:`)
-  console.log(`[WASM]   Total vertices: ${positions.length / 3}`)
-  console.log(`[WASM]   Total triangles: ${indices.length / 3}`)
-  console.log(`[WASM]   Positions: [${positions.slice(0, 12).join(',')}...] (first 4 vertices)`)
-  console.log(`[WASM]   Indices: [${indices.slice(0, 12).join(',')}...] (first 2 faces)`)
+  log(`[WASM] Final geometry summary:`)
+  log(`[WASM]   Total vertices: ${positions.length / 3}`)
+  log(`[WASM]   Total triangles: ${indices.length / 3}`)
+  log(`[WASM]   Positions: [${positions.slice(0, 12).join(',')}...] (first 4 vertices)`)
+  log(`[WASM]   Indices: [${indices.slice(0, 12).join(',')}...] (first 2 faces)`)
 
   return result
 }
 
+/**
+ * Split a single full-column WASM mesher result into per-section
+ * `ExportedSection` outputs by filtering `wasmResult.blocks` per requested
+ * section's Y range and invoking `renderWasmOutputToGeometry` once per
+ * section.
+ *
+ * Why split at the block level (and not after geometry generation):
+ *   - Liquids (water/lava), signs/heads/banners metadata, AO/light arrays
+ *     and index numbering are computed inside `renderWasmOutputToGeometry`.
+ *     Splitting *finished* vertex/index buffers would silently break those.
+ *   - Filtering blocks by Y range and re-running the post-processor per
+ *     section keeps the output identical to the existing per-section path.
+ *
+ * Y=15/16 (and any other inter-section) seam handling:
+ *   - The Rust mesher produced `wasmResult` over the full column, so each
+ *     block's `visible_faces`, `ao_data` and `light_data` already account
+ *     for its true neighbors — including the block above at the section
+ *     seam (e.g. a Y=15 top face is correctly suppressed when Y=16 is
+ *     opaque, even though Y=16 lives in the next render section).
+ *   - This helper therefore does NOT need to widen the per-section block
+ *     window: a strict `[sy*sectionHeight, sy*sectionHeight + sectionHeight)`
+ *     filter on `block.position[1]` is sufficient. The neighbor information
+ *     is already baked into each block's per-face mask/AO/light arrays.
+ *
+ * Empty sections: sections with no blocks in range still get a call into
+ * `renderWasmOutputToGeometry` with an empty `blocks` array, so the
+ * returned `ExportedSection` shape matches what the per-section path
+ * produces for an empty section (empty positions/normals/colors/uvs/
+ * indices arrays).
+ *
+ * Note: this pure helper is not gated internally; callers decide whether
+ * column meshing is enabled.
+ */
+export function splitColumnWasmOutputToSections(
+  fullColumnOutput: WasmGeometryOutput,
+  requestedSectionKeys: Array<{ x: number, y: number, z: number }>,
+  ctx: { version: string, world?: World, sectionHeight?: number }
+): Map<string, { exported: ExportedSection, blocksCount: number }> {
+  const { version, world } = ctx
+  const sectionHeight = ctx.sectionHeight ?? 16
+
+  // Bucket blocks by section Y once, so we don't re-scan the full column
+  // for every requested section. Bucket key = section-relative chunk Y
+  // (i.e. floor(by / sectionHeight)).
+  const blocksByChunkY = new Map<number, WasmBlockFaceData[]>()
+  for (const block of fullColumnOutput.blocks) {
+    const by = block.position[1]
+    const chunkY = Math.floor(by / sectionHeight)
+    let bucket = blocksByChunkY.get(chunkY)
+    if (!bucket) {
+      bucket = []
+      blocksByChunkY.set(chunkY, bucket)
+    }
+    bucket.push(block)
+  }
+
+  const out = new Map<string, { exported: ExportedSection, blocksCount: number }>()
+  for (const { x, y, z } of requestedSectionKeys) {
+    // `y` here is the section's world-Y origin (multiple of sectionHeight),
+    // matching the convention used by `mesherWasm.ts` (section keys are
+    // `${chunkX*16},${sectionY},${chunkZ*16}` with sectionY a world-Y
+    // multiple of 16). Translate to chunk-Y bucket index.
+    const chunkY = Math.floor(y / sectionHeight)
+    const sectionBlocks = blocksByChunkY.get(chunkY) ?? []
+
+    const sectionView: WasmGeometryOutput = {
+      blocks: sectionBlocks,
+      block_count: sectionBlocks.length,
+      block_iterations: fullColumnOutput.block_iterations,
+    }
+
+    const sectionKey = `${x},${y},${z}`
+    const sectionPosition = { x: x + 8, y: y + 8, z: z + 8 }
+    const exported = renderWasmOutputToGeometry(
+      sectionView,
+      version,
+      sectionKey,
+      sectionPosition,
+      world
+    )
+    out.set(sectionKey, { exported, blocksCount: sectionBlocks.length })
+  }
+
+  return out
+}
+
 /**
  * Convert WASM output to exported geometry format
  */