minecraft-renderer 0.1.106 → 0.1.108

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

@@ -4,6 +4,7 @@ export type PendingChunkMessage = {
   z: number
   chunk: any
   customBlockModels?: any
+  isLightUpdate?: boolean
 }
 
 export class PendingChunkBuffer {

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

@@ -0,0 +1,47 @@
+//@ts-nocheck
+/**
+ * Choose which dirty columns a mesher tick processes.
+ *
+ * Urgent (player-edit) columns go first with no cap. Bulk columns are limited
+ * so an incoming edit is not stuck behind a long FIFO of load-wave remeshes.
+ */
+
+export const BULK_COLUMNS_PER_TICK = 4
+
+export type ColumnTickSection = { key: string; x: number; y: number; z: number; count: number }
+
+export type ColumnTickGroup = { x: number; z: number; sections: ColumnTickSection[] }
+
+export function groupDirtySectionsByColumn(dirtySections: Iterable<[string, number]>): ColumnTickGroup[] {
+  const groups = new Map<string, ColumnTickGroup>()
+  for (const [key, count] of dirtySections) {
+    const [sx, sy, sz] = key.split(',').map(v => parseInt(v, 10))
+    const colKey = `${sx},${sz}`
+    let group = groups.get(colKey)
+    if (!group) {
+      group = { x: sx, z: sz, sections: [] }
+      groups.set(colKey, group)
+    }
+    group.sections.push({ key, x: sx, y: sy, z: sz, count })
+  }
+  return [...groups.values()]
+}
+
+export function selectColumnGroupsForTick(
+  dirtySections: Map<string, number>,
+  urgentKeys: Set<string>,
+  bulkLimit = BULK_COLUMNS_PER_TICK
+): { selected: ColumnTickGroup[]; remaining: Map<string, number> } {
+  const urgent: ColumnTickGroup[] = []
+  const bulk: ColumnTickGroup[] = []
+  for (const group of groupDirtySectionsByColumn(dirtySections)) {
+    if (group.sections.some(section => urgentKeys.has(section.key))) urgent.push(group)
+    else bulk.push(group)
+  }
+  const selected = [...urgent, ...bulk.slice(0, bulkLimit)]
+  const remaining = new Map<string, number>()
+  for (const group of bulk.slice(bulkLimit)) {
+    for (const section of group.sections) remaining.set(section.key, section.count)
+  }
+  return { selected, remaining }
+}

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

@@ -8,9 +8,9 @@
 // redundant conversions.
 //
 // Correctness invariants:
-// - Cache value MUST NOT be mutated by consumers. The `ChunkConversionResult`
-//   typed arrays are used as `set()` SOURCES (and as wasm INPUTS) in the
-//   mesher tick, never as destinations, so the read-only contract holds.
+// - Block arrays are patched only by patchConversionBlock. Light arrays may
+//   receive the current display overlay before meshing. Other consumers must
+//   not mutate cache values. WASM receives the resulting arrays as inputs.
 // - Identity-based key validation: a hit is served only when the stored
 //   chunk reference is `===` the live `world.getColumn(x,z)` reference, so a
 //   replaced column (via `world.addColumn`) can never accidentally serve
@@ -18,8 +18,8 @@
 //   skipped (defense in depth).
 // - In-place mutation of an existing column object (e.g. via
 //   `world.setBlockStateId` from a `blockUpdate` message) preserves identity
-//   but changes content. The `blockUpdate` handler explicitly invalidates
-//   the affected `(chunkX, chunkZ)` to handle this.
+//   but changes content. The `blockUpdate` handler patches the cached state
+//   and count, or invalidates when it cannot patch safely.
 
 import type { ChunkConversionResult } from '../bridge/convertChunk'
 
@@ -124,6 +124,17 @@ export function getConversionCacheLimit(): number {
   return activeLimit
 }
 
+/** Patch a live column without discarding its converted topology or metadata. */
+export function patchConversionBlock(x: number, z: number, chunkRef: any, blockX: number, blockY: number, blockZ: number, stateId: number): boolean {
+  const e = cache.get(keyOf(x, z))
+  if (!e || e.chunkRef !== chunkRef || blockY < e.worldMinY || blockY >= e.worldMaxY) return false
+  const index = blockX - x + (blockZ - z) * 16 + (blockY - e.worldMinY) * 256
+  const old = e.result.blockStates[index]!
+  e.result.blockStates[index] = stateId
+  e.result.blockCount += Number(stateId !== 0) - Number(old !== 0)
+  return true
+}
+
 export function invalidateConversion(x: number, z: number): boolean {
   return cache.delete(keyOf(x, z))
 }

package/src/wasm-mesher/worker/mesherWasmLightDirty.test.ts

@@ -1,9 +1,25 @@
 //@ts-nocheck
 import { describe, expect, it } from 'vitest'
-import { sectionYsForLightColumnDirty } from './mesherWasmLightDirty'
+import { dropRawMapChunkOnLightOnlyReload, sectionYsForLightColumnDirty } from './mesherWasmLightDirty'
 
 describe('sectionYsForLightColumnDirty', () => {
   it('covers every section in a 256-high overworld column', () => {
     expect(sectionYsForLightColumnDirty(0, 256)).toEqual(Array.from({ length: 16 }, (_, i) => i * 16))
   })
 })
+
+describe('dropRawMapChunkOnLightOnlyReload', () => {
+  it('deletes only the fused raw entry when the chunk reload is light-only', () => {
+    const raw = new Map<string, number>([
+      ['0,0', 1],
+      ['16,0', 2]
+    ])
+    expect(dropRawMapChunkOnLightOnlyReload(false, raw, '0,0')).toBe(false)
+    expect(raw.has('0,0')).toBe(true)
+    expect(dropRawMapChunkOnLightOnlyReload(undefined, raw, '0,0')).toBe(false)
+    expect(raw.has('0,0')).toBe(true)
+    expect(dropRawMapChunkOnLightOnlyReload(true, raw, '0,0')).toBe(true)
+    expect(raw.has('0,0')).toBe(false)
+    expect(raw.has('16,0')).toBe(true)
+  })
+})

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

@@ -9,3 +9,13 @@ export function sectionYsForLightColumnDirty(worldMinY: number, worldMaxY: numbe
   }
   return ys
 }
