minecraft-renderer 0.1.61 → 0.1.63

package/src/lib/workerSyncOps.test.ts

@@ -0,0 +1,154 @@
+//@ts-nocheck
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest'
+import { proxy, subscribe } from 'valtio'
+import { Vec3 } from 'vec3'
+import {
+  applySyncOps,
+  getWorkerSyncStatsForTest,
+  resetWorkerSyncStatsForTest,
+  sendWorkerSyncOps,
+  setByPath,
+  type WireSyncOp,
+} from './workerProxy'
+import { defaultPerformanceInstabilityFactors } from '../performanceMonitor'
+
+const fakeWorker = () => {
+  const listeners: Array<(event: { data: any }) => void> = []
+  return {
+    postMessage: vi.fn((data: any) => {
+      for (const listener of listeners) {
+        listener({ data })
+      }
+    }),
+    addEventListener: vi.fn((_type: string, listener: (event: { data: any }) => void) => {
+      listeners.push(listener)
+    }),
+    removeEventListener: vi.fn(),
+  } as unknown as Worker
+}
+
+const makeRendererState = () => proxy({
+  world: {
+    chunksLoaded: {} as Record<string, true>,
+    heightmaps: {} as Record<string, Int16Array>,
+    allChunksLoaded: false,
+    mesherWork: false,
+    instabilityFactors: defaultPerformanceInstabilityFactors(),
+    intersectMedia: null as null | object,
+  },
+  renderer: '...',
+  preventEscapeMenu: false,
+})
+
+describe('workerSyncOps', () => {
+  it('set op round-trips mesherWork', () => {
+    const source = makeRendererState()
+    const target = makeRendererState()
+    const ops: WireSyncOp[] = [{ kind: 'set', path: ['world', 'mesherWork'], value: true }]
+    applySyncOps(target, ops, fakeWorker())
+    expect(target.world.mesherWork).toBe(true)
+    expect(source.world.mesherWork).toBe(false)
+  })
+
+  it('top-level set round-trips renderer', () => {
+    const target = makeRendererState()
+    applySyncOps(target, [{ kind: 'set', path: ['renderer'], value: 'WebGL2 r123' }], fakeWorker())
+    expect(target.renderer).toBe('WebGL2 r123')
+  })
+
+  it('nested set creates chunksLoaded key on receiver', () => {
+    const target = makeRendererState()
+    applySyncOps(target, [{ kind: 'set', path: ['world', 'chunksLoaded', '1,2'], value: true }], fakeWorker())
+    expect(target.world.chunksLoaded['1,2']).toBe(true)
+  })
+
+  it('delete op removes heightmap key on receiver', () => {
+    const target = makeRendererState()
+    target.world.heightmaps['1,2'] = new Int16Array(256)
+    applySyncOps(target, [{ kind: 'delete', path: ['world', 'heightmaps', '1,2'] }], fakeWorker())
+    expect(target.world.heightmaps['1,2']).toBeUndefined()
+  })
+
+  it('Int16Array value survives copy without neutering sender buffer', () => {
+    const source = new Int16Array([1, 2, 3])
+    const sender = makeRendererState()
+    sender.world.heightmaps['0,0'] = source
+    const receiver = makeRendererState()
+    const buf = sender.world.heightmaps['0,0']!
+    applySyncOps(receiver, [{
+      kind: 'set',
+      path: ['world', 'heightmaps', '0,0'],
+      value: new Int16Array(buf),
+    }], fakeWorker())
+    expect([...receiver.world.heightmaps['0,0']!]).toEqual([1, 2, 3])
+    expect(sender.world.heightmaps['0,0']![0]).toBe(1)
+  })
+
+  it('Vec3 value survives via restorer', () => {
+    const target = makeRendererState() as any
+    const vec = new Vec3(1, 2, 3)
+    applySyncOps(target, [{
+      kind: 'set',
+      path: ['world', 'intersectMedia'],
+      value: { pos: { x: 1, y: 2, z: 3, __restorer: 'Vec3' } },
+    }], fakeWorker())
+    expect(target.world.intersectMedia.pos).toBeInstanceOf(Vec3)
+    expect(target.world.intersectMedia.pos.x).toBe(1)
+  })
+
+  it('batched ops in one tick produce one message with multiple ops', async () => {
+    const worker = fakeWorker()
+    const syncId = 'test-sync'
+    const source = makeRendererState()
+    let messageCount = 0
+    ;(worker.postMessage as ReturnType<typeof vi.fn>).mockImplementation((data: any) => {
+      messageCount++
+      expect(data.ops.length).toBeGreaterThanOrEqual(2)
+    })
+    await new Promise<void>((resolve) => {
+      subscribe(source, (ops) => {
+        sendWorkerSyncOps(syncId, ops, worker, 'toWorker', 'test')
+        resolve()
+      })
+      source.world.mesherWork = true
+      source.renderer = 'batch'
+    })
+    expect(messageCount).toBe(1)
+  })
+
+  describe('debugWorkerSyncStats', () => {
+    beforeEach(() => {
+      resetWorkerSyncStatsForTest()
+    })
+
+    afterEach(() => {
+      resetWorkerSyncStatsForTest()
+      vi.useRealTimers()
+    })
+
+    it('one postMessage increments toWorker by 1 regardless of op count', () => {
+      const worker = fakeWorker()
+      sendWorkerSyncOps('id', [
+        ['set', ['world', 'mesherWork'], true, false],
+        ['set', ['renderer'], 'x', '...'],
+      ], worker, 'toWorker', 'test')
+      expect(worker.postMessage).toHaveBeenCalledTimes(1)
+      expect(getWorkerSyncStatsForTest().toWorker).toBe(1)
+    })
+
+    it('applySyncOps with fromWorker counts one receive per message', () => {
+      const target = makeRendererState()
+      applySyncOps(target, [
+        { kind: 'set', path: ['world', 'mesherWork'], value: true },
+        { kind: 'set', path: ['renderer'], value: 'y' },
+      ], fakeWorker(), 'fromWorker')
+      expect(getWorkerSyncStatsForTest().fromWorker).toBe(1)
+    })
+  })
+
+  it('setByPath handles length-1 path', () => {
+    const target = { renderer: 'old' }
+    setByPath(target, ['renderer'], 'new')
+    expect(target.renderer).toBe('new')
+  })
+})

