minecraft-renderer 0.1.62 → 0.1.63

package/package.json

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

package/src/graphicsBackend/config.ts

@@ -117,8 +117,8 @@ export const getDefaultRendererState = (): {
   return {
     reactive: proxy({
       world: {
-        chunksLoaded: new Set<string>(),
-        heightmaps: new Map<string, Int16Array>(),
+        chunksLoaded: {},
+        heightmaps: {},
         allChunksLoaded: false,
         mesherWork: false,
         instabilityFactors: defaultPerformanceInstabilityFactors(),
@@ -132,7 +132,7 @@ export const getDefaultRendererState = (): {
       worstRenderTime: 0,
       avgRenderTime: 0,
       world: {
-        chunksLoaded: new Set(),
+        chunksLoadedCount: 0,
         chunksTotalNumber: 0,
         chunksFullInfo: '-'
       },

package/src/graphicsBackend/types.ts

@@ -58,7 +58,7 @@ export interface NonReactiveState {
   worstRenderTime: number
   avgRenderTime: number
   world: {
-    chunksLoaded: Set<string>
+    chunksLoadedCount: number
     chunksTotalNumber: number
     chunksFullInfo: string
     allChunksLoaded?: boolean
@@ -75,8 +75,8 @@ export interface NonReactiveState {
 /** Renderer reactive state */
 export interface RendererReactiveState {
   world: {
-    chunksLoaded: Set<string>
-    heightmaps: Map<string, Int16Array>
+    chunksLoaded: Record<string, true>
+    heightmaps: Record<string, Int16Array>
     allChunksLoaded: boolean
     mesherWork: boolean
     /** Low-FPS / render instability factors (see `performanceMonitor`). */

package/src/lib/bindAbortableListener.test.ts

@@ -0,0 +1,65 @@
+//@ts-nocheck
+import { EventEmitter } from 'events'
+import { describe, expect, it } from 'vitest'
+import { bindAbortableEmitterListener, bindAbortableListener } from './bindAbortableListener'
+import { WorldViewWorker } from '../worldView'
+
+describe('bindAbortableListener', () => {
+  it('removes handler on abort', () => {
+    const emitter = new WorldViewWorker()
+    const controller = new AbortController()
+    let calls = 0
+    bindAbortableListener(emitter, 'renderDistance', () => {
+      calls++
+    }, controller.signal)
+
+    emitter.emit('renderDistance', 8)
+    expect(calls).toBe(1)
+
+    controller.abort()
+    emitter.emit('renderDistance', 12)
+    expect(calls).toBe(1)
+  })
+
+  it('abort removes only the bound handler on a shared emitter', () => {
+    const emitter = new WorldViewWorker()
+    const controllerA = new AbortController()
+    const controllerB = new AbortController()
+    let callsA = 0
+    let callsB = 0
+
+    bindAbortableListener(emitter, 'renderDistance', () => {
+      callsA++
+    }, controllerA.signal)
+    bindAbortableListener(emitter, 'renderDistance', () => {
+      callsB++
+    }, controllerB.signal)
+
+    emitter.emit('renderDistance', 4)
+    expect(callsA).toBe(1)
+    expect(callsB).toBe(1)
+
+    controllerA.abort()
+    emitter.emit('renderDistance', 6)
+    expect(callsA).toBe(1)
+    expect(callsB).toBe(2)
+  })
+})
+
+describe('bindAbortableEmitterListener', () => {
+  it('removes handler on abort', () => {
+    const emitter = new EventEmitter()
+    const controller = new AbortController()
+    let calls = 0
+    bindAbortableEmitterListener(emitter, 'test', () => {
+      calls++
+    }, controller.signal)
+
+    emitter.emit('test')
+    expect(calls).toBe(1)
+
+    controller.abort()
+    emitter.emit('test')
+    expect(calls).toBe(1)
+  })
+})

package/src/lib/bindAbortableListener.ts

@@ -0,0 +1,41 @@
+//@ts-nocheck
+import type { EventEmitter } from 'events'
+import type { WorldViewEvents } from '../worldView/types'
+import type { WorldViewWorker } from '../worldView'
+
+/**
+ * Register an EventEmitter listener removed when `signal` aborts.
+ * Safe for shared emitters (e.g. worldView) — only removes this handler.
+ */
+export function bindAbortableListener<E extends keyof WorldViewEvents>(
+  emitter: Pick<WorldViewWorker, 'on' | 'off'>,
+  event: E,
+  handler: (...args: WorldViewEvents[E]) => void,
+  signal: AbortSignal
+): void {
+  emitter.on(event, handler as (...args: any[]) => void)
+  if (signal.aborted) {
+    emitter.off(event, handler as (...args: any[]) => void)
+    return
+  }
+  signal.addEventListener('abort', () => {
+    emitter.off(event, handler as (...args: any[]) => void)
+  }, { once: true })
+}
+
+/** Same pattern for plain EventEmitters (e.g. resourcesManager). */
+export function bindAbortableEmitterListener(
+  emitter: Pick<EventEmitter, 'on' | 'off'>,
+  event: string,
+  handler: (...args: any[]) => void,
+  signal: AbortSignal
+): void {
+  emitter.on(event, handler)
+  if (signal.aborted) {
+    emitter.off(event, handler)
+    return
+  }
+  signal.addEventListener('abort', () => {
+    emitter.off(event, handler)
+  }, { once: true })
+}

package/src/lib/workerProxy.ts

@@ -86,104 +86,232 @@ export const useWorkerProxy = <T extends { __workerProxy: Record<string, (...arg
 
 const DEBUG_SYNC = false
 
-const sendWorkerSync = (syncId: string, obj: any, worker: Worker, debugKey: string) => {
-  try {
-    worker.postMessage({
-      type: 'sync',
-      syncId,
-      value: cloneValtioObject(obj)
-    })
-    currentWorkerSyncStats.toWorker++
-    globalThis.debugSyncMessagesOutgoing ??= 0
-    globalThis.debugSyncMessagesOutgoing++
-  } catch (err) {
-    console.error('Failed to send worker sync', err)
-    findProblemTransfer(obj)
-  }
-}
+// rendererState: worker→main only; playerState: main→worker only. Applying ops on the
+// receiver re-fires local subscribers; no echo loop while directions stay split.
+
+type SyncDirection = 'toWorker' | 'fromWorker'
+
+export type WireSyncOp =
+  | { kind: 'set', path: (string | number | symbol)[], value: unknown }
+  | { kind: 'delete', path: (string | number | symbol)[] }
+
+type ValtioOp = readonly unknown[]
 
-// Add stats tracking variables
 const currentWorkerSyncStats = { toWorker: 0, fromWorker: 0 }
 
-if (typeof window !== 'undefined') {
-  setInterval(() => {
+let debugSyncStatsInterval: ReturnType<typeof setInterval> | null = null
+
+const ensureDebugSyncStatsInterval = () => {
+  if (debugSyncStatsInterval != null) return
+  if (typeof window === 'undefined') return
+  debugSyncStatsInterval = setInterval(() => {
     globalThis.debugWorkerSyncStats = { ...currentWorkerSyncStats }
     currentWorkerSyncStats.toWorker = 0
     currentWorkerSyncStats.fromWorker = 0
   }, 1000)
 }
 
+const bumpSyncStat = (direction: SyncDirection) => {
+  ensureDebugSyncStatsInterval()
+  if (direction === 'toWorker') {
+    currentWorkerSyncStats.toWorker++
+  } else {
+    currentWorkerSyncStats.fromWorker++
+  }
+}
+
+/** @internal vitest only */
+export const resetWorkerSyncStatsForTest = () => {
+  currentWorkerSyncStats.toWorker = 0
+  currentWorkerSyncStats.fromWorker = 0
+  if (debugSyncStatsInterval != null) {
+    clearInterval(debugSyncStatsInterval)
+    debugSyncStatsInterval = null
+  }
+}
+
+/** @internal vitest only */
+export const getWorkerSyncStatsForTest = () => ({ ...currentWorkerSyncStats })
+
 const getSyncId = () => {
   return Math.random().toString(36).slice(2, 15) + Math.random().toString(36).slice(2, 15)
 }
 
-const applySyncPatch = (target: any, patch: any, worker: Worker) => {
-  Object.assign(target, restoreTransferred(patch, [], worker, false))
+export const setByPath = (target: any, path: (string | number | symbol)[], value: unknown) => {
+  if (path.length === 0) return
+  let cur = target
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i]!
+    if (cur[key] == null || typeof cur[key] !== 'object') {
+      cur[key] = {}
+    }
+    cur = cur[key]
+  }
+  cur[path[path.length - 1]!] = value
 }
 
-const setupObjectSync = (obj: any, originalObj: any, worker: Worker, isValtio: boolean, debugKey: string) => {
-  if (!obj['__syncToWorker'] && !obj['__syncFromWorker'] && !isValtio) return
+export const deleteByPath = (target: any, path: (string | number | symbol)[]) => {
+  if (path.length === 0) return
+  let cur = target
+  for (let i = 0; i < path.length - 1; i++) {
+    cur = cur[path[i]!]
+    if (cur == null) return
+  }
+  delete cur[path[path.length - 1]!]
+}
 
-  const syncId = getSyncId()
-  obj['__syncId'] = syncId
+export const prepareOpValueForTransfer = (value: any, worker: Worker): any => {
+  if (value == null || typeof value !== 'object') {
+    return value
+  }
 
-  if (obj['__syncToWorker'] || isValtio) {
-    const syncToWorker = () => {
-      sendWorkerSync(syncId, originalObj, worker, `toWorker:${debugKey}`)
-    }
-    if (isValtio) {
-      subscribe(originalObj, syncToWorker)
-    }
+  if (value instanceof Vec3) {
+    return { x: value.x, y: value.y, z: value.z, __restorer: 'Vec3' }
+  }
 
-    const interval = obj['__syncToWorkerInterval'] ?? 0
-    if (interval > 0) {
-      setInterval(syncToWorker, interval)
-    }
+  if (typeof value['prepareForTransfer'] === 'function') {
+    return value['prepareForTransfer'](worker)
   }
 
-  if (originalObj['__syncFromWorker']) {
-    worker.addEventListener('message', (event: any) => {
-      if (event.data.type === 'sync' && event.data.syncId === syncId) {
-        currentWorkerSyncStats.fromWorker++
-        applySyncPatch(originalObj, event.data.value, worker)
-      }
-    })
+  if (ArrayBuffer.isView(value)) {
+    return value
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(item => prepareOpValueForTransfer(item, worker))
+  }
+
+  if (getVersion(value) !== undefined) {
+    return cloneValtioObject(value)
   }
+
+  const result = {} as any
+  for (const key in value) {
+    if (Object.prototype.hasOwnProperty.call(value, key)) {
+      result[key] = prepareOpValueForTransfer(value[key], worker)
+    }
+  }
+  return result
 }
 
-const serializeMapForTransfer = (map: Map<unknown, unknown>) => ({
-  __restorer: 'Map',
-  __mapEntries: Array.from(map.entries()),
-})
+const wireOpsFromValtioOps = (ops: ValtioOp[], worker: Worker): WireSyncOp[] => {
+  const wire: WireSyncOp[] = []
+  for (const op of ops) {
+    const kind = op[0]
+    if (kind === 'delete') {
+      wire.push({ kind: 'delete', path: op[1] as (string | number | symbol)[] })
+    } else if (kind === 'set') {
+      wire.push({
+        kind: 'set',
+        path: op[1] as (string | number | symbol)[],
+        value: prepareOpValueForTransfer(op[2], worker)
+      })
+    }
+  }
+  return wire
+}
 
-const serializeSetForTransfer = (set: Set<unknown>) => ({
-  __restorer: 'Set',
-  __setValues: [...set],
-})
+export const sendWorkerSyncOps = (
+  syncId: string,
+  ops: ValtioOp[],
+  worker: Worker,
+  direction: SyncDirection,
+  debugKey: string
+) => {
+  if (ops.length === 0) return
+  const wire = wireOpsFromValtioOps(ops, worker)
+  if (wire.length === 0) return
+  try {
+    worker.postMessage({ type: 'sync', syncId, ops: wire })
+    if (direction === 'toWorker') {
+      bumpSyncStat('toWorker')
+    }
+    if (DEBUG_SYNC) console.log(`sync ${debugKey}`, wire.length, 'ops')
+  } catch (err) {
+    console.error('Failed to send worker sync ops', err, debugKey)
+    for (const op of wire) {
+      if (op.kind === 'set') findProblemTransfer(op.value)
+    }
+  }
+}
 
-const isSetLike = (value: unknown): value is Set<unknown> => {
-  return value instanceof Set || Object.prototype.toString.call(value) === '[object Set]'
+export const applySyncOps = (
+  target: any,
+  wireOps: WireSyncOp[],
+  worker: Worker,
+  countReceive: 'fromWorker' | false = false
+) => {
+  for (const op of wireOps) {
+    if (op.kind === 'delete') {
+      deleteByPath(target, op.path)
+    } else {
+      setByPath(target, op.path, restoreTransferred(op.value, [], worker, false, false))
+    }
+  }
+  if (countReceive === 'fromWorker') {
+    bumpSyncStat('fromWorker')
+  }
 }
 
-const isMapLike = (value: unknown): value is Map<unknown, unknown> => {
-  return value instanceof Map || Object.prototype.toString.call(value) === '[object Map]'
+/** Full snapshot for plain (non-Valtio) objects on interval sync only, e.g. nonReactiveState. */
+const sendWorkerSyncSnapshot = (syncId: string, obj: any, worker: Worker, direction: SyncDirection, debugKey: string) => {
+  try {
+    const value = cloneValtioObject(obj)
+    worker.postMessage({ type: 'sync', syncId, value })
+    if (direction === 'toWorker') {
+      bumpSyncStat('toWorker')
+    }
+    if (DEBUG_SYNC) console.log(`sync snapshot ${debugKey}`)
+  } catch (err) {
+    console.error('Failed to send worker sync snapshot', err, debugKey)
+    findProblemTransfer(obj)
+  }
 }
 
-const iterableFromPlainObject = (obj: Record<string, unknown>) => {
-  return Object.keys(obj)
-    .filter(k => !k.startsWith('__'))
-    .sort((a, b) => Number(a) - Number(b))
-    .map(k => obj[k])
+const applySyncSnapshot = (target: any, patch: any, worker: Worker, countReceive: 'fromWorker' | false = false) => {
+  Object.assign(target, restoreTransferred(patch, [], worker, false, false))
+  if (countReceive === 'fromWorker') {
+    bumpSyncStat('fromWorker')
+  }
 }
 
-const cloneValtioObject = (obj: any) => {
-  if (isMapLike(obj)) {
-    return serializeMapForTransfer(obj)
+const setupObjectSync = (obj: any, originalObj: any, worker: Worker, isValtio: boolean, debugKey: string) => {
+  const syncFromWorker = obj['__syncFromWorker'] || originalObj['__syncFromWorker']
+  const syncToWorker = obj['__syncToWorker'] || originalObj['__syncToWorker']
+  if (!syncToWorker && !syncFromWorker && !isValtio) return
+
+  const syncId = getSyncId()
+  obj['__syncId'] = syncId
+
+  if (syncToWorker || isValtio) {
+    if (isValtio && syncToWorker !== false) {
+      subscribe(originalObj, (ops) => {
+        sendWorkerSyncOps(syncId, ops as ValtioOp[], worker, 'toWorker', `toWorker:${debugKey}`)
+      })
+    }
+
+    const interval = obj['__syncToWorkerInterval'] ?? originalObj['__syncToWorkerInterval'] ?? 0
+    if (interval > 0 && !isValtio) {
+      setInterval(() => {
+        sendWorkerSyncSnapshot(syncId, originalObj, worker, 'toWorker', `toWorker:interval:${debugKey}`)
+      }, interval)
+    }
   }
-  if (isSetLike(obj)) {
-    return serializeSetForTransfer(obj)
+
+  if (originalObj['__syncFromWorker']) {
+    worker.addEventListener('message', (event: any) => {
+      if (event.data.type === 'sync' && event.data.syncId === syncId) {
+        if (event.data.ops) {
+          applySyncOps(originalObj, event.data.ops, worker, 'fromWorker')
+        } else if (event.data.value) {
+          applySyncSnapshot(originalObj, event.data.value, worker, 'fromWorker')
+        }
+      }
+    })
   }
+}
 
+const cloneValtioObject = (obj: any) => {
   if (getVersion(obj) === undefined) {
     return obj
   }
@@ -215,21 +343,11 @@ export const deepPrepareForTransfer = (obj: any, worker: Worker, autoRemoveMetho
         continue
       }
 
-      // print a warning for Date, RegExp, WeakMap, WeakSet
-      if (obj[key] instanceof Date || obj[key] instanceof RegExp || obj[key] instanceof WeakMap || obj[key] instanceof WeakSet) {
+      // print a warning for Date, RegExp, Map, Set, WeakMap, WeakSet
+      if (obj[key] instanceof Date || obj[key] instanceof RegExp || obj[key] instanceof Map || obj[key] instanceof Set || obj[key] instanceof WeakMap || obj[key] instanceof WeakSet) {
         console.warn(`Warning: ${key} is a ${typeof obj[key]}, which is not supported for transfer.`)
       }
 
-      // default restorers main -> worker
-      if (isMapLike(obj[key])) {
-        newObj[key] = serializeMapForTransfer(obj[key])
-        continue
-      }
-      // Set (only primitive values)
-      if (isSetLike(obj[key])) {
-        newObj[key] = serializeSetForTransfer(obj[key])
-        continue
-      }
       if (obj[key] instanceof Vec3) {
         newObj[key] = { x: obj[key].x, y: obj[key].y, z: obj[key].z }
         newObj[key]['__restorer'] = 'Vec3'
@@ -247,6 +365,19 @@ export const deepPrepareForTransfer = (obj: any, worker: Worker, autoRemoveMetho
         const isValtio = getVersion(obj[key]) !== undefined
         newObj[key] = isValtio ? cloneValtioObject(obj[key]) : obj[key]
 
+        if (obj[key]['__syncFromWorker']) {
+          newObj[key]['__syncFromWorker'] = true
+        }
+        if (obj[key]['__syncToWorker']) {
+          newObj[key]['__syncToWorker'] = true
+        }
+        if (obj[key]['__syncFromWorkerInterval']) {
+          newObj[key]['__syncFromWorkerInterval'] = obj[key]['__syncFromWorkerInterval']
+        }
+        if (obj[key]['__syncToWorkerInterval']) {
+          newObj[key]['__syncToWorkerInterval'] = obj[key]['__syncToWorkerInterval']
+        }
+
         // Try to enable sync main -> worker
         const tryEnableDefaultSync = obj[key]['__syncToWorker'] !== false && !_isInsideValtio && isValtio && !obj[key]['__syncFromWorker']
         newObj[key]['__syncToWorker'] ??= tryEnableDefaultSync
@@ -258,6 +389,10 @@ export const deepPrepareForTransfer = (obj: any, worker: Worker, autoRemoveMetho
           setupObjectSync(newObj[key], originalObj[key], worker, true, key)
           continue
         }
+        if (newObj[key]['__syncFromWorker'] || newObj[key]['__syncToWorker']) {
+          setupObjectSync(newObj[key], originalObj[key], worker, isValtio, key)
+          continue
+        }
         setupObjectSync(newObj[key], originalObj[key], worker, false, key)
 
 
@@ -285,67 +420,52 @@ export const findProblemTransfer = (obj: any, path: string[] = []) => {
   }
 }
 
+// Tracks which syncIds already have listeners/timers wired, per worker, so a
+// given synced object is never armed twice (prevents runaway interval/listener
+// accumulation if a payload carrying __sync* flags is ever restored again).
+const armedSyncIds = new WeakMap<Worker, Set<string>>()
+
 const receiveSyncedObject = (obj: any, worker: Worker, debugKey: string) => {
   if (!obj['__syncId']) return
   const syncId = obj['__syncId']
 
+  let armed = armedSyncIds.get(worker)
+  if (!armed) {
+    armed = new Set()
+    armedSyncIds.set(worker, armed)
+  }
+  if (armed.has(syncId)) return
+  armed.add(syncId)
+
   if (obj['__syncToWorker']) {
     worker.addEventListener('message', (event: any) => {
       if (event.data.type === 'sync' && event.data.syncId === syncId) {
-        applySyncPatch(obj, event.data.value, worker)
+        if (event.data.ops) {
+          applySyncOps(obj, event.data.ops, worker)
+        } else if (event.data.value) {
+          applySyncSnapshot(obj, event.data.value, worker)
+        }
       }
     })
   }
 
   if (obj['__syncFromWorker']) {
-    const syncFromWorker = () => {
-      sendWorkerSync(syncId, obj, worker, `fromWorker:${debugKey}`)
-    }
-
     if (obj['__valtio']) {
-      subscribe(obj, syncFromWorker)
+      subscribe(obj, (ops) => {
+        sendWorkerSyncOps(syncId, ops as ValtioOp[], worker, 'fromWorker', `fromWorker:${debugKey}`)
+      })
     }
 
     const interval = obj['__syncFromWorkerInterval'] ?? 0
-    if (interval > 0) {
-      setInterval(syncFromWorker, interval)
+    if (interval > 0 && !obj['__valtio']) {
+      setInterval(() => {
+        sendWorkerSyncSnapshot(syncId, obj, worker, 'fromWorker', `fromWorker:interval:${debugKey}`)
+      }, interval)
     }
   }
 }
 
 const defaultRestorers = [
-  {
-    restorerName: 'Map',
-    restoreTransferred(obj, _worker: Worker) {
-      if (Array.isArray(obj)) {
-        return new Map(obj)
-      }
-      const raw = obj.__mapEntries ?? obj.entries
-      if (Array.isArray(raw)) {
-        return new Map(raw)
-      }
-      if (raw != null && typeof raw === 'object' && typeof raw !== 'function') {
-        return new Map(Object.entries(raw as Record<string, unknown>))
-      }
-      return new Map()
-    }
-  },
-  {
-    restorerName: 'Set',
-    restoreTransferred(obj, _worker: Worker) {
-      if (Array.isArray(obj)) {
-        return new Set(obj)
-      }
-      const raw = obj.__setValues ?? obj.values
-      if (Array.isArray(raw)) {
-        return new Set(raw)
-      }
-      if (raw != null && typeof raw === 'object' && typeof raw !== 'function') {
-        return new Set(iterableFromPlainObject(raw as Record<string, unknown>))
-      }
-      return new Set()
-    }
-  },
   {
     restorerName: 'Vec3',
     restoreTransferred(obj, worker: Worker) {
@@ -358,7 +478,7 @@ export const addDefaultRestorer = (restorer: { restorerName: string, restoreTran
   defaultRestorers.unshift(restorer)
 }
 
-export const restoreTransferred = (obj: any, restorersArg: any[], worker: Worker, errorHandler: ((error: Error) => void) | boolean = true) => {
+export const restoreTransferred = (obj: any, restorersArg: any[], worker: Worker, errorHandler: ((error: Error) => void) | boolean = true, armSync = true) => {
   const restorers = [...defaultRestorers, ...restorersArg]
 
   const restoreValue = (value: any, debugKey: string): any => {
@@ -400,7 +520,7 @@ export const restoreTransferred = (obj: any, restorersArg: any[], worker: Worker
       value = proxy(value)
     }
 
-    receiveSyncedObject(value, worker, debugKey)
+    if (armSync) receiveSyncedObject(value, worker, debugKey)
     return value
   }