+
+/**
+ * 1.18+ fused meshing prefers the original raw map_chunk. A later light-only
+ * column reload must drop that entry so the JSON column walk is used.
+ * Normal chunk loads must keep it (`setRawMapChunk` arrives first).
+ */
+export function dropRawMapChunkOnLightOnlyReload(isLightUpdate: boolean | undefined, rawCache: { delete: (key: string) => boolean }, key: string): boolean {
+  if (!isLightUpdate) return false
+  return rawCache.delete(key)
+}

package/src/wasm-mesher/worker/mesherWasmLightMerge.test.ts

@@ -0,0 +1,208 @@
+//@ts-nocheck
+import { describe, expect, it } from 'vitest'
+import {
+  LIGHT_BLOCKS_PER_SECTION,
+  createEmptyLightCache,
+  displayLightColumn,
+  isLightSectionPresent,
+  mergeUpdateLight,
+  worldSectionMaskBit,
+  type ParsedUpdateLight,
+  type UpdateLightColumnCache
+} from './mesherWasmLightMerge'
+
+const NUM_SECTIONS = 16
+const WORLD_BYTES = NUM_SECTIONS * LIGHT_BLOCKS_PER_SECTION
+
+function maskWithBits(...bits: number[]): Uint32Array {
+  const out = new Uint32Array(2)
+  for (const bit of bits) {
+    const bitInLong = bit & 63
+    if (bitInLong < 32) out[0] |= 1 << bitInLong
+    else out[1] |= 1 << (bitInLong - 32)
+  }
+  return out
+}
+
+function emptyParsed(overrides: Partial<ParsedUpdateLight> = {}): ParsedUpdateLight {
+  return {
+    x: 0,
+    z: 0,
+    trustEdges: false,
+    numSections: NUM_SECTIONS,
+    skyLight: new Uint8Array(WORLD_BYTES),
+    blockLight: new Uint8Array(WORLD_BYTES),
+    skyLightMask: new Uint32Array(2),
+    emptySkyLightMask: new Uint32Array(2),
+    blockLightMask: new Uint32Array(2),
+    emptyBlockLightMask: new Uint32Array(2),
+    ...overrides
+  }
+}
+
+function writeWorldSection(column: Uint8Array, sectionIndex: number, value: number) {
+  const start = sectionIndex * LIGHT_BLOCKS_PER_SECTION
+  column.fill(value, start, start + LIGHT_BLOCKS_PER_SECTION)
+}
+
+function sectionSlice(column: Uint8Array, sectionIndex: number): Uint8Array {
+  const start = sectionIndex * LIGHT_BLOCKS_PER_SECTION
+  return column.subarray(start, start + LIGHT_BLOCKS_PER_SECTION)
+}
+
+function sectionAll(column: Uint8Array, sectionIndex: number, value: number): boolean {
+  return sectionSlice(column, sectionIndex).every(v => v === value)
+}
+
+describe('mergeUpdateLight', () => {
+  it('does not bake omitted sky as authoritative 15 on the first packet', () => {
+    const skyLight = new Uint8Array(WORLD_BYTES)
+    writeWorldSection(skyLight, 1, 3)
+    const cache = mergeUpdateLight(
+      undefined,
+      emptyParsed({
+        skyLight,
+        skyLightMask: maskWithBits(worldSectionMaskBit(1))
+      })
+    )
+
+    expect(isLightSectionPresent(cache.skyPresent, worldSectionMaskBit(1))).toBe(true)
+    expect(isLightSectionPresent(cache.skyPresent, worldSectionMaskBit(0))).toBe(false)
+    expect(sectionAll(cache.skyLight, 1, 3)).toBe(true)
+    expect(sectionAll(cache.skyLight, 0, 15)).toBe(false)
+    expect(displayLightColumn(cache, 'sky', 15)[0]).toBe(15)
+    expect(displayLightColumn(cache, 'sky')[LIGHT_BLOCKS_PER_SECTION]).toBe(3)
+  })
+
+  it('preserves an omitted neighbor section across a repeated partial delta', () => {
+    const firstSky = new Uint8Array(WORLD_BYTES)
+    writeWorldSection(firstSky, 0, 7)
+    let cache = mergeUpdateLight(
+      undefined,
+      emptyParsed({
+        skyLight: firstSky,
+        skyLightMask: maskWithBits(worldSectionMaskBit(0))
+      })
+    )
+
+    const secondSky = new Uint8Array(WORLD_BYTES)
+    writeWorldSection(secondSky, 1, 4)
+    cache = mergeUpdateLight(
+      cache,
+      emptyParsed({
+        skyLight: secondSky,
+        skyLightMask: maskWithBits(worldSectionMaskBit(1))
+      })
+    )
+
+    expect(sectionAll(cache.skyLight, 0, 7)).toBe(true)
+    expect(sectionAll(cache.skyLight, 1, 4)).toBe(true)
+    expect(isLightSectionPresent(cache.skyPresent, worldSectionMaskBit(0))).toBe(true)
+    expect(isLightSectionPresent(cache.skyPresent, worldSectionMaskBit(1))).toBe(true)
+    expect(isLightSectionPresent(cache.skyPresent, worldSectionMaskBit(2))).toBe(false)
+  })
+
+  it('zeros a section when the empty-bit is set', () => {
+    const firstSky = new Uint8Array(WORLD_BYTES)
+    writeWorldSection(firstSky, 0, 7)
+    let cache = mergeUpdateLight(
+      undefined,
+      emptyParsed({
+        skyLight: firstSky,
+        skyLightMask: maskWithBits(worldSectionMaskBit(0))
+      })
+    )
+
+    cache = mergeUpdateLight(
+      cache,
+      emptyParsed({
+        emptySkyLightMask: maskWithBits(worldSectionMaskBit(0))
+      })
+    )
+
+    expect(isLightSectionPresent(cache.skyPresent, worldSectionMaskBit(0))).toBe(true)
+    expect(sectionAll(cache.skyLight, 0, 0)).toBe(true)
+    expect(displayLightColumn(cache, 'sky', 15)[0]).toBe(0)
+  })
+
+  it('updates sky and block independently', () => {
+    const skyLight = new Uint8Array(WORLD_BYTES)
+    const blockLight = new Uint8Array(WORLD_BYTES)
+    writeWorldSection(skyLight, 0, 12)
+    writeWorldSection(blockLight, 0, 5)
+    let cache = mergeUpdateLight(
+      undefined,
+      emptyParsed({
+        skyLight,
+        blockLight,
+        skyLightMask: maskWithBits(worldSectionMaskBit(0)),
+        blockLightMask: maskWithBits(worldSectionMaskBit(0))
+      })
+    )
+
+    cache = mergeUpdateLight(
+      cache,
+      emptyParsed({
+        emptyBlockLightMask: maskWithBits(worldSectionMaskBit(0))
+      })
+    )
+
+    expect(sectionAll(cache.skyLight, 0, 12)).toBe(true)
+    expect(sectionAll(cache.blockLight, 0, 0)).toBe(true)
+    expect(isLightSectionPresent(cache.skyPresent, worldSectionMaskBit(0))).toBe(true)
+    expect(isLightSectionPresent(cache.blockPresent, worldSectionMaskBit(0))).toBe(true)
+  })
+
+  it('records padding bits without writing them into the world column', () => {
+    const skyBelow = new Uint8Array(LIGHT_BLOCKS_PER_SECTION).fill(9)
+    const cache = mergeUpdateLight(
+      undefined,
+      emptyParsed({
+        skyBelow,
+        skyLightMask: maskWithBits(0)
+      })
+    )
+
+    expect(isLightSectionPresent(cache.skyPresent, 0)).toBe(true)
+    expect(cache.skyBelow).toBeDefined()
+    expect(cache.skyBelow!.every(v => v === 9)).toBe(true)
+    expect(sectionAll(cache.skyLight, 0, 0)).toBe(true)
+    expect(isLightSectionPresent(cache.skyPresent, worldSectionMaskBit(0))).toBe(false)
+  })
+
+  it('applies captured 1.17.1 empty-block bits without seeding omitted sky as 15', () => {
+    const cache = mergeUpdateLight(
+      undefined,
+      emptyParsed({
+        trustEdges: true,
+        emptyBlockLightMask: maskWithBits(1, 2, 3, 4, 5)
+      })
+    )
+
+    expect(cache.trustEdges).toBe(true)
+    for (let s = 0; s <= 4; s++) {
+      expect(isLightSectionPresent(cache.blockPresent, worldSectionMaskBit(s))).toBe(true)
+      expect(sectionAll(cache.blockLight, s, 0)).toBe(true)
+    }
+    expect(isLightSectionPresent(cache.skyPresent, worldSectionMaskBit(0))).toBe(false)
+    expect(sectionAll(cache.skyLight, 0, 15)).toBe(false)
+    expect(displayLightColumn(cache, 'sky', 15)[0]).toBe(15)
+  })
+
+  it('keeps trustEdges from the latest packet without changing merge rules', () => {
+    const cache = mergeUpdateLight(createEmptyLightCache(NUM_SECTIONS), emptyParsed({ trustEdges: true }))
+    expect(cache.trustEdges).toBe(true)
+  })
+})
+
+describe('displayLightColumn', () => {
+  it('fills only absent world sections and leaves explicit zeros', () => {
+    const cache: UpdateLightColumnCache = createEmptyLightCache(NUM_SECTIONS)
+    writeWorldSection(cache.blockLight, 2, 0)
+    cache.blockPresent = maskWithBits(worldSectionMaskBit(2))
+
+    const displayed = displayLightColumn(cache, 'block', 0)
+    expect(sectionAll(displayed, 2, 0)).toBe(true)
+    expect(sectionAll(displayed, 1, 0)).toBe(true)
+  })
+})

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

