minecraft-renderer 0.1.62 → 0.1.64

package/src/three/menuBackground/renderer.ts

@@ -3,14 +3,14 @@ import * as THREE from 'three'
 import type { GraphicsInitOptions } from '../../graphicsBackend/types'
 import type { DocumentRenderer } from '../documentRenderer'
 import { ClassicMenuBackground } from './classic'
-import { FuturisticMenuBackground } from './futuristic'
+import { V2MenuBackground } from './v2'
 import { WorldBlocksMenuBackground } from './worldBlocks'
 import type { MenuBackgroundView } from './activeView'
 import type { MenuBackgroundOptions } from './types'
 import { resolveMenuBackgroundMode } from './types'
 
 /**
- * Orchestrates main-menu background rendering (dispatches to classic / futuristic / world-blocks).
+ * Orchestrates main-menu background rendering (dispatches to classic / v2 / world-blocks).
  */
 export class MenuBackgroundRenderer {
   private active?: MenuBackgroundView
@@ -27,9 +27,9 @@ export class MenuBackgroundRenderer {
     this.mode = resolveMenuBackgroundMode(menuBackgroundOptions, singleFileBuild)
   }
 
-  /** Active futuristic instance when that style is running. */
-  get futuristic(): FuturisticMenuBackground | undefined {
-    return this.active instanceof FuturisticMenuBackground ? this.active : undefined
+  /** Active v2 instance when that style is running. */
+  get v2(): V2MenuBackground | undefined {
+    return this.active instanceof V2MenuBackground ? this.active : undefined
   }
 
   get scene(): THREE.Scene | undefined {
@@ -64,16 +64,16 @@ export class MenuBackgroundRenderer {
 
   private createImplementation(options: MenuBackgroundOptions): MenuBackgroundView {
     switch (this.mode) {
-      case 'futuristic':
-        return new FuturisticMenuBackground(
+      case 'v2':
+        return new V2MenuBackground(
           this.documentRenderer,
           {
             useMinecraftTextures: options.useMinecraftTextures,
-            initialScene: options.futuristicScene,
-            initialCamera: options.futuristicCamera,
-            initialBlockGroup: options.futuristicBlockGroup,
-            initialCameraSpeed: options.futuristicCameraSpeed,
-            initialBlockSpeed: options.futuristicBlockSpeed,
+            initialScene: options.v2Scene,
+            initialCamera: options.v2Camera,
+            initialBlockGroup: options.v2BlockGroup,
+            initialCameraSpeed: options.v2CameraSpeed,
+            initialBlockSpeed: options.v2BlockSpeed,
             resourcesManager: options.resourcesManager
           },
           this.abortController.signal

package/src/three/menuBackground/types.ts

@@ -1,25 +1,25 @@
 //@ts-nocheck
 import type { ResourcesManager } from '../../resourcesManager/resourcesManager'
-import type { FuturisticCameraId, FuturisticSceneId, MinecraftBlockGroupId } from './futuristic'
+import type { V2CameraId, V2SceneId, MinecraftBlockGroupId } from './v2'
 import { MENU_BACKGROUND_OPTION_DEFAULTS } from './config'
 
-export type { FuturisticCameraId, FuturisticSceneId, MinecraftBlockGroupId } from './futuristic'
+export type { V2CameraId, V2SceneId, MinecraftBlockGroupId } from './v2'
 
-export type MenuBackgroundMode = 'classic' | 'futuristic' | 'worldBlocks'
+export type MenuBackgroundMode = 'classic' | 'v2' | 'worldBlocks'
 
 export interface MenuBackgroundOptions {
   /** Visual style. Defaults to {@link MENU_BACKGROUND_OPTION_DEFAULTS.mode}, or `worldBlocks` in single-file build. */
   mode?: MenuBackgroundMode
-  /** Futuristic style: load block atlas and render textured cubes (requires assets / mcData). */
+  /** V2 style: load block atlas and render textured cubes (requires assets / mcData). */
   useMinecraftTextures?: boolean
-  futuristicScene?: FuturisticSceneId
-  futuristicCamera?: FuturisticCameraId
+  v2Scene?: V2SceneId
+  v2Camera?: V2CameraId
   /** Block pool when {@link useMinecraftTextures} is enabled. */
-  futuristicBlockGroup?: MinecraftBlockGroupId
+  v2BlockGroup?: MinecraftBlockGroupId
   /** Camera path speed (1 = 100%). */
-  futuristicCameraSpeed?: number
+  v2CameraSpeed?: number
   /** Block fly-through + sky drift speed (1 = 100%). */
-  futuristicBlockSpeed?: number
+  v2BlockSpeed?: number
   /**
    * Optional shared resource manager (e.g. appViewer.resourcesManager).
    * Caller should run `updateAssetsData` after mcData is loaded when using textured cubes.

package/src/three/menuBackground/{futuristic.ts → v2.ts}

@@ -8,31 +8,31 @@ import { resizeMenuBackgroundCamera } from './activeView'
 import { loadThreeJsTextureFromBitmap } from '../threeJsUtils'
 import { MENU_BACKGROUND_MOTION_DEFAULTS, MENU_BACKGROUND_OPTION_DEFAULTS } from './config'
 import {
-  FUTURISTIC_CAMERA_IDS,
-  FUTURISTIC_SCENE_IDS,
+  V2_CAMERA_IDS,
+  V2_SCENE_IDS,
   MINECRAFT_BLOCK_GROUP_IDS,
-  type FuturisticCameraId,
-  type FuturisticSceneId,
+  type V2CameraId,
+  type V2SceneId,
   type MinecraftBlockGroupId,
-} from './futuristicMeta'
+} from './v2Meta'
 
 export {
-  FUTURISTIC_SCENE_IDS,
-  FUTURISTIC_SCENE_LABELS,
-  FUTURISTIC_CAMERA_IDS,
-  FUTURISTIC_CAMERA_LABELS,
+  V2_SCENE_IDS,
+  V2_SCENE_LABELS,
+  V2_CAMERA_IDS,
+  V2_CAMERA_LABELS,
   MINECRAFT_BLOCK_GROUP_IDS,
   MINECRAFT_BLOCK_GROUP_LABELS,
-} from './futuristicMeta'
-export type { FuturisticSceneId, FuturisticCameraId, MinecraftBlockGroupId } from './futuristicMeta'
+} from './v2Meta'
+export type { V2SceneId, V2CameraId, MinecraftBlockGroupId } from './v2Meta'
 
 /** Mouse parallax scale (HTML prototype uses 1). */
 const MOUSE_INFLUENCE = 0.1
 
-export interface FuturisticMenuBackgroundOptions {
+export interface V2MenuBackgroundOptions {
   useMinecraftTextures?: boolean
-  initialScene?: FuturisticSceneId
-  initialCamera?: FuturisticCameraId
+  initialScene?: V2SceneId
+  initialCamera?: V2CameraId
   initialBlockGroup?: MinecraftBlockGroupId
   /** Camera path speed multiplier (0 = frozen path; mouse parallax unchanged). */
   initialCameraSpeed?: number
@@ -41,7 +41,7 @@ export interface FuturisticMenuBackgroundOptions {
   resourcesManager?: ResourcesManager
 }
 
-/** Block pools for textured floating cubes (selected via {@link FuturisticMenuBackground.setBlockGroup}). */
+/** Block pools for textured floating cubes (selected via {@link V2MenuBackground.setBlockGroup}). */
 export const MINECRAFT_BLOCK_GROUPS = {
   mixed: [
     'white_wool', 'cyan_wool', 'blue_wool', 'purple_wool',
@@ -123,7 +123,7 @@ interface FloatingBlock {
   minecraftBlockName?: string
 }
 
-const PAL: Record<FuturisticSceneId, ScenePalette> = {
+const PAL: Record<V2SceneId, ScenePalette> = {
   galaxy: {
     bg: 0x02_04_12, fog: 0x02_04_12, fogD: 0.011,
     blocks: [0x00_f0_ff, 0x00_d4_ff, 0x00_b8_ff, 0x00_e8_ff, 0x22_cc_ff, 0x00_a8_ff],
@@ -192,7 +192,7 @@ const PAL: Record<FuturisticSceneId, ScenePalette> = {
   }
 }
 
-const CAMS: Record<FuturisticCameraId, CameraMode> = {
+const CAMS: Record<V2CameraId, CameraMode> = {
   cruise: {
     pos: (t, mx, my) => ({ x: Math.sin(t * 0.28) * 18 + Math.cos(t * 0.11) * 7 + mx * 10, y: Math.sin(t * 0.19) * 6 + Math.cos(t * 0.31) * 3 + my * 6, z: 0 }),
     look: (t, mx, my) => ({ x: Math.sin((t + 0.18) * 0.28) * 18 + mx * 8, y: Math.sin((t + 0.18) * 0.19) * 6 + my * 4, z: -25 }),
@@ -232,7 +232,7 @@ const CAMS: Record<FuturisticCameraId, CameraMode> = {
   }
 }
 
-const CAM_SPD: Record<FuturisticCameraId, number> = {
+const CAM_SPD: Record<V2CameraId, number> = {
   cruise: 1,
   barrel: 1.6,
   dive: 2.2,
@@ -270,7 +270,7 @@ const makeSkyGradientTexture = (gradient: NonNullable<ScenePalette['gradientBg']
   return tex
 }
 
-export class FuturisticMenuBackground implements MenuBackgroundView {
+export class V2MenuBackground implements MenuBackgroundView {
   readonly scene: THREE.Scene
   readonly camera: THREE.PerspectiveCamera
 
@@ -288,8 +288,8 @@ export class FuturisticMenuBackground implements MenuBackgroundView {
   private readonly bGeo = new THREE.BoxGeometry(1, 1, 1)
   private readonly eGeo = new THREE.EdgesGeometry(this.bGeo)
 
-  private curScene: FuturisticSceneId
-  private curCam: FuturisticCameraId
+  private curScene: V2SceneId
+  private curCam: V2CameraId
   private blockGroup: MinecraftBlockGroupId
   private cameraSpeed: number
   private blockSpeed: number
@@ -307,16 +307,19 @@ export class FuturisticMenuBackground implements MenuBackgroundView {
   private gradientSkyTexture: THREE.CanvasTexture | null = null
   private disposed = false
   private animTime = 0
+  private texturesApplied = false
+  private textureLoadInProgress = false
+  private onAssetsTexturesUpdated?: () => void
 
   constructor(
     private readonly documentRenderer: DocumentRenderer,
-    options: FuturisticMenuBackgroundOptions = {},
+    options: V2MenuBackgroundOptions = {},
     private readonly abortSignal?: AbortSignal
   ) {
     const d = MENU_BACKGROUND_OPTION_DEFAULTS
-    this.curScene = options.initialScene ?? d.futuristicScene
-    this.curCam = options.initialCamera ?? d.futuristicCamera
-    this.blockGroup = options.initialBlockGroup ?? d.futuristicBlockGroup
+    this.curScene = options.initialScene ?? d.v2Scene
+    this.curCam = options.initialCamera ?? d.v2Camera
+    this.blockGroup = options.initialBlockGroup ?? d.v2BlockGroup
     this.cameraSpeed = options.initialCameraSpeed ?? MENU_BACKGROUND_MOTION_DEFAULTS.camera
     this.blockSpeed = options.initialBlockSpeed ?? MENU_BACKGROUND_MOTION_DEFAULTS.block
     this.useMinecraftTextures = options.useMinecraftTextures ?? d.minecraftTextures
@@ -420,13 +423,79 @@ export class FuturisticMenuBackground implements MenuBackgroundView {
   }
 
   async init() {
-    if (this.useMinecraftTextures) {
-      try {
-        await this.loadMinecraftTextures()
-      } catch (err) {
-        console.warn('[FuturisticMenuBackground] Failed to load Minecraft textures, using solid colors:', err)
-        this.useMinecraftTextures = false
+    if (!this.useMinecraftTextures) return
+    void this.scheduleMinecraftTextureLoad()
+  }
+
+  private scheduleMinecraftTextureLoad() {
+    if (!this.useMinecraftTextures || this.disposed || this.texturesApplied || this.textureLoadInProgress) return
+    void this.tryApplyMinecraftTextures()
+  }
+
+  private attachAssetsListener() {
+    const rm = this.resourcesManager
+    if (!rm || this.onAssetsTexturesUpdated) return
+    this.onAssetsTexturesUpdated = () => this.scheduleMinecraftTextureLoad()
+    rm.on('assetsTexturesUpdated', this.onAssetsTexturesUpdated)
+  }
+
+  private detachAssetsListener() {
+    const rm = this.resourcesManager
+    if (!rm || !this.onAssetsTexturesUpdated) return
+    rm.off('assetsTexturesUpdated', this.onAssetsTexturesUpdated)
+    this.onAssetsTexturesUpdated = undefined
+  }
+
+  private hasBlockAtlas(resourcesManager: ResourcesManager): boolean {
+    const resources = resourcesManager.currentResources
+    return !!(resources?.blocksAtlasImage && resources.blocksAtlasJson)
+  }
+
+  private async ensureAtlasReady(resourcesManager: ResourcesManager): Promise<boolean> {
+    await this.ensureMcDataLoaded()
+    if (this.hasBlockAtlas(resourcesManager)) return true
+
+    if (typeof document === 'undefined' && resourcesManager !== this.resourcesManager) {
+      return false
+    }
+
+    resourcesManager.currentConfig = {
+      ...resourcesManager.currentConfig,
+      version: MENU_BACKGROUND_MC_VERSION,
+      noInventoryGui: true
+    }
+
+    try {
+      await resourcesManager.updateAssetsData?.({})
+    } catch {
+      return false
+    }
+
+    return this.hasBlockAtlas(resourcesManager)
+  }
+
+  private async tryApplyMinecraftTextures() {
+    if (this.disposed || !this.useMinecraftTextures || this.texturesApplied) return
+
+    this.textureLoadInProgress = true
+    try {
+      const resourcesManager = this.resourcesManager ?? new ResourcesManager()
+      const ready = await this.ensureAtlasReady(resourcesManager)
+      if (!ready) {
+        if (this.resourcesManager) this.attachAssetsListener()
+        return
       }
+      if (this.disposed) return
+
+      this.applyMinecraftTexturesFromAtlas(resourcesManager)
+      this.texturesApplied = true
+      this.detachAssetsListener()
+    } catch (err) {
+      console.warn('[V2MenuBackground] Failed to load Minecraft textures, using solid colors:', err)
+      this.useMinecraftTextures = false
+      this.detachAssetsListener()
+    } finally {
+      this.textureLoadInProgress = false
     }
   }
 
@@ -626,23 +695,7 @@ export class FuturisticMenuBackground implements MenuBackgroundView {
     return null
   }
 
-  private async loadMinecraftTextures() {
-    await this.ensureMcDataLoaded()
-
-    const resourcesManager = this.resourcesManager ?? new ResourcesManager()
-    const needsAssetUpdate = !resourcesManager.currentResources?.blocksAtlasImage
-    if (needsAssetUpdate) {
-      if (typeof document === 'undefined') {
-        throw new Error('Menu atlas missing in worker; pass resourcesManager from main thread')
-      }
-      resourcesManager.currentConfig = {
-        ...resourcesManager.currentConfig,
-        version: MENU_BACKGROUND_MC_VERSION,
-        noInventoryGui: true
-      }
-      await resourcesManager.updateAssetsData?.({})
-    }
-
+  private applyMinecraftTexturesFromAtlas(resourcesManager: ResourcesManager) {
     const resources = resourcesManager.currentResources
     if (!resources?.blocksAtlasImage || !resources.blocksAtlasJson) {
       throw new Error('Block atlas not available')
@@ -690,8 +743,8 @@ export class FuturisticMenuBackground implements MenuBackgroundView {
     }
   }
 
-  setScene(name: FuturisticSceneId) {
-    if (!(FUTURISTIC_SCENE_IDS as readonly string[]).includes(name)) return
+  setScene(name: V2SceneId) {
+    if (!(V2_SCENE_IDS as readonly string[]).includes(name)) return
     if (name === this.curScene || this.transitioning) return
     this.transitioning = true
     this.curScene = name
@@ -726,8 +779,8 @@ export class FuturisticMenuBackground implements MenuBackgroundView {
     }, 150)
   }
 
-  setCamera(name: FuturisticCameraId) {
-    if (!(FUTURISTIC_CAMERA_IDS as readonly string[]).includes(name)) return
+  setCamera(name: V2CameraId) {
+    if (!(V2_CAMERA_IDS as readonly string[]).includes(name)) return
     this.curCam = name
   }
 
@@ -749,18 +802,15 @@ export class FuturisticMenuBackground implements MenuBackgroundView {
       mat.dispose()
     }
     this.blockMaterialPool.clear()
-    try {
-      await this.loadMinecraftTextures()
-    } catch (err) {
-      console.warn('[FuturisticMenuBackground] Failed to reload block group textures:', err)
-    }
+    this.texturesApplied = false
+    this.scheduleMinecraftTextureLoad()
   }
 
-  getSceneId(): FuturisticSceneId {
+  getSceneId(): V2SceneId {
     return this.curScene
   }
 
-  getCameraId(): FuturisticCameraId {
+  getCameraId(): V2CameraId {
     return this.curCam
   }
 
@@ -830,6 +880,7 @@ export class FuturisticMenuBackground implements MenuBackgroundView {
 
   dispose() {
     this.disposed = true
+    this.detachAssetsListener()
     this.scene.clear()
     this.bGeo.dispose()
     this.eGeo.dispose()

package/src/three/menuBackground/{futuristicMeta.ts → v2Meta.ts}

@@ -1,13 +1,13 @@
 //@ts-nocheck
 /** Settings / labels only — no Three.js or DocumentRenderer (safe for defaultOptions imports). */
 
-export const FUTURISTIC_SCENE_IDS = ['galaxy', 'nether', 'end', 'cyber', 'light'] as const
-export type FuturisticSceneId = typeof FUTURISTIC_SCENE_IDS[number]
+export const V2_SCENE_IDS = ['galaxy', 'nether', 'end', 'cyber', 'light'] as const
+export type V2SceneId = typeof V2_SCENE_IDS[number]
 
-export const FUTURISTIC_CAMERA_IDS = ['cruise', 'barrel', 'dive', 'orbit', 'snake'] as const
-export type FuturisticCameraId = typeof FUTURISTIC_CAMERA_IDS[number]
+export const V2_CAMERA_IDS = ['cruise', 'barrel', 'dive', 'orbit', 'snake'] as const
+export type V2CameraId = typeof V2_CAMERA_IDS[number]
 
-export const FUTURISTIC_SCENE_LABELS: Record<FuturisticSceneId, string> = {
+export const V2_SCENE_LABELS: Record<V2SceneId, string> = {
   galaxy: 'Galaxy',
   nether: 'Nether',
   end: 'The End',
@@ -15,7 +15,7 @@ export const FUTURISTIC_SCENE_LABELS: Record<FuturisticSceneId, string> = {
   light: 'Light Space'
 }
 
-export const FUTURISTIC_CAMERA_LABELS: Record<FuturisticCameraId, string> = {
+export const V2_CAMERA_LABELS: Record<V2CameraId, string> = {
   cruise: 'Cruise',
   barrel: 'Barrel',
   dive: 'Dive',

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/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/wasm-mesher/tests/mesherWasmRequestTracker.test.ts

@@ -0,0 +1,29 @@
+//@ts-nocheck
+import { describe, expect, test } from 'vitest'
+import { SectionRequestTracker } from '../worker/mesherWasmRequestTracker'
+
+describe('SectionRequestTracker.clearColumn', () => {
+  test('removes all pending keys for the column', () => {
+    const tracker = new SectionRequestTracker()
+    tracker.addRequest('160,64,0')
+    tracker.addRequest('160,80,0')
+    tracker.addRequest('0,64,0')
+
+    tracker.clearColumn(160, 0)
+
+    expect(tracker.hasPending('160,64,0')).toBe(false)
+    expect(tracker.hasPending('160,80,0')).toBe(false)
+    expect(tracker.hasPending('0,64,0')).toBe(true)
+    expect(tracker.size()).toBe(1)
+  })
+
+  test('is a no-op when the column has no pending keys', () => {
+    const tracker = new SectionRequestTracker()
+    tracker.addRequest('0,64,0')
+
+    tracker.clearColumn(160, 0)
+
+    expect(tracker.hasPending('0,64,0')).toBe(true)
+    expect(tracker.size()).toBe(1)
+  })
+})

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

@@ -767,6 +767,13 @@ const handleMessage = async (data: any) => {
       if (!world) break
       world.removeColumn(data.x, data.z)
       world.customBlockModels.delete(`${data.x},${data.z}`)
+      requestTracker.clearColumn(data.x, data.z)
+      for (const key of [...dirtySections.keys()]) {
+        const [sx, , sz] = key.split(',').map(Number)
+        if (sx === data.x && sz === data.z) {
+          dirtySections.delete(key)
+        }
+      }
       if (Object.keys(world.columns).length === 0) softCleanup()
       break
     }

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

@@ -49,6 +49,16 @@ export class SectionRequestTracker {
         this.counts.clear()
     }
 
+    /** Drop all pending requests for one column (`cx`,`cz` = column origin in block coords). */
+    clearColumn (cx: number, cz: number): void {
+        for (const key of [...this.counts.keys()]) {
+            const [x, , z] = key.split(',').map(Number)
+            if (x === cx && z === cz) {
+                this.counts.delete(key)
+            }
+        }
+    }
+
     /** Number of distinct keys with pending requests. */
     size (): number {
         return this.counts.size

package/src/worldView/worldView.spiral.test.ts

@@ -0,0 +1,38 @@
+//@ts-nocheck
+import { describe, expect, it, vi } from 'vitest'
+import { Vec3 } from 'vec3'
+import { WorldView } from './worldView'
+
+describe('WorldView._loadChunks spiral guard', () => {
+  it('does not let a superseded spiral reset inLoading or panic state', async () => {
+    const world = {
+      getColumnAt: () => null,
+      setBlockStateId: vi.fn(),
+    }
+    const view = new WorldView(world, 8, new Vec3(0, 64, 0))
+    view.addWaitTime = 0
+    view.loadChunk = vi.fn(async () => {})
+
+    const positions = [new Vec3(0, 0, 0)]
+    const spiralA = view._loadChunks(positions, new Vec3(0, 64, 0))
+    await Promise.resolve()
+
+    expect(view.inLoading).toBe(true)
+    expect(view.spiralNumber).toBe(1)
+
+    const spiralB = view._loadChunks(positions, new Vec3(0, 64, 0))
+    await Promise.resolve()
+
+    expect(view.spiralNumber).toBe(2)
+    expect(view.inLoading).toBe(true)
+    expect(view.gotPanicLastTime).toBe(false)
+
+    await spiralA
+    expect(view.inLoading).toBe(true)
+    expect(view.gotPanicLastTime).toBe(false)
+
+    view.waitingSpiralChunksLoad['0,0']?.(true)
+    await spiralB
+    expect(view.inLoading).toBe(false)
+  })
+})

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
+  }
 }
 
 /**
@@ -234,6 +265,8 @@ export class WorldView extends (EventEmitter as new () => TypedEmitter<WorldView
       this.chunkProgress()
     })
 
+    if (spiralNumber !== this.spiralNumber) return
+
     if (this.panicTimeout) clearTimeout(this.panicTimeout)
     this.inLoading = false
     this.gotPanicLastTime = false

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)
+  })
+})