minecraft-renderer 0.1.70 → 0.1.72

package/package.json

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

package/src/graphicsBackend/rendererDefaultOptions.ts

@@ -166,8 +166,8 @@ export const RENDERER_OPTIONS_META: Partial<Record<RendererDefaultOptionKey, Ren
   },
   rendererWorldPerformance: {
     text: 'World performance',
-    tooltip: 'Background workers for chunk geometry. Reload to apply.',
-    requiresRestart: true,
+    tooltip: 'Background workers for chunk geometry. Recreates mesher workers and reloads chunks.',
+    requiresChunksReload: true,
     possibleValues: [
       ['low-energy', 'Low Energy'],
       ['normal', 'Normal'],
@@ -193,8 +193,8 @@ export const RENDERER_OPTIONS_META: Partial<Record<RendererDefaultOptionKey, Ren
   rendererMesher: {
     possibleValues: [['wasm', 'WASM'], ['legacy-js', 'Legacy JS']],
     text: 'Mesher pipeline',
-    tooltip: 'WASM is faster. Use JS if WASM is not working. Requires reload.',
-    requiresRestart: true
+    tooltip: 'Browser technology for processing world geometry before render. WASM is the fastest; if you see a dead tab icon, reloads, or other errors, switch to Legacy JS.',
+    requiresChunksReload: true,
   },
   rendererShaderCubeBlocks: {
     text: '(UNSTABLE) Instanced shader cubes',

package/src/lib/worldrendererCommon.reconfigure.test.ts

@@ -0,0 +1,202 @@
+//@ts-nocheck
+import { EventEmitter } from 'events'
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+import { Vec3 } from 'vec3'
+import { proxy } from 'valtio'
+import * as worldRendererModule from './worldrendererCommon'
+import { WorldRendererCommon } from './worldrendererCommon'
+import { defaultWorldRendererConfig } from '../graphicsBackend/config'
+import { getInitialPlayerState } from '../playerState/playerState'
+import type { DisplayWorldOptions, GraphicsInitOptions } from '../graphicsBackend/types'
+
+vi.mock('./ui/newStats', () => ({
+  addNewStat: vi.fn(() => ({ updateText: vi.fn(), setVisibility: vi.fn() })),
+  updateStatText: vi.fn(),
+  removeAllStats: vi.fn(),
+  updatePanesVisibility: vi.fn(),
+  MC_RENDERER_DEBUG_OVERLAY_CLASS: 'mc-renderer-debug-overlay',
+}))
+
+vi.mock('./utils/skins', () => ({
+  setSkinsConfig: vi.fn(),
+  steveTexture: {},
+  stevePngUrl: '',
+}))
+
+function ensurePromiseWithResolvers() {
+  if (!Promise.withResolvers) {
+    Promise.withResolvers = function <T>() {
+      let resolve!: (value: T | PromiseLike<T>) => void
+      let reject!: (reason?: unknown) => void
+      const promise = new Promise<T>((res, rej) => {
+        resolve = res
+        reject = rej
+      })
+      return { promise, resolve, reject }
+    }
+  }
+}
+
+class TestWorldRenderer extends WorldRendererCommon {
+  outputFormat = 'threeJs' as const
+
+  changeBackgroundColor() {}
+  changeCardinalLight() {}
+  handleWorkerMessage() {}
+  updateCamera() {}
+  render() {}
+  updateShowChunksBorder() {}
+}
+
+function createRenderer(workerCount = 2, worldView?: DisplayWorldOptions['worldView']) {
+  const reloadLoadedChunks = vi.fn(async () => {})
+  const rendererState = proxy({
+    world: {
+      chunksLoaded: {} as Record<string, true>,
+      heightmaps: {} as Record<string, Int16Array>,
+      allChunksLoaded: false,
+      mesherWork: false,
+      instabilityFactors: {},
+      intersectMedia: null,
+    },
+    renderer: '',
+    preventEscapeMenu: false,
+  })
+
+  const displayOptions: DisplayWorldOptions = {
+    version: '1.21.1',
+    worldView: (worldView ?? Object.assign(new EventEmitter(), { reloadLoadedChunks })) as DisplayWorldOptions['worldView'],
+    inWorldRenderingConfig: proxy({ ...defaultWorldRendererConfig, mesherWorkers: workerCount }),
+    playerStateReactive: getInitialPlayerState(),
+    rendererState,
+    nonReactiveState: {
+      fps: 0,
+      worstRenderTime: 0,
+      avgRenderTime: 0,
+      world: {
+        chunksLoadedCount: 0,
+        chunksTotalNumber: 0,
+        chunksFullInfo: '',
+      },
+      renderer: {
+        timeline: { live: [], frozen: [], lastSecond: [] },
+      },
+    },
+    resourcesManager: {
+      currentResources: {
+        mcData: { version: {} },
+        blocksAtlasJson: {},
+        blockstatesModels: {},
+      },
+    } as DisplayWorldOptions['resourcesManager'],
+  }
+
+  const initOptions: GraphicsInitOptions = {
+    config: { sceneBackground: '#000' },
+    rendererSpecificSettings: {},
+    callbacks: {
+      displayCriticalError: vi.fn(),
+      setRendererSpecificSettings: vi.fn(),
+      fireCustomEvent: vi.fn(),
+    },
+  }
+
+  const renderer = new TestWorldRenderer(displayOptions.resourcesManager, displayOptions, initOptions)
+  renderer.active = true
+  renderer.workers = Array.from({ length: workerCount }, () => ({
+    postMessage: vi.fn(),
+    terminate: vi.fn(),
+  }))
+  renderer['syncMesherPoolSnapshot']()
+  renderer.viewDistance = 8
+  renderer.viewerChunkPosition = new Vec3(0, 64, 0)
+  renderer.worldSizeParams = { minY: 0, worldHeight: 256 }
+  return { renderer, reloadLoadedChunks }
+}
+
+describe('WorldRendererCommon.reconfigureMesherWorkers', () => {
+  beforeEach(() => {
+    ensurePromiseWithResolvers()
+    vi.stubGlobal('location', { href: 'http://localhost/' })
+    vi.stubGlobal('Worker', class MockWorker {
+      postMessage = vi.fn()
+      terminate = vi.fn()
+      addEventListener = vi.fn()
+      onmessage: ((event: MessageEvent) => void) | null = null
+    })
+    vi.spyOn(worldRendererModule, 'meshersSendMcData').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+    vi.unstubAllGlobals()
+  })
+
+  test('recreates workers with new count and reloads chunks', async () => {
+    const { renderer, reloadLoadedChunks } = createRenderer(3)
+    const terminated = renderer.workers.map((worker) => worker.terminate)
+    renderer.worldRendererConfig.mesherWorkers = 1
+
+    await renderer.reconfigureMesherWorkers()
+
+    for (const terminate of terminated) {
+      expect(terminate).toHaveBeenCalled()
+    }
+    expect(renderer.workers).toHaveLength(1)
+    expect(reloadLoadedChunks).toHaveBeenCalledTimes(1)
+  })
+
+  test('recreates workers when mesher pipeline changes', async () => {
+    const { renderer, reloadLoadedChunks } = createRenderer(2)
+    const terminated = renderer.workers.map((worker) => worker.terminate)
+    renderer.worldRendererConfig.wasmMesher = false
+
+    await renderer.reconfigureMesherWorkers()
+
+    for (const terminate of terminated) {
+      expect(terminate).toHaveBeenCalled()
+    }
+    expect(renderer.workers).toHaveLength(2)
+    expect(reloadLoadedChunks).toHaveBeenCalledTimes(1)
+  })
+
+  test('watchMesherPoolConfig registers valtio unsubscribe functions', () => {
+    const { renderer } = createRenderer(2)
+
+    renderer['watchMesherPoolConfig']()
+    expect(renderer['valtioUnsubs']).toHaveLength(3)
+    for (const unsub of renderer['valtioUnsubs']) {
+      expect(typeof unsub).toBe('function')
+    }
+
+    expect(() => {
+      for (const unsub of renderer['valtioUnsubs']) unsub()
+      renderer.destroy()
+    }).not.toThrow()
+  })
+
+  test('config watcher enqueues reconfigure when mesherWorkers changes', async () => {
+    const enqueueSpy = vi.spyOn(TestWorldRenderer.prototype as any, 'enqueueMesherWorkersReconfigure')
+    const { renderer } = createRenderer(2)
+
+    renderer['watchMesherPoolConfig']()
+    renderer.worldRendererConfig.mesherWorkers = 4
+
+    await vi.waitFor(() => {
+      expect(enqueueSpy).toHaveBeenCalled()
+    })
+
+    enqueueSpy.mockRestore()
+  })
+
+  test('skips tail work when destroyed during bootstrap', async () => {
+    const { renderer, reloadLoadedChunks } = createRenderer(2)
+    vi.spyOn(renderer, 'updateAssetsData').mockImplementation(async () => {
+      renderer.active = false
+    })
+
+    await renderer.reconfigureMesherWorkers()
+
+    expect(reloadLoadedChunks).not.toHaveBeenCalled()
+  })
+})

package/src/lib/worldrendererCommon.ts

@@ -127,6 +127,12 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
   debugStopGeometryUpdate = false
 
   protocolCustomBlocks = new Map<string, CustomBlockModels>()
+  private mesherPoolSnapshot = {
+    mesherWorkers: -1,
+    wasmMesher: false,
+    dedicatedChangeWorker: false,
+  }
+  private mesherReconfigureQueue: Promise<void> = Promise.resolve()
   private heightmapDebounceTimers = new Map<string, ReturnType<typeof setTimeout>>()
 
   // Geometry throttle: first dirty per section is instant, subsequent within window are grouped
@@ -272,6 +278,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
 
     this.watchReactivePlayerState()
     this.watchReactiveConfig()
+    this.watchMesherPoolConfig()
     this.worldReadyResolvers.resolve()
   }
 
@@ -309,18 +316,127 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
     }
   }
 
