minecraft-renderer 0.1.106 → 0.1.108

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

@@ -892,3 +892,111 @@ test('GlobalLegacyBuffer: blend reorder metadata survives compaction', () => {
   buffer.dispose()
   mat.dispose()
 })
+
+function quadGeometry(quadCount: number): ReturnType<typeof makeQuadGeometry> {
+  const indices = new Uint32Array(quadCount * 6)
+  for (let i = 0; i < quadCount; i++) {
+    const v = i * 4
+    indices.set([v, v + 1, v + 2, v, v + 2, v + 3], i * 6)
+  }
+  return {
+    positions: new Float32Array(quadCount * 12),
+    colors: new Float32Array(quadCount * 12),
+    skyLights: new Float32Array(quadCount * 4),
+    blockLights: new Float32Array(quadCount * 4),
+    uvs: new Float32Array(quadCount * 8),
+    indices
+  }
+}
+
+function drawableLegacyIndices(buffer: GlobalLegacyBuffer, key: string): number {
+  buffer.updateDrawSpans([{ key, distSq: 0 }], 'opaque')
+  return buffer.getVisibleIndexSpans().reduce((sum, span) => sum + span.indexCount, 0)
+}
+
+test('GlobalLegacyBuffer: compaction must not hide pending-replace displayed indices', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene)
+
+  buffer.addSection('H', quadGeometry(8000), 0, 0, 0)
+  buffer.addSection('A', quadGeometry(3000), 0, 0, 0)
+  buffer.addSection('B', quadGeometry(500), 0, 0, 0)
+  drainUploads(buffer)
+  const original = buffer.getSectionDrawStart('A')
+
+  buffer.addSection('A', quadGeometry(3000), 0, 0, 0)
+  buffer.removeSection('H')
+  buffer.compactStep()
+  buffer.uploadDirtyRange()
+  buffer.updateDrawSpans([{ key: 'A', distSq: 0 }], 'opaque')
+
+  expect(drawableLegacyIndices(buffer, 'A')).toBe(18_000)
+  expect(buffer.getSectionDrawStart('A')).toBe(original)
+  expect(buffer.getPendingMove()?.key === 'A').toBe(false)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalLegacyBuffer: 27 simultaneous remeshes keep displayed quads on every frame', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene)
+  const n = 27
+  const quads = 1000
+  const expectedIndices = quads * 6
+
+  for (let i = 0; i < n; i++) buffer.addSection(String(i), quadGeometry(quads), 0, 0, 0)
+  drainUploads(buffer)
+  for (let i = 0; i < n; i++) buffer.addSection(String(i), quadGeometry(quads), 0, 0, 0)
+
+  for (let frame = 1; frame <= 160; frame++) {
+    buffer.compactStep()
+    buffer.uploadDirtyRange()
+    for (let i = 0; i < n; i++) {
+      expect(drawableLegacyIndices(buffer, String(i)), `section ${i} on frame ${frame}`).toBe(expectedIndices)
+    }
+    if (!buffer.hasPendingUploads() && !buffer.hasPendingReplace() && !buffer.getPendingMove()) break
+  }
+
+  buffer.dispose()
+  mat.dispose()
+})
+
+test('GlobalLegacyBuffer: remesh during move keeps original displayed slot', () => {
+  const scene = new THREE.Scene()
+  const mat = createGlobalLegacyBlockMaterial()
+  const buffer = new GlobalLegacyBuffer(mat, scene)
+
+  buffer.addSection('H', quadGeometry(8000), 0, 0, 0)
+  buffer.addSection('B', quadGeometry(500), 0, 0, 0)
+  buffer.addSection('A', quadGeometry(3000), 0, 0, 0)
+  drainUploads(buffer)
+  buffer.removeSection('H')
+  drainUploads(buffer)
+  buffer.compactStep()
+  expect(buffer.getPendingMove()?.key).toBe('A')
+  const displayed = buffer.getSectionDrawStart('A')
+  expect(displayed).toBeDefined()
+
+  buffer.addSection('A', quadGeometry(3000), 0, 0, 0)
+  expect(buffer.getSectionDrawStart('A')).toBe(displayed)
+  expect(buffer.getPendingMove()).toBeNull()
+  expect(buffer.hasPendingReplace()).toBe(true)
+  expect(drawableLegacyIndices(buffer, 'A')).toBe(18_000)
+
+  buffer.compactStep()
+  buffer.uploadDirtyRange()
+  expect(buffer.getSectionDrawStart('A')).toBe(displayed)
+  expect(buffer.getPendingMove()?.key === 'A').toBe(false)
+  expect(drawableLegacyIndices(buffer, 'A')).toBe(18_000)
+
+  drainUploads(buffer)
+  buffer.compactStep()
+  finishCurrentMove(buffer)
+  expect(drawableLegacyIndices(buffer, 'A')).toBe(18_000)
+
+  buffer.dispose()
+  mat.dispose()
+})

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