package/src/lib/worldrendererCommon.ts

@@ -19,6 +19,7 @@ import { MesherLogReader } from './mesherlogReader'
 import { setSkinsConfig } from './utils/skins'
 import { calculateSkyLightSimple } from './skyLight'
 import { WorldViewWorker } from '../worldView'
+import { bindAbortableEmitterListener, bindAbortableListener } from './bindAbortableListener'
 import { generateSpiralMatrix } from './spiral'
 import { PlayerStateReactive } from '../playerState/playerState'
 import { IndexedData } from 'minecraft-data'
@@ -170,6 +171,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
   stopMesherMessagesProcessing = false
 
   abortController = new AbortController()
+  private valtioUnsubs: Array<() => void> = []
   lastRendered = 0
   renderingActive = true
   geometryReceiveCountPerSec = 0
@@ -257,10 +259,16 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
       })()
     ])
 
-    this.resourcesManager.on('assetsTexturesUpdated', async () => {
+    const onAssetsTexturesUpdated = async () => {
       if (!this.active) return
       await this.updateAssetsData()
-    })
+    }
+    bindAbortableEmitterListener(
+      this.resourcesManager,
+      'assetsTexturesUpdated',
+      onAssetsTexturesUpdated,
+      this.abortController.signal
+    )
 
     this.watchReactivePlayerState()
     this.watchReactiveConfig()
