minecraft-renderer 0.1.107 → 0.1.108

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

@@ -0,0 +1,83 @@
+//@ts-nocheck
+import { describe, expect, test } from 'vitest'
+import { provenMeshLightVersion } from '../worker/mesherLightDependencies'
+
+function prove(sx: number, sz: number, used: string[], applied: Array<[string, number]>) {
+  return provenMeshLightVersion({
+    sx,
+    sz,
+    usedColumns: new Set(used),
+    appliedVersionByColumn: new Map(applied)
+  })
+}
+
+describe('provenMeshLightVersion', () => {
+  test('a bootstrap neighbor wall takes the published column version when that column was meshed', () => {
+    expect(prove(16, 0, ['0,0', '16,0'], [['0,0', 10]])).toBe(10)
+    expect(prove(0, 16, ['0,0', '0,16'], [['0,0', 8]])).toBe(8)
+  })
+
+  test('negative chunk coordinates use the same column keys', () => {
+    expect(prove(-16, -32, ['-32,-32', '-16,-32'], [['-32,-32', 7]])).toBe(7)
+  })
+
+  test('an unused published column is not proof, even if a dirty job requested that version', () => {
+    expect(prove(16, 0, ['16,0'], [['0,0', 10]])).toBe(0)
+  })
+
+  test('an older own-column version does not hide a newer neighbor publication that was meshed', () => {
+    expect(
+      prove(
+        16,
+        0,
+        ['0,0', '16,0'],
+        [
+          ['16,0', 4],
+          ['0,0', 10]
+        ]
+      )
+    ).toBe(10)
+  })
+
+  test('a later own publication does not cover an earlier neighbor that was left out of the mesh', () => {
+    expect(
+      prove(
+        16,
+        0,
+        ['16,0'],
+        [
+          ['0,0', 10],
+          ['16,0', 12]
+        ]
+      )
+    ).toBe(0)
+  })
+
+  test('a used column older than the missing neighbor still counts', () => {
+    expect(
+      prove(
+        16,
+        0,
+        ['16,0'],
+        [
+          ['0,0', 10],
+          ['16,0', 4]
+        ]
+      )
+    ).toBe(4)
+  })
+
+  test('a far column publication does not raise the stamp', () => {
+    expect(prove(0, 0, ['0,0', '100,100'], [['100,100', 100]])).toBe(0)
+  })
+
+  test('forgetting a column drops it from later proofs', () => {
+    const applied = new Map<string, number>([
+      ['0,0', 10],
+      ['16,0', 10]
+    ])
+    applied.delete('0,0')
+    expect(prove(16, 0, ['16,0'], [...applied.entries()])).toBe(10)
+    expect(prove(0, 0, ['0,0'], [...applied.entries()])).toBe(0)
+  })
+})

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

@@ -0,0 +1,39 @@
+//@ts-nocheck
+import { describe, expect, test } from 'vitest'
+import { BULK_COLUMNS_PER_TICK, selectColumnGroupsForTick } from '../worker/mesherWasmColumnTickSelect'
+
+function dirtyOf(keys: string[]): Map<string, number> {
+  const dirty = new Map<string, number>()
+  for (const key of keys) dirty.set(key, 1)
+  return dirty
+}
+
+describe('selectColumnGroupsForTick', () => {
+  test('urgent columns are selected before bulk columns', () => {
+    const dirty = dirtyOf(['160,64,0', '0,64,0', '32,64,0'])
+    const urgent = new Set(['0,64,0'])
+    const { selected, remaining } = selectColumnGroupsForTick(dirty, urgent, 4)
+    expect(selected.map(group => `${group.x},${group.z}`)).toEqual(['0,0', '160,0', '32,0'])
+    expect(remaining.size).toBe(0)
+  })
+
+  test('a tick leaves leftover bulk columns for the next tick', () => {
+    const keys = ['0,64,0', '16,64,0', '32,64,0', '48,64,0', '64,64,0', '80,64,0']
+    const dirty = dirtyOf(keys)
+    const first = selectColumnGroupsForTick(dirty, new Set(), BULK_COLUMNS_PER_TICK)
+    expect(first.selected).toHaveLength(4)
+    expect([...first.remaining.keys()]).toEqual(['64,64,0', '80,64,0'])
+    const second = selectColumnGroupsForTick(first.remaining, new Set(), BULK_COLUMNS_PER_TICK)
+    expect(second.selected.map(group => `${group.x},${group.z}`)).toEqual(['64,0', '80,0'])
+    expect(second.remaining.size).toBe(0)
+  })
+
+  test('urgent still wins when the same key also has bulk dirties', () => {
+    const dirty = dirtyOf(['16,64,0', '0,64,0', '32,64,0', '48,64,0', '64,64,0', '80,64,0', '96,64,0'])
+    dirty.set('0,64,0', 2)
+    const { selected, remaining } = selectColumnGroupsForTick(dirty, new Set(['0,64,0']), 4)
+    expect(selected[0]).toMatchObject({ x: 0, z: 0 })
+    expect(selected).toHaveLength(5)
+    expect([...remaining.keys()]).toEqual(['80,64,0', '96,64,0'])
+  })
+})

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