@@ -0,0 +1,25 @@
+//@ts-nocheck
+import { expect, test } from 'vitest'
+import { getWaterFogEnd, getWaterVision, waterFogColorToRgb } from '../waterFog'
+
+test('water vision ramps with sqrt over 30 seconds and then stays at 1', () => {
+  expect(getWaterVision(0)).toBe(0)
+  expect(getWaterVision(7.5)).toBeCloseTo(0.5)
+  expect(getWaterVision(30)).toBe(1)
+  expect(getWaterVision(300)).toBe(1)
+  expect(getWaterVision(-5)).toBe(0)
+})
+
+test('fog distance starts at 24 blocks, reaches 96 and breathing skips the ramp', () => {
+  expect(getWaterFogEnd(0, false)).toBe(24)
+  expect(getWaterFogEnd(7.5, false)).toBeCloseTo(48)
+  expect(getWaterFogEnd(30, false)).toBe(96)
+  expect(getWaterFogEnd(0, true)).toBe(96)
+})
+
+test('default water fog colour is the vanilla dark navy', () => {
+  const [r, g, b] = waterFogColorToRgb(0x05_05_33)
+  expect(r).toBeCloseTo(5 / 255)
+  expect(g).toBeCloseTo(5 / 255)
+  expect(b).toBeCloseTo(51 / 255)
+})

package/src/three/waterFog.ts

@@ -0,0 +1,28 @@
+//@ts-nocheck
+/** Vanilla `Biome.waterFogColor` for most biomes (0x050533). */
+export const DEFAULT_WATER_FOG_COLOR = 0x05_05_33
+
+/** Vanilla `FogRenderer`: water fog ends 96 blocks away at full vision. */
+export const WATER_FOG_FULL_DISTANCE = 96
+/** Vision never drops below a quarter of the full distance, so 24 blocks right after diving in. */
+export const WATER_FOG_MIN_VISION = 0.25
+/** `LocalPlayer.waterVisionTime` caps at 600 ticks (30s at 20 TPS). */
+export const WATER_VISION_TICKS = 600
+export const TICKS_PER_SECOND = 20
+
+/** Vanilla `LocalPlayer.getWaterVision`: sqrt ramp from 0 to 1 over 30s spent underwater. */
+export function getWaterVision(secondsUnderwater: number): number {
+  const ticks = Math.min(Math.max(secondsUnderwater, 0) * TICKS_PER_SECOND, WATER_VISION_TICKS)
+  return Math.sqrt(ticks / WATER_VISION_TICKS)
+}
+
+/** Distance at which water fog is fully opaque. Conduit-like water breathing gives full vision at once. */
+export function getWaterFogEnd(secondsUnderwater: number, waterBreathing: boolean): number {
+  const vision = waterBreathing ? 1 : getWaterVision(secondsUnderwater)
+  return WATER_FOG_FULL_DISTANCE * Math.max(WATER_FOG_MIN_VISION, vision)
+}
+
+/** 0xRRGGBB to 0..1 components (same raw-component convention the land fog already uses). */
+export function waterFogColorToRgb(color: number): [number, number, number] {
+  return [((color >> 16) & 0xff) / 255, ((color >> 8) & 0xff) / 255, (color & 0xff) / 255]
+}

package/src/three/worldRendererThree.ts

@@ -40,6 +40,9 @@ import { FireworksManager } from './fireworks'
 import { SceneOrigin } from './sceneOrigin'
 import { downloadWorldGeometry } from './worldGeometryExport'
 import { ChunkMeshManager } from './chunkMeshManager'
+import { selectReadySectionFlushes } from '../lighting/versioning/pendingSectionFlush'
+import { isClientLightTraceEnabled, recordClientLightTrace } from '../lighting/debug/clientLightTrace'
+import { EntityLightController } from '../lighting/entity/entityLightController'
 import { raycastVoxelSolid } from './thirdPersonVoxelRaycast'
 import type { RendererModuleManifest, RegisteredModule, RendererModuleController } from './rendererModuleSystem'
 import { BUILTIN_MODULES } from './modules/index'