+  private getMesherWorkerScript(): 'wasm' | 'legacy' {
+    return this.worldRendererConfig.wasmMesher ? 'wasm' : 'legacy'
+  }
+
+  private createMesherWorker() {
+    const script = this.getMesherWorkerScript()
+    return initMesherWorker((data) => {
+      if (Array.isArray(data)) {
+        this.messageQueue.push(...data)
+      } else {
+        this.messageQueue.push(data)
+      }
+      void this.processMessageQueue('worker')
+    }, script === 'wasm' ? 'mesherWasm.js' : 'mesher.js')
+  }
+
   initWorkers(numWorkers = this.worldRendererConfig.mesherWorkers) {
-    // init workers
-    for (let i = 0; i < numWorkers + 0; i++) {
-      const worker = initMesherWorker((data) => {
-        if (Array.isArray(data)) {
-          this.messageQueue.push(...data)
-        } else {
-          this.messageQueue.push(data)
-        }
-        void this.processMessageQueue('worker')
-      }, this.worldRendererConfig.wasmMesher ? 'mesherWasm.js' : 'mesher.js')
-      this.workers.push(worker)
+    for (let i = 0; i < numWorkers; i++) {
+      this.workers.push(this.createMesherWorker())
+    }
+  }
+
+  private syncMesherPoolSnapshot() {
+    this.mesherPoolSnapshot = {
+      mesherWorkers: this.worldRendererConfig.mesherWorkers,
+      wasmMesher: this.worldRendererConfig.wasmMesher,
+      dedicatedChangeWorker: this.worldRendererConfig.dedicatedChangeWorker,
+    }
+  }
+
+  private watchMesherPoolConfig() {
+    this.syncMesherPoolSnapshot()
+
+    const tryReconfigure = () => {
+      const cfg = this.worldRendererConfig
+      const snap = this.mesherPoolSnapshot
+      if (
+        cfg.mesherWorkers === snap.mesherWorkers &&
+        cfg.wasmMesher === snap.wasmMesher &&
+        cfg.dedicatedChangeWorker === snap.dedicatedChangeWorker
+      ) {
+        return
+      }
+      this.syncMesherPoolSnapshot()
+      this.enqueueMesherWorkersReconfigure()
+    }
+
+    for (const key of ['mesherWorkers', 'wasmMesher', 'dedicatedChangeWorker'] as const) {
+      this.valtioUnsubs.push(
+        this.onReactiveConfigUpdated(key, tryReconfigure, false)
+      )
+    }
+  }
+
+  private enqueueMesherWorkersReconfigure() {
+    this.mesherReconfigureQueue = this.mesherReconfigureQueue
+      .then(() => this.reconfigureMesherWorkers())
+      .catch((err) => {
+        console.error('[Mesher] Failed to reconfigure workers:', err)
+      })
+  }
+  private clearMesherPendingState() {
+    this.sectionsWaiting.clear()
+    this.toWorkerMessagesQueue = {}
+    this.queueAwaited = false
+    this.messageQueue = []
+    this.isProcessingQueue = false
+    for (const timer of this.sectionDirtyTimers.values()) {
+      clearTimeout(timer)
+    }
+    this.sectionDirtyTimers.clear()
+    this.sectionDirtyCount.clear()
+    this.sectionDirtyPendingArgs.clear()
+    this.reactiveState.world.mesherWork = false
+  }
+
+  private terminateAllMesherWorkers() {
+    for (const worker of this.workers) {
+      worker.terminate()
+    }
+    this.workers = []
+  }
+
+  private async bootstrapMesherWorkers() {
+    if (this.workers.length === 0) return
+
+    this.sendMesherMcData()
+    await this.updateAssetsData()
+    this.logWorkerWork('# mesher workers bootstrapped')
+  }
+
+  async reconfigureMesherWorkers() {
+    if (!this.active) return
+
+    this.clearMesherPendingState()
+    this.terminateAllMesherWorkers()
+    this.initWorkers()
+    await this.bootstrapMesherWorkers()
+    if (!this.active) return
+
+    await this.requestLoadedChunksReload()
+  }
+
+  private async requestLoadedChunksReload() {
+    try {
+      const worldView = this.displayOptions.worldView as {
+        reloadLoadedChunks?: () => void | Promise<void>
+      }
+
+      if (typeof worldView.reloadLoadedChunks === 'function') {
+        await worldView.reloadLoadedChunks()
+        return
+      }
+
+      const workerScope = globalThis as typeof globalThis & { WorkerGlobalScope?: typeof WorkerGlobalScope }
+      if (typeof workerScope.WorkerGlobalScope !== 'undefined' && globalThis instanceof workerScope.WorkerGlobalScope) {
+        // eslint-disable-next-line no-restricted-globals
+        self.postMessage({ type: 'reloadLoadedChunks' })
+      }
+    } catch (err) {
+      console.error('[Mesher] Failed to reload chunks after worker reconfigure:', err)
     }
   }
 
@@ -331,13 +447,18 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
     return subscribeKey(this.playerStateReactive, key, callback)
   }
 