@@ -5,7 +5,8 @@ import {
   _peekConversionCache,
   clearConversionCache,
   getOrConvertColumn,
-  invalidateConversion
+  invalidateConversion,
+  patchConversionBlock
 } from '../worker/mesherWasmConversionCache'
 import type { ChunkConversionResult } from '../bridge/convertChunk'
 
@@ -27,6 +28,34 @@ describe('mesherWasmConversionCache', () => {
     clearConversionCache()
   })
 
+  test('patches state and count in place and rejects identity drift', () => {
+    const ref = {}
+    const result = { ...makeResult(0), blockStates: new Uint16Array(4096) }
+    getOrConvertColumn(-16, 0, ref, 'v', -64, -48, () => result, ref)
+    expect(patchConversionBlock(-16, 0, ref, -1, -49, 15, 2)).toBe(true)
+    expect(result.blockStates[4095]).toBe(2)
+    expect(result.blockCount).toBe(1)
+    patchConversionBlock(-16, 0, ref, -1, -49, 15, 3)
+    expect(result.blockCount).toBe(1)
+    expect(patchConversionBlock(-16, 0, {}, -1, -49, 15, 0)).toBe(false)
+    patchConversionBlock(-16, 0, ref, -1, -49, 15, 0)
+    expect(result.blockCount).toBe(0)
+    expect(
+      getOrConvertColumn(
+        -16,
+        0,
+        ref,
+        'v',
+        -64,
+        -48,
+        () => {
+          throw new Error('unexpected conversion')
+        },
+        ref
+      ).result
+    ).toBe(result)
+  })
+
   test('miss then hit on same chunk ref returns cached result', () => {
     const ref = { id: 'chunk-a' }
     let calls = 0

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

@@ -0,0 +1,73 @@
+//@ts-nocheck
+import { afterEach, describe, expect, test } from 'vitest'
+import { beginTickWasmParseCache, endTickWasmParseCache, getOrConvertTickWasmParse, getTickWasmParseStats } from '../worker/mesherWasmTickParseCache'
+
+afterEach(() => {
+  endTickWasmParseCache()
+})
+
+describe('mesherWasmTickParseCache', () => {
+  test('second convert of the same column in one tick is a hit without copying', () => {
+    beginTickWasmParseCache()
+    let calls = 0
+    const convert = () => {
+      calls++
+      return { tag: calls }
+    }
+    const a = getOrConvertTickWasmParse('0,0', convert)
+    const b = getOrConvertTickWasmParse('0,0', convert)
+    expect(a.hit).toBe(false)
+    expect(b.hit).toBe(true)
+    expect(calls).toBe(1)
+    expect(b.result).toBe(a.result)
+    expect(getTickWasmParseStats()).toEqual({ hits: 1, misses: 1 })
+  })
+
+  test('distinct columns miss independently and unique-column count matches the cache', () => {
+    beginTickWasmParseCache()
+    let calls = 0
+    const convert = () => {
+      calls++
+      return { tag: calls }
+    }
+    for (let i = 0; i < 9; i++) getOrConvertTickWasmParse(`${i * 16},0`, convert)
+    for (let i = 0; i < 9; i++) getOrConvertTickWasmParse(`${i * 16},0`, convert)
+    expect(calls).toBe(9)
+    expect(getTickWasmParseStats()).toEqual({ hits: 9, misses: 9 })
+  })
+
+  test('null results are not cached so a later convert can recover', () => {
+    beginTickWasmParseCache()
+    let calls = 0
+    const a = getOrConvertTickWasmParse('16,16', () => {
+      calls++
+      return null
+    })
+    const b = getOrConvertTickWasmParse('16,16', () => {
+      calls++
+      return { tag: 1 }
+    })
+    expect(a.result).toBeNull()
+    expect(a.hit).toBe(false)
+    expect(b.hit).toBe(false)
+    expect(b.result).toEqual({ tag: 1 })
+    expect(calls).toBe(2)
+  })
+
+  test('end of tick drops entries so the next tick misses', () => {
+    beginTickWasmParseCache()
+    let calls = 0
+    getOrConvertTickWasmParse('0,0', () => {
+      calls++
+      return { tag: 1 }
+    })
+    endTickWasmParseCache()
+    beginTickWasmParseCache()
+    getOrConvertTickWasmParse('0,0', () => {
+      calls++
+      return { tag: 2 }
+    })
+    expect(calls).toBe(2)
+    expect(getTickWasmParseStats()).toEqual({ hits: 0, misses: 1 })
+  })
+})

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

@@ -0,0 +1,51 @@
+//@ts-nocheck
+import { describe, expect, test, vi } from 'vitest'
+import { BULK_MESH_INTERVAL_MS, createMeshTickScheduler } from '../worker/mesherWasmTickSchedule'
+
+describe('createMeshTickScheduler', () => {
+  test('an urgent kick runs on the next turn, before the bulk poll interval', async () => {
+    vi.useFakeTimers()
+    try {
+      let runs = 0
+      const scheduler = createMeshTickScheduler(() => {
+        runs++
+      })
+      scheduler.kick()
+      expect(runs).toBe(0)
+      await vi.advanceTimersByTimeAsync(0)
+      expect(runs).toBe(1)
+      expect(BULK_MESH_INTERVAL_MS).toBeGreaterThan(0)
+    } finally {
+      vi.clearAllTimers()
+      vi.useRealTimers()
+    }
+  })
+
+  test('a kick during a running tick runs again after that tick finishes', async () => {
+    vi.useFakeTimers()
+    try {
+      let release: () => void = () => {}
+      const gate = new Promise<void>(resolve => {
+        release = resolve
+      })
+      let runs = 0
+      const scheduler = createMeshTickScheduler(() => {
+        runs++
+        if (runs === 1) {
+          scheduler.kick()
+          return gate
+        }
+      })
+      scheduler.kick()
+      await vi.advanceTimersByTimeAsync(0)
+      expect(runs).toBe(1)
+      release()
+      await gate
+      await Promise.resolve()
+      expect(runs).toBe(2)
+    } finally {
+      vi.clearAllTimers()
+      vi.useRealTimers()
+    }
+  })
+})

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

@@ -0,0 +1,78 @@
+//@ts-nocheck
+import { afterEach, describe, expect, test } from 'vitest'
+import {
+  TOPOLOGY_POST_CACHE_LIMIT,
+  clearTopologyPostCache,
+  clearTopologyPostCacheColumn,
+  getOrComputeTopologyPost
+} from '../worker/mesherWasmTopologyPostCache'
+
+afterEach(() => {
+  clearTopologyPostCache()
+})
+
+describe('mesherWasmTopologyPostCache', () => {
+  test('second pass with the same revision does not walk', () => {
+    let walks = 0
+    const compute = () => {
+      walks++
+      return { visibilitySet: 1, signs: { a: walks }, heads: {}, banners: {} }
+    }
+    const first = getOrComputeTopologyPost('0,64,0', 4, compute)
+    const second = getOrComputeTopologyPost('0,64,0', 4, compute)
+    expect(walks).toBe(1)
+    expect(first.hit).toBe(false)
+    expect(second.hit).toBe(true)
+    expect(second.payload).toBe(first.payload)
+  })
+
+  test('revision change walks again', () => {
+    let walks = 0
+    const compute = () => {
+      walks++
+      return { visibilitySet: walks, signs: {}, heads: {}, banners: {} }
+    }
+    getOrComputeTopologyPost('0,64,0', 4, compute)
+    const next = getOrComputeTopologyPost('0,64,0', 5, compute)
+    expect(walks).toBe(2)
+    expect(next.hit).toBe(false)
+    expect(next.payload.visibilitySet).toBe(2)
+  })
+
+  test('missing revision always walks and does not cache', () => {
+    let walks = 0
+    const compute = () => {
+      walks++
+      return { visibilitySet: walks, signs: {}, heads: {}, banners: {} }
+    }
+    getOrComputeTopologyPost('0,64,0', undefined, compute)
+    getOrComputeTopologyPost('0,64,0', undefined, compute)
+    expect(walks).toBe(2)
+  })
+
+  test('unload of a column clears its cached sections', () => {
+    let walks = 0
+    const compute = () => {
+      walks++
+      return { visibilitySet: walks, signs: {}, heads: {}, banners: {} }
+    }
+    getOrComputeTopologyPost('0,64,0', 3, compute)
+    getOrComputeTopologyPost('16,64,0', 3, compute)
+    clearTopologyPostCacheColumn(0, 0)
+    getOrComputeTopologyPost('0,64,0', 3, compute)
+    getOrComputeTopologyPost('16,64,0', 3, compute)
+    expect(walks).toBe(3)
+  })
+
+  test('evicts oldest entries past the cap', () => {
+    for (let i = 0; i < TOPOLOGY_POST_CACHE_LIMIT + 3; i++) {
+      getOrComputeTopologyPost(`${i},64,0`, 1, () => ({ visibilitySet: i, signs: {}, heads: {}, banners: {} }))
+    }
+    let walks = 0
+    getOrComputeTopologyPost('0,64,0', 1, () => {
+      walks++
+      return { visibilitySet: -1, signs: {}, heads: {}, banners: {} }
+    })
+    expect(walks).toBe(1)
+  })
+})

package/src/wasm-mesher/worker/clientLightDarkPublication.probe.test.ts

@@ -0,0 +1,32 @@
+//@ts-nocheck
+import { describe, it, expect } from 'vitest'
+import { applyOwnerPublicationToColumnCaches } from './mesherWasmOwnerLight'
+import { displayLightColumn } from './mesherWasmLightMerge'
+
+describe('dark publication omission diagnostic (current behavior)', () => {
+  const blockOnly = { sx: 0, sy: 0, sz: 0, blockLight: new Uint8Array(2048) }
+  const base = { worldMinY: 0, columnWorldX: 0, columnWorldZ: 0, numSections: 2 }
+  it('displays sky 15 when initial publication omits sky and no incoming light exists', () => {
+    const result = applyOwnerPublicationToColumnCaches({ ...base, incoming: undefined, display: undefined, sections: [blockOnly] })
+    expect(
+      displayLightColumn(result.display, 'sky')
+        .subarray(0, 4096)
+        .every(value => value === 15)
+    ).toBe(true)
+  })
+  it('retains dark sky when an incoming authoritative cache exists', () => {
+    const initial = applyOwnerPublicationToColumnCaches({
+      ...base,
+      incoming: undefined,
+      display: undefined,
+      sections: [{ ...blockOnly, skyLight: new Uint8Array(2048) }]
+    }).display
+    const result = applyOwnerPublicationToColumnCaches({ ...base, incoming: initial, display: initial, sections: [blockOnly] })
+    expect(
+      displayLightColumn(result.display, 'sky')
+        .subarray(0, 4096)
+        .every(value => value === 0)
+    ).toBe(true)
+    expect(result.display).not.toBe(initial)
+  })
+})

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

@@ -0,0 +1,43 @@
+//@ts-nocheck
+/**
+ * Light-version stamp for one section mesh.
+ *
+ * Each column keeps only the latest applied owner version. The stamp is the
+ * newest of those versions whose sampled columns were actually meshed, and it
+ * stops before the first sampled column that was written but left out. The
+ * version requested on the dirty job is not an input.
+ */
+
+export function sectionLightSampleColumns(sx: number, sz: number): string[] {
+  const columns: string[] = []
+  for (let dx = -16; dx <= 16; dx += 16) {
+    for (let dz = -16; dz <= 16; dz += 16) {
+      columns.push(`${sx + dx},${sz + dz}`)
+    }
+  }
+  return columns
+}
+
+export function provenMeshLightVersion(opts: {
+  sx: number
+  sz: number
+  usedColumns: ReadonlySet<string>
+  appliedVersionByColumn: ReadonlyMap<string, number>
+}): number {
+  let gap = Number.POSITIVE_INFINITY
+  let covered = 0
+  for (const column of sectionLightSampleColumns(opts.sx, opts.sz)) {
+    const applied = opts.appliedVersionByColumn.get(column)
+    if (applied == null) continue
+    if (!opts.usedColumns.has(column)) gap = Math.min(gap, applied)
+    else covered = Math.max(covered, applied)
+  }
+  if (!Number.isFinite(gap)) return covered
+  let belowGap = 0
+  for (const column of sectionLightSampleColumns(opts.sx, opts.sz)) {
+    const applied = opts.appliedVersionByColumn.get(column)
+    if (applied == null || !opts.usedColumns.has(column) || applied >= gap) continue
+    belowGap = Math.max(belowGap, applied)
+  }
+  return belowGap
+}

package/src/wasm-mesher/worker/mesherWasm.ownerLightSync.test.ts

@@ -0,0 +1,198 @@
+//@ts-nocheck
+import MinecraftData from 'minecraft-data'
+import Chunks from 'prismarine-chunk'
+import { Vec3 } from 'vec3'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { packUnpackedLightSection } from '../../mesher-shared/lightNibblePack'
+import { LIGHT_BLOCKS_PER_SECTION, maskBitSet, worldSectionMaskBit, type ParsedUpdateLight } from './mesherWasmLightMerge'
+
+// Drives the real worker message handler. The legacy mesh path reads light
+// through `World.getChannelLightNorm`, so that is what these tests observe.
+
+const { parseUpdateLightV17 } = vi.hoisted(() => ({ parseUpdateLightV17: vi.fn() }))
+
+vi.mock('../runtime-build/wasm_mesher.js', () => ({
+  default: vi.fn(async () => undefined),
+  parseUpdateLightV17
+}))
+vi.mock('../../mesher-shared/models', async importOriginal => ({
+  ...(await importOriginal<object>()),
+  setBlockStatesData: vi.fn()
+}))
+vi.mock('./mesherWasmTickSchedule', () => ({
+  BULK_MESH_INTERVAL_MS: 50,
+  createMeshTickScheduler: () => ({ kick: vi.fn() })
+}))
+
+const VERSION = '1.17.1'
+const NUM_SECTIONS = 16
+const COLUMN_X = 16
+const COLUMN_Z = 32
+const PUBLISHED_Y = 64
+const UNPUBLISHED_Y = 80
+const PUBLISHED_POS = new Vec3(COLUMN_X + 3, PUBLISHED_Y + 1, COLUMN_Z + 5)
+const UNPUBLISHED_POS = new Vec3(COLUMN_X + 3, UNPUBLISHED_Y + 5, COLUMN_Z + 5)
+const INCOMING = {
+  [PUBLISHED_Y]: { sky: 3, block: 1 },
+  [UNPUBLISHED_Y]: { sky: 9, block: 4 }
+}
+
+type WorkerSelf = { onmessage: (event: { data: unknown }) => void }
+type WorldLike = {
+  getColumn: (
+    x: number,
+    z: number
+  ) => {
+    setSkyLight: (pos: Vec3, light: number) => void
+    setBlockLight: (pos: Vec3, light: number) => void
+    skyLightSections: Array<unknown | null>
+    blockLightSections: Array<unknown | null>
+  }
+  getChannelLightNorm: (pos: Vec3) => { block: number; sky: number }
+}
+
+const send = (data: unknown) => (globalThis.self as unknown as WorkerSelf).onmessage({ data })
+const world = () => (globalThis as unknown as { world: WorldLike }).world
+const lightAt = (pos: Vec3) => world().getChannelLightNorm(pos)
+const expectedLight = ({ sky, block }: { sky: number; block: number }) => ({
+  sky: Math.min(15, sky + 2) / 15,
+  block: Math.min(15, block + 2) / 15
+})
+
+function serverColumnJson() {
+  const Chunk = Chunks(VERSION) as any
+  const chunk = new Chunk(undefined as any)
+  const stone = MinecraftData(VERSION).blocksByName.stone!.defaultState
+  chunk.setBlockStateId(new Vec3(3, PUBLISHED_POS.y, 5), stone)
+  chunk.setBlockStateId(new Vec3(3, UNPUBLISHED_POS.y, 5), stone)
+  return chunk.toJson()
+}
+
+function serverLightPacket(): ParsedUpdateLight {
+  const columnBytes = NUM_SECTIONS * LIGHT_BLOCKS_PER_SECTION
+  const skyLight = new Uint8Array(columnBytes)
+  const blockLight = new Uint8Array(columnBytes)
+  const skyLightMask = new Uint32Array(2)
+  const blockLightMask = new Uint32Array(2)
+  for (const [sectionY, light] of Object.entries(INCOMING)) {
+    const sectionIndex = Number(sectionY) / 16
+    const start = sectionIndex * LIGHT_BLOCKS_PER_SECTION
+    skyLight.fill(light.sky, start, start + LIGHT_BLOCKS_PER_SECTION)
+    blockLight.fill(light.block, start, start + LIGHT_BLOCKS_PER_SECTION)
+    maskBitSet(skyLightMask, worldSectionMaskBit(sectionIndex))
+    maskBitSet(blockLightMask, worldSectionMaskBit(sectionIndex))
+  }
+  return {
+    x: COLUMN_X / 16,
+    z: COLUMN_Z / 16,
+    trustEdges: true,
+    numSections: NUM_SECTIONS,
+    skyLight,
+    blockLight,
+    skyLightMask,
+    blockLightMask,
+    emptySkyLightMask: new Uint32Array(2),
+    emptyBlockLightMask: new Uint32Array(2)
+  }
+}
+
+function publishOwnerLight(publicationVersion: number, sectionY: number, light: { sky: number; block: number }) {
+  const packed = (value: number) => packUnpackedLightSection(new Uint8Array(LIGHT_BLOCKS_PER_SECTION).fill(value))
+  send({
+    type: 'applyOwnerLightPublication',
+    worldGeneration: 1,
+    publicationVersion,
+    sections: [{ sx: COLUMN_X, sy: sectionY, sz: COLUMN_Z, blockLight: packed(light.block), skyLight: packed(light.sky) }]
+  })
+}
+
+/** Moves the JS column away from the caches, so a sync of this section is detectable. */
+function markUnpublishedSectionInJsColumn(light: { sky: number; block: number }) {
+  const column = world().getColumn(COLUMN_X, COLUMN_Z)
+  const local = new Vec3(UNPUBLISHED_POS.x & 15, UNPUBLISHED_POS.y, UNPUBLISHED_POS.z & 15)
+  column.setSkyLight(local, light.sky)
+  column.setBlockLight(local, light.block)
+}
+
+describe('mesher worker JS column light with the client light owner', () => {
+  beforeEach(async () => {
+    vi.resetModules()
+    parseUpdateLightV17.mockReset()
+    parseUpdateLightV17.mockReturnValue(serverLightPacket())
+    vi.stubGlobal('self', {})
+    vi.stubGlobal('postMessage', vi.fn())
+    const realSetInterval = globalThis.setInterval
+    vi.stubGlobal('setInterval', vi.fn())
+    await import('./mesherWasm')
+    vi.stubGlobal('setInterval', realSetInterval)
+
+    send({ type: 'mesherData', config: { version: VERSION, worldMinY: 0, worldMaxY: 256, enableLighting: true } })
+    send({ type: 'chunk', x: COLUMN_X, z: COLUMN_Z, chunk: serverColumnJson() })
+    send({ type: 'setUpdateLightV17', rawPacket: new Uint8Array(1), numSections: NUM_SECTIONS })
+    await vi.waitFor(() => expect(parseUpdateLightV17).toHaveBeenCalledOnce())
+
+    expect(lightAt(PUBLISHED_POS)).toEqual(expectedLight(INCOMING[PUBLISHED_Y]))
+    expect(lightAt(UNPUBLISHED_POS)).toEqual(expectedLight(INCOMING[UNPUBLISHED_Y]))
+  }, 30_000)
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+    delete (globalThis as any).world
+  })
+
+  it('keeps authoritative zero light explicit in initially null sections', () => {
+    const sectionY = 96
+    const pos = new Vec3(COLUMN_X + 3, sectionY + 1, COLUMN_Z + 5)
+    expect(lightAt(pos)).toEqual({ block: 0, sky: 1 })
+    publishOwnerLight(1, sectionY, { sky: 0, block: 0 })
+    expect(lightAt(pos)).toEqual(expectedLight({ sky: 0, block: 0 }))
+    send({ type: 'chunk', x: COLUMN_X, z: COLUMN_Z, chunk: serverColumnJson() })
+    expect(lightAt(pos)).toEqual(expectedLight({ sky: 0, block: 0 }))
+  })
+
+  it('allocates only the authoritative channel and leaves omitted sections null', () => {
+    const sectionY = 96
+    send({
+      type: 'applyOwnerLightPublication',
+      worldGeneration: 1,
+      publicationVersion: 1,
+      sections: [{ sx: COLUMN_X, sy: sectionY, sz: COLUMN_Z, blockLight: new Uint8Array(2048) }]
+    })
+    const column = world().getColumn(COLUMN_X, COLUMN_Z)
+    expect(column.blockLightSections[sectionY / 16 + 1]).not.toBeNull()
+    expect(column.skyLightSections[sectionY / 16 + 1]).toBeNull()
+    expect(column.blockLightSections[sectionY / 16 + 2]).toBeNull()
+    expect(column.skyLightSections[sectionY / 16 + 2]).toBeNull()
+    expect(lightAt(new Vec3(COLUMN_X + 3, sectionY + 17, COLUMN_Z + 5))).toEqual({ block: 0, sky: 1 })
+  })
+
+  it('raises JS light when a publication brightens a section', () => {
+    const bright = { sky: 12, block: 7 }
+    publishOwnerLight(1, PUBLISHED_Y, bright)
+    expect(lightAt(PUBLISHED_POS)).toEqual(expectedLight(bright))
+  })
+
+  it('lowers JS light when a later publication darkens the section', () => {
+    const dark = { sky: 0, block: 0 }
+    publishOwnerLight(1, PUBLISHED_Y, { sky: 12, block: 7 })
+    publishOwnerLight(2, PUBLISHED_Y, dark)
+    expect(lightAt(PUBLISHED_POS)).toEqual(expectedLight(dark))
+  })
+
+  it('writes only the published section Ys into the JS column', () => {
+    const marker = { sky: 14, block: 13 }
+    const bright = { sky: 12, block: 7 }
+    markUnpublishedSectionInJsColumn(marker)
+    publishOwnerLight(1, PUBLISHED_Y, bright)
+    expect(lightAt(PUBLISHED_POS)).toEqual(expectedLight(bright))
+    expect(lightAt(UNPUBLISHED_POS)).toEqual(expectedLight(marker))
+  })
+
+  it('restores every incoming section in the JS column on revert', () => {
+    publishOwnerLight(1, PUBLISHED_Y, { sky: 12, block: 7 })
+    markUnpublishedSectionInJsColumn({ sky: 14, block: 13 })
+    send({ type: 'revertOwnerLightToIncoming' })
+    expect(lightAt(PUBLISHED_POS)).toEqual(expectedLight(INCOMING[PUBLISHED_Y]))
+    expect(lightAt(UNPUBLISHED_POS)).toEqual(expectedLight(INCOMING[UNPUBLISHED_Y]))
+  })
+})