@@ -0,0 +1,228 @@
+//@ts-nocheck
+/** 16³ unpacked light values per section. */
+export const LIGHT_BLOCKS_PER_SECTION = 4096
+
+export type ParsedUpdateLight = {
+  x: number
+  z: number
+  trustEdges: boolean
+  numSections: number
+  skyLight: Uint8Array
+  blockLight: Uint8Array
+  skyLightMask: Uint32Array
+  emptySkyLightMask: Uint32Array
+  blockLightMask: Uint32Array
+  emptyBlockLightMask: Uint32Array
+  skyBelow?: Uint8Array
+  skyAbove?: Uint8Array
+  blockBelow?: Uint8Array
+  blockAbove?: Uint8Array
+}
+
+export type UpdateLightColumnCache = {
+  numSections: number
+  trustEdges: boolean
+  skyLight: Uint8Array
+  blockLight: Uint8Array
+  skyPresent: Uint32Array
+  blockPresent: Uint32Array
+  skyBelow?: Uint8Array
+  skyAbove?: Uint8Array
+  blockBelow?: Uint8Array
+  blockAbove?: Uint8Array
+}
+
+export function worldSectionMaskBit(sectionIndex: number): number {
+  return sectionIndex + 1
+}
+
+export function lightMaskWordCount(numSections: number): number {
+  const bits = numSections + 2
+  return Math.max(2, Math.ceil(bits / 64) * 2)
+}
+
+export function maskBitGet(mask: Uint32Array, i: number): boolean {
+  const longIdx = i >> 6
+  const bitInLong = i & 63
+  const pair = longIdx * 2
+  if (pair + 1 >= mask.length) return false
+  const val = bitInLong < 32 ? mask[pair]! : mask[pair + 1]!
+  const bit = bitInLong & 31
+  return ((val >>> bit) & 1) === 1
+}
+
+export function maskBitSet(mask: Uint32Array, i: number): void {
+  const longIdx = i >> 6
+  const bitInLong = i & 63
+  const pair = longIdx * 2
+  if (pair + 1 >= mask.length) return
+  if (bitInLong < 32) mask[pair] = (mask[pair]! | (1 << bitInLong)) >>> 0
+  else mask[pair + 1] = (mask[pair + 1]! | (1 << (bitInLong - 32))) >>> 0
+}
+
+export function isLightSectionPresent(present: Uint32Array, maskBit: number): boolean {
+  return maskBitGet(present, maskBit)
+}
+
+export function createEmptyLightCache(numSections: number): UpdateLightColumnCache {
+  const worldBytes = numSections * LIGHT_BLOCKS_PER_SECTION
+  const words = lightMaskWordCount(numSections)
+  return {
+    numSections,
+    trustEdges: false,
+    skyLight: new Uint8Array(worldBytes),
+    blockLight: new Uint8Array(worldBytes),
+    skyPresent: new Uint32Array(words),
+    blockPresent: new Uint32Array(words)
+  }
+}
+
+function copySection(dest: Uint8Array, src: Uint8Array, sectionIndex: number, value?: number) {
+  const start = sectionIndex * LIGHT_BLOCKS_PER_SECTION
+  const end = start + LIGHT_BLOCKS_PER_SECTION
+  if (value !== undefined) {
+    dest.fill(value, start, end)
+    return
+  }
+  if (src.length < end) return
+  dest.set(src.subarray(start, end), start)
+}
+
+function mergePadding(hasData: boolean, incoming?: Uint8Array): Uint8Array {
+  if (hasData && incoming && incoming.length === LIGHT_BLOCKS_PER_SECTION) {
+    return new Uint8Array(incoming)
+  }
+  return new Uint8Array(LIGHT_BLOCKS_PER_SECTION)
+}
+
+function mergeChannel(
+  destValues: Uint8Array,
+  destPresent: Uint32Array,
+  srcValues: Uint8Array,
+  dataMask: Uint32Array,
+  emptyMask: Uint32Array,
+  numSections: number,
+  destBelow: Uint8Array | undefined,
+  destAbove: Uint8Array | undefined,
+  incomingBelow: Uint8Array | undefined,
+  incomingAbove: Uint8Array | undefined
+): { below?: Uint8Array; above?: Uint8Array } {
+  let below = destBelow
+  let above = destAbove
+  const totalBits = numSections + 2
+  for (let bit = 0; bit < totalBits; bit++) {
+    const hasData = maskBitGet(dataMask, bit)
+    const hasEmpty = maskBitGet(emptyMask, bit)
+    if (!hasData && !hasEmpty) continue
+
+    if (bit === 0) {
+      below = mergePadding(hasData, incomingBelow)
+      maskBitSet(destPresent, 0)
+      continue
+    }
+    if (bit === numSections + 1) {
+      above = mergePadding(hasData, incomingAbove)
+      maskBitSet(destPresent, bit)
+      continue
+    }
+
+    const sectionIndex = bit - 1
+    if (hasData) copySection(destValues, srcValues, sectionIndex)
+    else copySection(destValues, srcValues, sectionIndex, 0)
+    maskBitSet(destPresent, bit)
+  }
+  return { below, above }
+}
+
+export function mergeUpdateLight(cache: UpdateLightColumnCache | undefined, parsed: ParsedUpdateLight): UpdateLightColumnCache {
+  const next = cache ? cloneLightCache(cache) : createEmptyLightCache(parsed.numSections)
+  next.trustEdges = parsed.trustEdges
+  next.numSections = parsed.numSections
+
+  const skyPad = mergeChannel(
+    next.skyLight,
+    next.skyPresent,
+    parsed.skyLight,
+    parsed.skyLightMask,
+    parsed.emptySkyLightMask,
+    parsed.numSections,
+    next.skyBelow,
+    next.skyAbove,
+    parsed.skyBelow,
+    parsed.skyAbove
+  )
+  next.skyBelow = skyPad.below
+  next.skyAbove = skyPad.above
+
+  const blockPad = mergeChannel(
+    next.blockLight,
+    next.blockPresent,
+    parsed.blockLight,
+    parsed.blockLightMask,
+    parsed.emptyBlockLightMask,
+    parsed.numSections,
+    next.blockBelow,
+    next.blockAbove,
+    parsed.blockBelow,
+    parsed.blockAbove
+  )
+  next.blockBelow = blockPad.below
+  next.blockAbove = blockPad.above
+
+  return next
+}
+
+export function cloneLightCache(cache: UpdateLightColumnCache): UpdateLightColumnCache {
+  return {
+    numSections: cache.numSections,
+    trustEdges: cache.trustEdges,
+    skyLight: new Uint8Array(cache.skyLight),
+    blockLight: new Uint8Array(cache.blockLight),
+    skyPresent: new Uint32Array(cache.skyPresent),
+    blockPresent: new Uint32Array(cache.blockPresent),
+    skyBelow: cache.skyBelow ? new Uint8Array(cache.skyBelow) : undefined,
+    skyAbove: cache.skyAbove ? new Uint8Array(cache.skyAbove) : undefined,
+    blockBelow: cache.blockBelow ? new Uint8Array(cache.blockBelow) : undefined,
+    blockAbove: cache.blockAbove ? new Uint8Array(cache.blockAbove) : undefined
+  }
+}
+
+export function displayLightColumn(cache: UpdateLightColumnCache, channel: 'sky' | 'block', fill = channel === 'sky' ? 15 : 0): Uint8Array {
+  const out = new Uint8Array(cache.numSections * LIGHT_BLOCKS_PER_SECTION)
+  overlayDisplayLight(cache, channel, out, fill)
+  return out
+}
+
+/** Overlay the current display into a reusable conversion buffer. */
+export function overlayDisplayLight(cache: UpdateLightColumnCache, channel: 'sky' | 'block', out: Uint8Array, fill = channel === 'sky' ? 15 : 0): void {
+  const src = channel === 'sky' ? cache.skyLight : cache.blockLight
+  const present = channel === 'sky' ? cache.skyPresent : cache.blockPresent
+  for (let s = 0; s < cache.numSections; s++) {
+    const start = s * LIGHT_BLOCKS_PER_SECTION
+    const end = start + LIGHT_BLOCKS_PER_SECTION
+    if (maskBitGet(present, worldSectionMaskBit(s))) {
+      out.set(src.subarray(start, end), start)
+    } else {
+      out.fill(fill, start, end)
+    }
+  }
+}
+
+export function parsedUpdateLightFromWasm(parsed: any, numSections: number): ParsedUpdateLight {
+  return {
+    x: parsed.x as number,
+    z: parsed.z as number,
+    trustEdges: Boolean(parsed.trustEdges),
+    numSections,
+    skyLight: parsed.skyLight as Uint8Array,
+    blockLight: parsed.blockLight as Uint8Array,
+    skyLightMask: (parsed.skyLightMask as Uint32Array) ?? new Uint32Array(2),
+    emptySkyLightMask: (parsed.emptySkyLightMask as Uint32Array) ?? new Uint32Array(2),
+    blockLightMask: (parsed.blockLightMask as Uint32Array) ?? new Uint32Array(2),
+    emptyBlockLightMask: (parsed.emptyBlockLightMask as Uint32Array) ?? new Uint32Array(2),
+    skyBelow: parsed.skyBelow as Uint8Array | undefined,
+    skyAbove: parsed.skyAbove as Uint8Array | undefined,
+    blockBelow: parsed.blockBelow as Uint8Array | undefined,
+    blockAbove: parsed.blockAbove as Uint8Array | undefined
+  }
+}