@@ -338,18 +346,24 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
   }
 
   watchReactivePlayerState() {
-    this.onReactivePlayerStateUpdated('backgroundColor', (value) => {
-      this.changeBackgroundColor(value)
-    })
-    this.onReactivePlayerStateUpdated('cardinalLight', (value) => {
-      this.changeCardinalLight(value)
-    })
+    this.valtioUnsubs.push(
+      this.onReactivePlayerStateUpdated('backgroundColor', (value) => {
+        this.changeBackgroundColor(value)
+      })
+    )
+    this.valtioUnsubs.push(
+      this.onReactivePlayerStateUpdated('cardinalLight', (value) => {
+        this.changeCardinalLight(value)
+      })
+    )
   }
 
   watchReactiveConfig() {
-    this.onReactiveConfigUpdated('fetchPlayerSkins', (value) => {
-      setSkinsConfig({ apiEnabled: value })
-    })
+    this.valtioUnsubs.push(
+      this.onReactiveConfigUpdated('fetchPlayerSkins', (value) => {
+        setSkinsConfig({ apiEnabled: value })
+      })
+    )
   }
 
   async processMessageQueue(source: string) {
@@ -432,7 +446,8 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
           // CHUNK FINISHED
           this.finishedChunks[chunkKey] = true
           const CHUNK_SIZE = 16
-          this.reactiveState.world.chunksLoaded.add(`${Math.floor(chunkCoords[0] / CHUNK_SIZE)},${Math.floor(chunkCoords[2] / CHUNK_SIZE)}`)
+          const gridKey = `${Math.floor(chunkCoords[0] / CHUNK_SIZE)},${Math.floor(chunkCoords[2] / CHUNK_SIZE)}`
+          this.reactiveState.world.chunksLoaded[gridKey] = true
           this.renderUpdateEmitter.emit(`chunkFinished`, `${chunkCoords[0]},${chunkCoords[2]}`)
           this.checkAllFinished()
           // merge highest blocks by sections into highest blocks by chunks
@@ -513,7 +528,8 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
     }
 
     if (data.type === 'heightmap') {
-      this.reactiveState.world.heightmaps.set(data.key, new Int16Array(data.heightmap))
+      const heightmap = new Int16Array(data.heightmap)
+      this.reactiveState.world.heightmaps[data.key] = heightmap
     }
   }
 
@@ -684,7 +700,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
 
   updateChunksStats() {
     const loadedChunks = Object.keys(this.finishedChunks)
-    this.displayOptions.nonReactiveState.world.chunksLoaded = new Set(loadedChunks)
+    this.displayOptions.nonReactiveState.world.chunksLoadedCount = loadedChunks.length
     this.displayOptions.nonReactiveState.world.chunksTotalNumber = this.chunksLength
     this.reactiveState.world.allChunksLoaded = this.allChunksFinished
 
@@ -787,7 +803,8 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
       delete this.finishedSections[`${x},${y},${z}`]
     }
     this.highestBlocksByChunks.delete(`${x},${z}`)
-    this.reactiveState.world.heightmaps.delete(`${Math.floor(x / 16)},${Math.floor(z / 16)}`)
+    const heightmapKey = `${Math.floor(x / 16)},${Math.floor(z / 16)}`
+    delete this.reactiveState.world.heightmaps[heightmapKey]
 
     this.updateChunksStats()
 
@@ -826,22 +843,23 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
 
   connect(worldView: WorldViewWorker) {
     const worldEmitter = worldView
+    const signal = this.abortController.signal
 
-    worldEmitter.on('entity', (e) => {
+    bindAbortableListener(worldEmitter, 'entity', (e) => {
       this.updateEntity(e, false)
-    })
-    worldEmitter.on('entityMoved', (e) => {
+    }, signal)
+    bindAbortableListener(worldEmitter, 'entityMoved', (e) => {
       this.updateEntity(e, true)
-    })
-    worldEmitter.on('playerEntity', (e) => {
+    }, signal)
+    bindAbortableListener(worldEmitter, 'playerEntity', (e) => {
       this.updatePlayerEntity?.(e)
-    })
+    }, signal)
 
     let currentLoadChunkBatch = null as {
       timeout
       data
     } | null
-    worldEmitter.on('loadChunk', ({ x, z, chunk, worldConfig, isLightUpdate }) => {
+    bindAbortableListener(worldEmitter, 'loadChunk', ({ x, z, chunk, worldConfig, isLightUpdate }) => {
       this.worldSizeParams = worldConfig
       this.queuedChunks.add(`${x},${z}`)
       const args = [x, z, chunk, isLightUpdate]
@@ -863,45 +881,44 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
         }
       }
       currentLoadChunkBatch.data.push(args)
-    })
+    }, signal)
     // todo remove and use other architecture instead so data flow is clear