-  onReactiveConfigUpdated<T extends keyof typeof this.worldRendererConfig>(key: T, callback: (value: typeof this.worldRendererConfig[T]) => void) {
-    callback(this.worldRendererConfig[key])
+  onReactiveConfigUpdated<T extends keyof typeof this.worldRendererConfig>(
+    key: T,
+    callback: (value: typeof this.worldRendererConfig[T]) => void,
+    initial = true
+  ) {
+    if (initial) {
+      callback(this.worldRendererConfig[key])
+    }
     if ((key as any) === '*') {
-      subscribe(this.worldRendererConfig, callback as any)
-    } else {
-      subscribeKey(this.worldRendererConfig, key, callback)
+      return subscribe(this.worldRendererConfig, callback as any)
     }
+    return subscribeKey(this.worldRendererConfig, key, callback)
   }
 
   onReactiveDebugUpdated<T extends keyof typeof this.reactiveDebugParams>(key: T, callback: (value: typeof this.reactiveDebugParams[T]) => void) {
@@ -637,6 +758,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
 
     this.initWorkers()
     this.active = true
+    this.syncMesherPoolSnapshot()
 
     this.sendMesherMcData()
   }

package/src/three/entities.ts

@@ -271,46 +271,6 @@ export class Entities {
   itemFrameMaps = {} as Record<number, Array<THREE.Mesh<THREE.PlaneGeometry, THREE.MeshLambertMaterial>>>
   pendingModelOverrides = new Map<string, { parts: EntityModelOverridePart[] }>()
 
-  private motionCache = new Map<string, { pos: THREE.Vector3, speed: number }>()
-  private readonly MOVE_ON = 0.05
-  private readonly MOVE_OFF = 0.02
-  private readonly RUN_ON = 4.8
-  private readonly RUN_OFF = 4.2
-
-  private updateAutoWalkFlags(entityKey: string, entity: SceneEntity, dt: number) {
-    if (!entity.playerObject?.animation) return
-    const anim: any = entity.playerObject.animation
-    if (!('isMoving' in anim) || !('isRunning' in anim)) return
-    if (dt <= 0) return
-
-    const cached = this.motionCache.get(entityKey)
-    if (!cached) {
-      this.motionCache.set(entityKey, { pos: entity.position.clone(), speed: 0 })
-      anim.isMoving = false
-      anim.isRunning = false
-      return
-    }
-
-    const dx = entity.position.x - cached.pos.x
-    const dz = entity.position.z - cached.pos.z
-    cached.pos.copy(entity.position)
-
-    const instSpeed = Math.hypot(dx, dz) / Math.max(dt, 1e-6)
-
-    cached.speed = cached.speed * 0.8 + instSpeed * 0.2
-
-    const movingNow = anim.isMoving
-      ? cached.speed > this.MOVE_OFF
-      : cached.speed > this.MOVE_ON
-
-    const runningNow = anim.isRunning
-      ? cached.speed > this.RUN_OFF
-      : cached.speed > this.RUN_ON
-
-    anim.isMoving = movingNow
-    anim.isRunning = movingNow && runningNow
-  }
-
   get entitiesByName(): Record<string, SceneEntity[]> {
     const byName: Record<string, SceneEntity[]> = {}
     for (const entity of Object.values(this.entities)) {
@@ -383,8 +343,6 @@ export class Entities {
     this.entities = {}
     this.currentSkinUrls = {}
 
-    this.motionCache.clear()
-
     // Clean up player entity
     if (this.playerEntity) {
       this.worldRenderer.sceneOrigin.removeAndUntrack(this.playerEntity)
@@ -447,15 +405,13 @@ export class Entities {
       this.setRendering(renderEntitiesConfig)
     }
 
-    const dtRaw = this.clock.getDelta()
-    const dt = Math.min(dtRaw, 1 / 30)
+    const dt = Math.min(this.clock.getDelta(), 1 / 30)
     const botPos = this.worldRenderer.viewerChunkPosition
     const VISIBLE_DISTANCE = 10 * 10
 
     for (const [entityIdRaw, entity] of [...Object.entries(this.entities), ['player_entity', this.playerEntity] as [string, SceneEntity | null]]) {
       if (!entity) continue
 
-      let entityKey = entityIdRaw
       const isPlayerEntity = entityIdRaw === 'player_entity'
 
       if (isPlayerEntity) {
@@ -470,14 +426,10 @@ export class Entities {
             this.worldRenderer.cameraWorldPos.z
           )
         }
-
-        entityKey = String(this.playerEntity?.originalEntity.id ?? 'player_entity')
       }
 
       const { playerObject } = entity
 
-      this.updateAutoWalkFlags(entityKey, entity, dtRaw)
-
       if (playerObject?.animation) {
         playerObject.animation.update(playerObject, dt)
       }
@@ -778,84 +730,31 @@ export class Entities {
     }
   }
 
-  playAnimation(entityPlayerId, animation: 'walking' | 'running' | 'oneSwing' | 'idle' | 'crouch' | 'crouchWalking') {
-    // TODO CLEANUP!
-    // Handle special player entity ID for bot entity in third person
-    const key = String(entityPlayerId)
-    // `oneSwing` is a one-shot event, not a persistent state: two swings in a row
-    // are both 'oneSwing', so deduping by name would swallow every repeat swing
-    // while standing still. Only dedupe the persistent state animations.
-    if (animation !== 'oneSwing') {
-      if (this.playerPerAnimation[key] === animation) return
-      this.playerPerAnimation[key] = animation
-    }
-
-    if (entityPlayerId === 'player_entity' && this.playerEntity?.playerObject) {
-      const { playerObject } = this.playerEntity
-      if (animation === 'oneSwing') {
-        if (playerObject.animation && (playerObject.animation as any).swingArm) {
-          (playerObject.animation as any).swingArm()
-        }
-        return
-      }
+  private applyMovementAnimation(
+    playerObject: PlayerObjectType,
+    animation: 'walking' | 'running' | 'oneSwing' | 'idle' | 'crouch' | 'crouchWalking',
+  ): void {
+    const anim = playerObject.animation as WalkingGeneralSwing | undefined
+    if (!anim) return
 
-      if (playerObject.animation && (playerObject.animation as any).switchAnimationCallback !== undefined) {
-        (playerObject.animation as any).switchAnimationCallback = () => {
-          const anim = playerObject.animation as any
-          if (anim) {
-            anim.isMoving = animation === 'walking' || animation === 'running' || animation === 'crouchWalking'
-            anim.isRunning = animation === 'running'
-            anim.isCrouched = animation === 'crouch' || animation === 'crouchWalking'
-          }
-        }
-      }
+    if (animation === 'oneSwing') {
+      anim.swingArm()
       return
     }
 
-    // Handle regular entities
-    const playerObject = this.getPlayerObject(entityPlayerId)
-    if (playerObject) {
-      if (animation === 'oneSwing') {
-        if (playerObject.animation && (playerObject.animation as any).swingArm) {
-          (playerObject.animation as any).swingArm()
-        }
-        return
-      }
-
-      if (playerObject.animation && (playerObject.animation as any).switchAnimationCallback !== undefined) {
-        (playerObject.animation as any).switchAnimationCallback = () => {
-          const anim = playerObject.animation as any
-          if (anim) {
-            anim.isMoving = animation === 'walking' || animation === 'running' || animation === 'crouchWalking'
-            anim.isRunning = animation === 'running'
-            anim.isCrouched = animation === 'crouch' || animation === 'crouchWalking'
-          }
-        }
-      }
-      return
-    }
+    anim.switchAnimationCallback = null
+    anim.isMoving = animation === 'walking' || animation === 'running' || animation === 'crouchWalking'
+    anim.isRunning = animation === 'running'
+    anim.isCrouched = animation === 'crouch' || animation === 'crouchWalking'
+  }
 
-    // Handle player entity (for third person view) - fallback for backwards compatibility
-    if (this.playerEntity?.playerObject) {
-      const { playerObject: playerEntityObject } = this.playerEntity
-      if (animation === 'oneSwing') {
-        if (playerEntityObject.animation && (playerEntityObject.animation as any).swingArm) {
-          (playerEntityObject.animation as any).swingArm()
-        }
-        return
-      }
+  playAnimation(entityPlayerId, animation: 'walking' | 'running' | 'oneSwing' | 'idle' | 'crouch' | 'crouchWalking') {
+    const playerObject = entityPlayerId === 'player_entity'
+      ? this.playerEntity?.playerObject
+      : this.getPlayerObject(entityPlayerId) ?? this.playerEntity?.playerObject
 
-      if (playerEntityObject.animation && (playerEntityObject.animation as any).switchAnimationCallback !== undefined) {
-        (playerEntityObject.animation as any).switchAnimationCallback = () => {
-          const anim = playerEntityObject.animation as any
-          if (anim) {
-            anim.isMoving = animation === 'walking' || animation === 'running' || animation === 'crouchWalking'
-            anim.isRunning = animation === 'running'
-            anim.isCrouched = animation === 'crouch' || animation === 'crouchWalking'
-          }
-        }
-      }
-    }
+    if (!playerObject) return
+    this.applyMovementAnimation(playerObject, animation)
   }
 
   parseEntityLabel(jsonLike) {
@@ -1340,11 +1239,9 @@ export class Entities {
     }
   }
 
-  playerPerAnimation = {} as Record<number, string>
   onRemoveEntity(entity: import('prismarine-entity').Entity) {
     this.loadedSkinEntityIds.delete(entity.id.toString())
     delete this.currentSkinUrls[entity.id.toString()]
-    this.motionCache.delete(entity.id.toString())
   }
 
   updateMap(mapNumber: string | number, data: string) {

package/src/three/graphicsBackendOffThread.ts

@@ -9,6 +9,7 @@ import type { MenuBackgroundOptions } from './menuBackground/types'
 import { MENU_BACKGROUND_MC_VERSION } from './menuBackground/shared'
 import { createGraphicsBackendBase, type ThreeJsBackendMethods } from './graphicsBackendBase'
 import { addCanvasForWorker } from './documentRenderer'
+import type { WorldView } from '../worldView'
 
 function initThreeWorker(onGotMessage: (data: any) => void) {
   // Node environment needs an absolute path, but browser needs the url of the file
@@ -31,7 +32,12 @@ function initThreeWorker(onGotMessage: (data: any) => void) {
 }
 
 export const createGraphicsBackendOffThread: GraphicsBackendLoader = async (initOptions) => {
-  const worker = initThreeWorker(() => { })
+  const workerSideChannel = {
+    onMessage: (_data: unknown) => {},
+  }
+  const worker = initThreeWorker((data) => {
+    workerSideChannel.onMessage(data)
+  })
   type WorkerType = ReturnType<ReturnType<typeof createGraphicsBackendBase>['workerProxy']>
 
   const proxy = useWorkerProxy<WorkerType>(worker)
@@ -79,6 +85,15 @@ export const createGraphicsBackendOffThread: GraphicsBackendLoader = async (init
       }
     },
     async startWorld(options) {
+      const worldView = options.worldView as unknown as WorldView
+      workerSideChannel.onMessage = (data: any) => {
+        if (data?.type === 'reloadLoadedChunks') {
+          void worldView.reloadLoadedChunks().catch((err) => {
+            console.error('[Renderer] Failed to reload chunks after mesher reconfigure:', err)
+          })
+        }
+      }
+
       const workerThreeSendData = {
         ...dynamicMcDataFiles,
         items: 'itemsArray',

package/src/worldView/worldView.ts

@@ -320,6 +320,17 @@ export class WorldView extends (EventEmitter as new () => TypedEmitter<WorldView
     }
   }
 
+  /**
+   * Re-fetch and re-emit every loaded chunk (e.g. after mesher workers are recreated).
+   */
+  async reloadLoadedChunks(): Promise<void> {
+    const coords = Object.keys(this.loadedChunks)
+    for (const key of coords) {
+      const [x, z] = key.split(',').map(Number)
+      await this.loadChunk({ x, z }, false, 'mesher-reconfigure')
+    }
+  }
+
   /**
    * Unload all chunks.
    */