@@ -89,6 +92,7 @@ export class WorldRendererThree extends WorldRendererCommon {
   ambientLight = new THREE.AmbientLight(0xcc_cc_cc, WorldRendererThree.LEGACY_TO_PHYSICAL_LIGHT)
   directionalLight = new THREE.DirectionalLight(0xff_ff_ff, 0.5 * WorldRendererThree.LEGACY_TO_PHYSICAL_LIGHT)
   entities = new Entities(this, (globalThis as any).mcData)
+  entityLightController?: EntityLightController
   performanceMonitor!: PerformanceMonitor
   cameraGroupVr?: THREE.Object3D
   material = new THREE.MeshBasicMaterial({ vertexColors: true, transparent: true, alphaTest: 0.1 })
@@ -204,6 +208,14 @@ export class WorldRendererThree extends WorldRendererCommon {
 
     // Initialize chunk mesh manager
     this.chunkMeshManager = new ChunkMeshManager(this, this.scene, this.material, this.worldSizeParams.worldHeight, this.viewDistance)
+    this.entityLightController = new EntityLightController({
+      getLight: (x, y, z) => this.rendererLightCache.getLight(x, y, z),
+      getSkyLevel: () => this.chunkMeshManager.getSkyLevel(),
+      getLightmapParams: () => this.chunkMeshManager.getLightmapParams(),
+      getColumnRevision: (cx, cz) => this.rendererLightCache.getColumnRevision(cx, cz),
+      getGlobalRevision: () => this.rendererLightCache.getGlobalRevision(),
+      lightingEnabled: () => this.worldRendererConfig.enableLighting !== false
+    })
     this.onRenderDistanceChanged = viewDistance => {
       this.chunkMeshManager.updateViewDistance(viewDistance)
     }
@@ -563,6 +575,9 @@ export class WorldRendererThree extends WorldRendererCommon {
       this.cursorBlock.setHighlightCursorBlock(value ? new Vec3(value.x, value.y, value.z) : null, value?.shapes)
     })
     this.onReactivePlayerStateUpdated('diggingBlock', value => {
+      if (value && (value.stage == null || value.stage === 0) && isClientLightTraceEnabled()) {
+        recordClientLightTrace({ phase: 'inputClick', sectionKey: `${value.x},${value.y},${value.z}` })
+      }
       this.cursorBlock.updateBreakAnimation(value ? { x: value.x, y: value.y, z: value.z } : undefined, value?.stage ?? null, value?.mergedShape)
     })
     this.onReactivePlayerStateUpdated('perspective', value => {
@@ -594,6 +609,13 @@ export class WorldRendererThree extends WorldRendererCommon {
     this.onReactiveConfigUpdated('futuristicReveal', () => {
       this.updateModulesFromConfig()
     })
+    this.onReactiveConfigUpdated(
+      'enableLighting',
+      () => {
+        this.rerenderAllChunks()
+      },
+      false
+    )
     this.onReactiveDebugUpdated('disableEntities', () => {
       this.entities.syncSceneAttachment()
     })
@@ -732,16 +754,20 @@ export class WorldRendererThree extends WorldRendererCommon {
   }
 
   timeUpdated(newTime: number): void {
-    // Update starfield module with time
-    const starfieldModule = this.getModule<any>('starfield')
-    if (starfieldModule?.updateTimeOfDay) {
-      starfieldModule.updateTimeOfDay(newTime)
+    for (const module of Object.values(this.modules)) {
+      ;(module.controller as { updateTimeOfDay?: (time: number) => void }).updateTimeOfDay?.(newTime)
     }
 
     this.skyboxRenderer.updateTime(newTime)
     this.syncSkyLevelFromTime(newTime)
   }
 
+  moonPhaseUpdated(phase: number): void {
+    for (const module of Object.values(this.modules)) {
+      ;(module.controller as { updateMoonPhase?: (phase: number) => void }).updateMoonPhase?.(phase)
+    }
+  }
+
   private syncSkyLevelFromTime(timeOfDay: number): void {
     const skyLevel = calculateSkyLightSimple(timeOfDay) / 15
     this.chunkMeshManager.setSkyLevel(skyLevel)
@@ -826,6 +852,10 @@ export class WorldRendererThree extends WorldRendererCommon {
         if (camCollisionBytes > 0) {
           text += `CAM: ${formatCompact(camCollisionBytes)}b `
         }
+        const entityLightBytes = this.rendererLightCache.getAllocatedBytes()
+        if (entityLightBytes > 0) {
+          text += `ELIGHT: ${formatCompact(entityLightBytes)}b `
+        }
         const pf = formatPerformanceFactorsDebug(this.reactiveState.world.instabilityFactors)
         if (pf) text += `PF: ${pf} `
         // entities can be seen in F3
@@ -880,45 +910,37 @@ export class WorldRendererThree extends WorldRendererCommon {
     if (this.pendingSectionUpdates.size === 0) return
 
     const now = performance.now()
-    const sectionHeight = this.getSectionHeight()
-    const ready: string[] = []
-
-    for (const key of this.pendingSectionUpdates.keys()) {
-      const startedAt = this.pendingSectionBufferStartTimes.get(key) ?? now
-      const sinceFirst = now - startedAt
-
-      if (sinceFirst < WorldRendererThree.MAX_SECTION_UPDATE_BUFFER_MS) {
-        // Still within this section's grace window — wait if any neighbor is
-        // currently being re-meshed so we don't briefly expose a hole between
-        // the just-updated section and a stale neighbor (sky-flicker bug).
-        const [sx, sy, sz] = key.split(',').map(Number)
-        const neighborKeys = [
-          `${sx - 16},${sy},${sz}`,
-          `${sx + 16},${sy},${sz}`,
-          `${sx},${sy - sectionHeight},${sz}`,
-          `${sx},${sy + sectionHeight},${sz}`,
-          `${sx},${sy},${sz - 16}`,
-          `${sx},${sy},${sz + 16}`
-        ]
-        let neighborBusy = false
-        for (const neighborKey of neighborKeys) {
-          if (this.sectionsWaiting.has(neighborKey) && !this.pendingSectionUpdates.has(neighborKey) && this.sectionObjects[neighborKey]) {
-            neighborBusy = true
-            break
+    // Face-adjacent buffered sections are installed as one group: a lone
+    // install would show the neighbour's faces still culled against the old
+    // block state, i.e. a see-through hole (sky flash) on dig/place.
+    const ready = selectReadySectionFlushes({
+      pendingKeys: this.pendingSectionUpdates.keys(),
+      startedAt: key => this.pendingSectionBufferStartTimes.get(key),
+      now,
+      maxBufferMs: WorldRendererThree.MAX_SECTION_UPDATE_BUFFER_MS,
+      sectionHeight: this.getSectionHeight(),
+      isOutstanding: key => this.sectionsWaiting.has(key) && !this.pendingSectionUpdates.has(key),
+      ...(this.lightCoordinator.isSessionLive()
+        ? {
+            isTopologyOutstanding: (key: string) => this.lightCoordinator.pendingTopologyBySection.has(key) && !this.pendingSectionUpdates.has(key)
           }
-        }
-        if (neighborBusy) continue
-      }
-
-      ready.push(key)
-    }
+        : {}),
+      hasSectionObject: key => !!this.sectionObjects[key]
+    })
 
     if (ready.length === 0) return
 
-    for (const key of ready) {
+    for (const { key, reason } of ready) {
       const update = this.pendingSectionUpdates.get(key)!
       this.pendingSectionUpdates.delete(key)
       this.pendingSectionBufferStartTimes.delete(key)
+      if (isClientLightTraceEnabled()) {
+        recordClientLightTrace({
+          phase: 'flush',
+          sectionKey: key,
+          flushReason: reason
+        })
+      }
 
       const chunkCoords = update.key.split(',')
       const chunkKey = `${chunkCoords[0]},${chunkCoords[2]}`
@@ -928,6 +950,14 @@ export class WorldRendererThree extends WorldRendererCommon {
         continue
       }
 
+      const decision = this.lightCoordinator.evaluateOwnerGeometry(update)
+      if (!decision.accepted || update.geometry?.hadErrors) {
+        this.lightCoordinator.noteRejectedOwnerGeometry(update.key, undefined, { expectLaterFinished: false })
+        continue
+      }
+      this.lightCoordinator.acknowledgeAcceptedTopology(update)
+      if (decision.keepCovering) this.lightCoordinator.maybeDispatchCoveringRemesh(update.key)
+
       if (!this.chunkMeshManager.sectionHasRenderableContent(update.geometry)) {
         this.chunkMeshManager.releaseSection(update.key)
         continue
@@ -962,6 +992,14 @@ export class WorldRendererThree extends WorldRendererCommon {
         return
       }
 
+      const decision = this.lightCoordinator.evaluateOwnerGeometry(data)
+      if (!decision.accepted || data.geometry?.hadErrors) {
+        this.lightCoordinator.noteRejectedOwnerGeometry(data.key, undefined, { expectLaterFinished: true })
+        return
+      }
+      this.lightCoordinator.acknowledgeAcceptedTopology(data)
+      if (decision.keepCovering) this.lightCoordinator.maybeDispatchCoveringRemesh(data.key)
+
       if (this.sectionObjects[data.key]) {
         this.pendingSectionUpdates.set(data.key, data)
         // Per-section deadline: only set if we don't already have one, so
@@ -969,6 +1007,13 @@ export class WorldRendererThree extends WorldRendererCommon {
         if (!this.pendingSectionBufferStartTimes.has(data.key)) {
           this.pendingSectionBufferStartTimes.set(data.key, performance.now())
         }
+        if (isClientLightTraceEnabled()) {
+          recordClientLightTrace({
+            phase: 'pending',
+            sectionKey: data.key,
+            queueDepth: this.pendingSectionUpdates.size
+          })
+        }
         return
       }
 
@@ -1325,7 +1370,7 @@ export class WorldRendererThree extends WorldRendererCommon {
 
     // Update skybox position to follow camera
     const cameraPos = this.getCameraPosition()
-    this.skyboxRenderer.update(cameraPos, this.viewDistance)
+    this.skyboxRenderer.update(cameraPos, this.viewDistance, deltaTime)
 
     this.updateSmoothFov()
     if (sizeChanged) {
@@ -1548,8 +1593,8 @@ export class WorldRendererThree extends WorldRendererCommon {
     }
   }
 
-  removeColumn(x, z) {
-    super.removeColumn(x, z)
+  removeColumn(x, z, opts?: { preserveClientLight?: boolean }) {
+    super.removeColumn(x, z, opts)
 
     this.clearPendingSectionUpdatesForChunk(x, z)
     const sectionHeight = this.getSectionHeight()

package/src/wasm-mesher/bridge/render-from-wasm.ts

@@ -3,6 +3,7 @@
 // This file takes WASM output and generates full Three.js buffer geometry
 
 import * as THREE from 'three'
+import { isClientLightProbeBlock } from '../../lighting/debug/clientLightProbe'
 import worldBlockProviderModule, { WorldBlockProvider } from 'mc-assets/dist/worldBlockProvider'
 import blocksAtlasesJson from 'mc-assets/dist/blocksAtlases.json'
 import blockStatesModels from 'mc-assets/dist/blockStatesModels.json'
@@ -692,7 +693,26 @@ export function renderWasmOutputToGeometry(
           },
           shaderWordBuffer
         )
-        if (emitted) continue
+        if (emitted) {
+          if (isClientLightProbeBlock(bx, by, bz)) {
+            console.log('[lightProbe:shaderCube]', {
+              time: Date.now(),
+              position: [bx, by, bz],
+              blockStateId,
+              name: prismBlock.name,
+              useModelLighting: false,
+              wasmSky: block.sky_light_data?.map(values => [...values]),
+              visibleFaces: block.visible_faces,
+              jsNeighborSky: Object.fromEntries(
+                Object.entries(elemFaces).map(([face, info]) => [
+                  face,
+                  world?.getChannelLightNorm(new Vec3(bx, by, bz).offset(info.dir[0], info.dir[1], info.dir[2])).sky
+                ])
+              )
+            })
+          }
+          continue
+        }
       }
     }
 
@@ -842,6 +862,20 @@ export function renderWasmOutputToGeometry(
           const tint = getTint(matchingEFace, cachedModel.blockName, cachedModel.blockProps, biome, world)
 
           const useModelLighting = (!cachedModel.isCube || globalMatrix != null) && world
+          if (isClientLightProbeBlock(bx, by, bz)) {
+            console.log('[lightProbe:face]', {
+              time: Date.now(),
+              position: [bx, by, bz],
+              faceName,
+              blockStateId,
+              name: prismBlock.name,
+              isCube: cachedModel.isCube,
+              rotated: globalMatrix != null,
+              useModelLighting: Boolean(useModelLighting),
+              wasmSky: skyValuesRaw ? [...skyValuesRaw] : null,
+              jsNeighborSky: world?.getChannelLightNorm(new Vec3(bx, by, bz).offset(...transformedDirI)).sky
+            })
+          }
           const baseChannels = useModelLighting
             ? world.getChannelLightNorm(new Vec3(bx, by, bz).offset(transformedDirI[0], transformedDirI[1], transformedDirI[2]))
             : null
@@ -921,6 +955,17 @@ export function renderWasmOutputToGeometry(
             tgtCol.push(tintAo[0], tintAo[1], tintAo[2])
             tgtSky.push(skyLightNorm)
             tgtBlock.push(blockLightNorm)
+            if (isClientLightProbeBlock(bx, by, bz)) {
+              console.log('[lightProbe:vertex]', {
+                time: Date.now(),
+                position: [bx, by, bz],
+                faceName,
+                cornerIdx,
+                useModelLighting: Boolean(useModelLighting),
+                skyLightNorm,
+                blockLightNorm
+              })
+            }
 
             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

package/src/wasm-mesher/runtime-build/wasm_mesher.d.ts

@@ -2,6 +2,21 @@
 /* tslint:disable */
 /* eslint-disable */
 
+export class JsLightEngine {
+  free(): void;
+  [Symbol.dispose](): void;
+  pushEvent(event: any): void;
+  getSkyLight(x: number, y: number, z: number): number;
+  getBlockLight(x: number, y: number, z: number): number;
+  setLightTables(emission: Uint8Array, opacity: Uint8Array): void;
+  setOcclusionTable(occupancy: Uint8Array): void;
+  setSkyLightEnabled(enabled: boolean): void;
+  pollCompletedPublication(): any;
+  step(budget_ms: number): boolean;
+  constructor(world_min_y: number, world_height: number);
+  readonly fallbackRelights: number;
+}
+
 /**
  * Compute wireframe edge positions from a triangle mesh.
  *
@@ -210,11 +225,11 @@ export function parseMapChunkV18Plus(raw_packet: Uint8Array, num_sections: numbe
  * `raw_packet` includes the leading packet-id varint (we skip it).
  * `num_sections` should match the column the light is for (16 in 1.17).
  *
- * Returns `{ x, z, skyLight: Uint8Array(num_sections * 4096),
- *            blockLight: Uint8Array(num_sections * 4096), bytesRead }`.
- * Layout matches the existing 1.18+ light arrays
- * (`x + z*16 + y_abs*256`); the JS-side worker reorders into per-section
- * stack via the same path used for 1.18+ raw map_chunk parsing.
+ * Returns `{ x, z, trustEdges, skyLight, blockLight, skyLightMask,
+ *            emptySkyLightMask, blockLightMask, emptyBlockLightMask,
+ *            skyBelow?, skyAbove?, blockBelow?, blockAbove?, bytesRead }`.
+ * World arrays are `num_sections * 4096` (`x + z*16 + y_abs*256`).
+ * Omitted sections are left 0 and are not authoritative — use the masks.
  */
 export function parseUpdateLightV17(raw_packet: Uint8Array, num_sections: number): any;
 
@@ -227,6 +242,7 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
+  readonly __wbg_jslightengine_free: (a: number, b: number) => void;
   readonly computeWireframeEdges: (a: number, b: number, c: number, d: number) => [number, number];
   readonly computeWireframeEdgesU16: (a: number, b: number, c: number, d: number) => [number, number];
   readonly generateGeometryFromDump118: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number, h1: number, i1: number, j1: number, k1: number) => any;
@@ -236,6 +252,16 @@ export interface InitOutput {
   readonly generateGeometryFromParsedV16V17Multi: (a: any, b: number, c: number, d: number, e: number, f: number, g: any, h: number, i: any, j: any, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number, h1: number) => any;
   readonly generate_geometry: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number) => any;
   readonly generate_geometry_multi: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number) => any;
+  readonly jslightengine_fallbackRelights: (a: number) => number;
+  readonly jslightengine_getBlockLight: (a: number, b: number, c: number, d: number) => number;
+  readonly jslightengine_getSkyLight: (a: number, b: number, c: number, d: number) => number;
+  readonly jslightengine_js_new: (a: number, b: number) => number;
+  readonly jslightengine_pollCompletedPublication: (a: number) => any;
+  readonly jslightengine_pushEvent: (a: number, b: any) => void;
+  readonly jslightengine_setLightTables: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly jslightengine_setOcclusionTable: (a: number, b: number, c: number) => void;
+  readonly jslightengine_setSkyLightEnabled: (a: number, b: number) => void;
+  readonly jslightengine_step: (a: number, b: number) => number;
   readonly parseChunkDump118: (a: number, b: number, c: number, d: number, e: number) => any;
   readonly parseChunkDump118FullColumn: (a: number, b: number, c: number, d: number, e: number) => any;
   readonly parseChunkDump118FullColumnAll: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number) => any;