-    worldEmitter.on('blockEntities', (blockEntities) => {
+    bindAbortableListener(worldEmitter, 'blockEntities', (blockEntities) => {
       this.blockEntities = blockEntities
-    })
+    }, signal)
 
-    worldEmitter.on('unloadChunk', ({ x, z }) => {
+    bindAbortableListener(worldEmitter, 'unloadChunk', ({ x, z }) => {
       this.removeColumn(x, z)
-    })
+    }, signal)
 
-    worldEmitter.on('blockUpdate', ({ pos, stateId }) => {
+    bindAbortableListener(worldEmitter, 'blockUpdate', ({ pos, stateId }) => {
       this.setBlockStateId(new Vec3(pos.x, pos.y, pos.z), stateId)
-    })
+    }, signal)
 
-    worldEmitter.on('chunkPosUpdate', ({ pos }) => {
+    bindAbortableListener(worldEmitter, 'chunkPosUpdate', ({ pos }) => {
       this.updateViewerPosition(pos)
-    })
+    }, signal)
 
-    worldEmitter.on('end', () => {
+    bindAbortableListener(worldEmitter, 'end', () => {
       this.worldStop?.()
-    })
-
+    }, signal)
 
-    worldEmitter.on('renderDistance', (d) => {
+    bindAbortableListener(worldEmitter, 'renderDistance', (d) => {
       this.viewDistance = d
       this.chunksLength = d === 0 ? 1 : generateSpiralMatrix(d).length
       this.allChunksFinished = Object.keys(this.finishedChunks).length === this.chunksLength
       this.onRenderDistanceChanged?.(d)
-    })
+    }, signal)
 
-    worldEmitter.on('markAsLoaded', ({ x, z }) => {
+    bindAbortableListener(worldEmitter, 'markAsLoaded', ({ x, z }) => {
       this.markAsLoaded(x, z)
-    })
+    }, signal)
 
-    worldEmitter.on('updateLight', ({ pos }) => {
+    bindAbortableListener(worldEmitter, 'updateLight', ({ pos }) => {
       this.lightUpdate(pos.x, pos.z)
-    })
+    }, signal)
 
-    worldEmitter.on('onWorldSwitch', () => {
+    bindAbortableListener(worldEmitter, 'onWorldSwitch', () => {
       for (const fn of this.onWorldSwitched) {
         try {
           fn()
@@ -912,9 +929,9 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
           }, 0)
         }
       }
-    })
+    }, signal)
 
-    worldEmitter.on('time', (timeOfDay) => {
+    bindAbortableListener(worldEmitter, 'time', (timeOfDay) => {
       if (!this.worldRendererConfig.dayCycle) return
       this.timeUpdated?.(timeOfDay)
 
@@ -925,15 +942,15 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
       // if (this instanceof WorldRendererThree) {
       //   (this).rerenderAllChunks?.()
       // }
-    })
+    }, signal)
 
-    worldEmitter.on('biomeUpdate', ({ biome }) => {
+    bindAbortableListener(worldEmitter, 'biomeUpdate', ({ biome }) => {
       this.biomeUpdated?.(biome)
-    })
+    }, signal)
 
-    worldEmitter.on('biomeReset', () => {
+    bindAbortableListener(worldEmitter, 'biomeReset', () => {
       this.biomeReset?.()
-    })
+    }, signal)
   }
 
   setBlockStateIdInner(pos: Vec3, stateId: number | undefined, needAoRecalculation = true) {
@@ -1217,6 +1234,11 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
   }
 
   destroy() {
+    for (const unsub of this.valtioUnsubs) {
+      unsub()
+    }
+    this.valtioUnsubs = []
+
     // Cancel all pending heightmap debounce timers
     for (const timer of this.heightmapDebounceTimers.values()) {
       clearTimeout(timer)

package/src/three/documentRenderer.ts

@@ -34,7 +34,7 @@ export interface NonReactiveState {
   worstRenderTime: number
   avgRenderTime: number
   world: {
-    chunksLoaded: Set<string>
+    chunksLoadedCount: number
     chunksTotalNumber: number
   }
   renderer: {

package/src/three/entities.ts

@@ -1080,6 +1080,7 @@ export class Entities {
     if (entity.delete) {
       if (!e) return
       e.userData._posTween?.stop()
+      e.userData._rotTween?.stop()
       if (e.additionalCleanup) e.additionalCleanup()
       e.traverse(c => {
         if (c['additionalCleanup']) c['additionalCleanup']()
@@ -1394,7 +1395,11 @@ export class Entities {
     }
     if (typeof entity.yaw === 'number' && Number.isFinite(entity.yaw)) {
       const dy = shortestYawRadians(e.rotation.y, entity.yaw)
-      new TWEEN.Tween(e.rotation).to({ y: e.rotation.y + dy }, ANIMATION_DURATION).start()
+      // Stop previous rotation tween to prevent accumulation (mirror _posTween)
+      e.userData._rotTween?.stop()
+      e.userData._rotTween = new TWEEN.Tween(e.rotation)
+        .to({ y: e.rotation.y + dy }, ANIMATION_DURATION)
+        .start()
     }
 
     if (e?.playerObject && overrides?.rotation?.head) {

package/src/three/graphicsBackendBase.ts

@@ -191,25 +191,35 @@ export const createGraphicsBackendBase = () => {
   }
 
   const startWorld = async (displayOptionsArg: DisplayWorldOptions) => {
-    const displayOptionsRestorers = [ResourcesManager, WorldViewWorker]
-    const displayOptions: DisplayWorldOptions = isWebWorker ? restoreTransferred(displayOptionsArg, displayOptionsRestorers, globalThis as unknown as Worker) : displayOptionsArg
-
     if (!documentRenderer) throw new Error('Document renderer not initialized')
 
-    documentRenderer.nonReactiveState = displayOptions.nonReactiveState
-      // Set resourcesManager globally for world rendering
-      ; (globalThis as any).resourcesManager = displayOptions.resourcesManager
-
     if (menuBackgroundRenderer) {
       menuBackgroundRenderer.dispose()
       menuBackgroundRenderer = null
     }
 
+    if (worldRenderer) {
+      worldRenderer.destroy()
+      worldRenderer = null
+      frameTimingCollector = null
+      ;(globalThis as any).world = undefined
+      ;(globalThis as any).frameTimingCollector = undefined
+    }
+
+    const displayOptionsRestorers = [ResourcesManager, WorldViewWorker]
+    const displayOptions: DisplayWorldOptions = isWebWorker ? restoreTransferred(displayOptionsArg, displayOptionsRestorers, globalThis as unknown as Worker) : displayOptionsArg
+
+    documentRenderer.nonReactiveState = displayOptions.nonReactiveState
+      // Set resourcesManager globally for world rendering
+      ; (globalThis as any).resourcesManager = displayOptions.resourcesManager
+
     worldRenderer = new WorldRendererThree(documentRenderer.renderer, initOptions, displayOptions)
 
     await worldRenderer.worldReadyPromise
 
-    frameTimingCollector = new FrameTimingCollector(displayOptions.nonReactiveState)
+    frameTimingCollector = displayOptions.inWorldRenderingConfig.enableDebugOverlay
+      ? new FrameTimingCollector(displayOptions.nonReactiveState)
+      : null
       ; (globalThis as any).frameTimingCollector = frameTimingCollector
 
     const originalRender = documentRenderer.render

package/src/three/modules/rain.ts

@@ -93,7 +93,7 @@ export class RainModule implements RendererModuleController {
       const chunkX = Math.floor(worldX / 16)
       const chunkZ = Math.floor(worldZ / 16)
       if (chunkX !== prevChunkX || chunkZ !== prevChunkZ) {
-        cachedHeightmap = heightmaps.get(`${chunkX},${chunkZ}`)
+        cachedHeightmap = heightmaps[`${chunkX},${chunkZ}`]
         prevChunkX = chunkX
         prevChunkZ = chunkZ
       }

package/src/three/shaders/cubeBlockShader.ts

@@ -142,9 +142,9 @@ void main() {
     } else if (faceId == 2u || faceId == 3u) {
         v_uv = vec2(v, u);
     } else if (faceId == 4u) {
-        v_uv = vec2(u, 1.0 - v);
+        v_uv = vec2(u, v);
     } else { // faceId == 5u
-        v_uv = vec2(1.0 - u, 1.0 - v);
+        v_uv = vec2(1.0 - u, v);
     }
 
     // --- Position: section base (multiples of 16) + face quad + block-local 0..15 ---

package/src/three/worldRendererThree.ts

@@ -167,7 +167,8 @@ export class WorldRendererThree extends WorldRendererCommon {
     this.performanceMonitor = new PerformanceMonitor(this.reactiveState.world.instabilityFactors)
 
     this.renderer = renderer
-    displayOptions.rendererState.renderer = WorldRendererThree.getRendererInfo(renderer) ?? '...'
+    const rendererInfo = WorldRendererThree.getRendererInfo(renderer) ?? '...'
+    displayOptions.rendererState.renderer = rendererInfo
 
     // Initialize chunk mesh manager
     this.chunkMeshManager = new ChunkMeshManager(this, this.scene, this.material, this.worldSizeParams.worldHeight, this.viewDistance)

package/src/worldView/worldView.ts

@@ -44,6 +44,13 @@ export const delayedIterator = async <T>(
   }
 }
 
+type WorkerWorldViewBridge = {
+  activeWorldView: WorldViewWorker
+  handler: (event: MessageEvent) => void
+}
+
+const workerWorldViewBridges = new WeakMap<Worker, WorkerWorldViewBridge>()
+
 /**
  * WorldView for worker thread communication.
  * This is a lightweight version that receives events from the main thread.
@@ -51,19 +58,43 @@ export const delayedIterator = async <T>(
 export class WorldViewWorker extends (EventEmitter as new () => TypedEmitter<WorldViewEvents>) {
   static readonly restorerName = 'WorldViewWorker'
 
-  static restoreTransferred(data: any, worker?: Worker): WorldViewWorker {
+  static restoreTransferred(_data: any, worker?: Worker): WorldViewWorker {
     const worldView = new WorldViewWorker()
-    if (worker) {
-      worker.addEventListener('message', ({ data }) => {
-        if (data.class === WorldViewWorker.restorerName) {
-          if (data.type === 'event') {
-            worldView.emit(data.eventName, ...data.args)
-          }
+    if (!worker) {
+      return worldView
+    }
+
+    let bridge = workerWorldViewBridges.get(worker)
+    if (!bridge) {
+      const handler = ({ data }: MessageEvent) => {
+        const state = workerWorldViewBridges.get(worker)
+        const active = state?.activeWorldView
+        if (!active || data?.class !== WorldViewWorker.restorerName) return
+        if (data.type === 'event') {
+          active.emit(data.eventName, ...data.args)
         }
-      })
+      }
+      worker.addEventListener('message', handler as EventListener)
+      bridge = { activeWorldView: worldView, handler }
+      workerWorldViewBridges.set(worker, bridge)
+    } else {
+      bridge.activeWorldView = worldView
     }
     return worldView
   }
+
+  /** @internal vitest — remove bridge listener from worker */
+  static clearWorkerBridgeForTest(worker: Worker): void {
+    const bridge = workerWorldViewBridges.get(worker)
+    if (!bridge) return
+    worker.removeEventListener('message', bridge.handler as EventListener)
+    workerWorldViewBridges.delete(worker)
+  }
+
+  /** @internal vitest — count of bridge listeners on worker */
+  static getWorkerBridgeListenerCountForTest(worker: Worker): number {
+    return workerWorldViewBridges.has(worker) ? 1 : 0
+  }
 }
 
 /**

package/src/worldView/worldViewWorkerBridge.test.ts

@@ -0,0 +1,59 @@
+//@ts-nocheck
+import { describe, expect, it, vi } from 'vitest'
+import { WorldViewWorker } from './worldView'
+
+describe('WorldViewWorker.restoreTransferred bridge', () => {
+  it('registers only one message listener per worker across restores', () => {
+    const addSpy = vi.fn()
+    const worker = {
+      addEventListener: addSpy,
+      removeEventListener: vi.fn(),
+    } as unknown as Worker
+
+    WorldViewWorker.restoreTransferred({}, worker)
+    WorldViewWorker.restoreTransferred({}, worker)
+    WorldViewWorker.restoreTransferred({}, worker)
+
+    expect(addSpy).toHaveBeenCalledTimes(1)
+    expect(WorldViewWorker.getWorkerBridgeListenerCountForTest(worker)).toBe(1)
+
+    WorldViewWorker.clearWorkerBridgeForTest(worker)
+  })
+
+  it('routes events to the latest restored worldView only', () => {
+    const listeners: Array<(event: MessageEvent) => void> = []
+    const worker = {
+      addEventListener: (_type: string, handler: (event: MessageEvent) => void) => {
+        listeners.push(handler)
+      },
+      removeEventListener: () => {},
+    } as unknown as Worker
+
+    const first = WorldViewWorker.restoreTransferred({}, worker)
+    const second = WorldViewWorker.restoreTransferred({}, worker)
+
+    let firstCalls = 0
+    let secondCalls = 0
+    first.on('loadChunk', () => {
+      firstCalls++
+    })
+    second.on('loadChunk', () => {
+      secondCalls++
+    })
+
+    const handler = listeners[0]!
+    handler({
+      data: {
+        class: WorldViewWorker.restorerName,
+        type: 'event',
+        eventName: 'loadChunk',
+        args: [{ x: 0, z: 0, chunk: {}, worldConfig: {}, isLightUpdate: false }],
+      },
+    } as MessageEvent)
+
+    expect(firstCalls).toBe(0)
+    expect(secondCalls).toBe(1)
+
+    WorldViewWorker.clearWorkerBridgeForTest(worker)
+  })
+})

package/src/lib/workerProxy.restore.test.ts

@@ -1,29 +0,0 @@
-//@ts-nocheck
-import { describe, expect, it } from 'vitest'
-import { restoreTransferred } from './workerProxy'
-
-describe('restoreTransferred Set/Map', () => {
-  const worker = null as unknown as Worker
-
-  it('restores Set from __setValues', () => {
-    const out = restoreTransferred({ __restorer: 'Set', __setValues: ['a', 'b'] }, [], worker, false)
-    expect(out).toEqual(new Set(['a', 'b']))
-  })
-
-  it('does not throw when legacy values is a function (Map.values collision)', () => {
-    const map = new Map([['k', 1]])
-    const out = restoreTransferred({ __restorer: 'Set', values: map.values.bind(map) }, [], worker, false)
-    expect(out).toEqual(new Set())
-  })
-
-  it('restores Map from __mapEntries', () => {
-    const out = restoreTransferred({ __restorer: 'Map', __mapEntries: [['a', 1]] }, [], worker, false)
-    expect(out).toEqual(new Map([['a', 1]]))
-  })
-
-  it('does not throw when legacy entries is a function', () => {
-    const m = new Map()
-    const out = restoreTransferred({ __restorer: 'Map', entries: m.entries.bind(m) }, [], worker, false)
-    expect(out).toEqual(new Map())
-  })
-})