minecraft-renderer 0.1.79 → 0.1.80

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-renderer",
-  "version": "0.1.79",
+  "version": "0.1.80",
   "description": "The most Modular Minecraft world renderer with Three.js WebGL backend",
   "type": "module",
   "main": "./dist/index.js",
@@ -83,6 +83,7 @@
     "minecraft-data": "3.98.0",
     "mineflayer": "^4.33.0",
     "npm-run-all": "^4.1.5",
+    "prettier": "^3.8.4",
     "prismarine-block": "github:zardoy/prismarine-block#next-era",
     "prismarine-chunk": "github:zardoy/prismarine-chunk#master",
     "prismarine-world": "github:zardoy/prismarine-world#next-era",
@@ -129,6 +130,8 @@
     "unit-test": "vitest",
     "dev": "run-p watch:mesher watch:threeworker dev:playground",
     "dev:playground": "rsbuild dev --config rsbuild.config.ts",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write .",
+    "format:check": "prettier --check ."
   }
 }

package/src/bundler/bundlePrepare.ts

@@ -4,12 +4,7 @@ import { createRequire } from 'node:module'
 import path from 'node:path'
 
 /** Worker-related basenames inside `minecraft-renderer`/`dist`; skipped if missing. */
-export const MESHER_DIST_FILES = [
-  'mesher.js',
-  'mesher.js.map',
-  'mesherWasm.js',
-  'mesherWasm.js.map',
-] as const
+export const MESHER_DIST_FILES = ['mesher.js', 'mesher.js.map', 'mesherWasm.js', 'mesherWasm.js.map'] as const
 
 export type BundlePrepareMesherOptions = {
   cwd?: string
@@ -19,14 +14,14 @@ export type BundlePrepareMesherOptions = {
   files?: readonly string[]
 }
 
-function resolveSrcDist (opts: BundlePrepareMesherOptions | undefined, cwd: string): string {
+function resolveSrcDist(opts: BundlePrepareMesherOptions | undefined, cwd: string): string {
   if (opts?.mesherDistDir) return path.resolve(cwd, opts.mesherDistDir)
   const pkg = opts?.packageName ?? 'minecraft-renderer'
   const req = createRequire(path.join(cwd, 'package.json'))
   return path.join(path.dirname(req.resolve(`${pkg}/package.json`)), 'dist')
 }
 
-export async function bundlePrepareMesherWorkers (opts?: BundlePrepareMesherOptions): Promise<string[]> {
+export async function bundlePrepareMesherWorkers(opts?: BundlePrepareMesherOptions): Promise<string[]> {
   const cwd = opts?.cwd ?? process.cwd()
   const outDir = path.resolve(cwd, opts?.outDir ?? 'dist')
   const srcDist = resolveSrcDist(opts, cwd)

package/src/graphicsBackend/appViewer.ts

@@ -85,7 +85,10 @@ export class AppViewer {
   /** Bound by `subscribeRendererOptions` / `bindRendererOptions` — source of truth for renderer-owned settings. */
   private getRendererOptions?: () => RendererStorageOptions
 
-  constructor(options: AppViewerOptions = {}, public resourcesManager: ResourcesManager = new ResourcesManager()) {
+  constructor(
+    options: AppViewerOptions = {},
+    public resourcesManager: ResourcesManager = new ResourcesManager()
+  ) {
     this.config = {
       ...defaultGraphicsBackendConfig,
       ...options.config
@@ -116,7 +119,7 @@ export class AppViewer {
    * Preload mesher worker script (HTTP validate + ephemeral Worker + `mc-web-ping` / `mc-web-pong`).
    * Chooses `/mesherWasm.js` vs `/mesher.js` from `inWorldRenderingConfig.wasmMesher`.
    */
-  preloadWorkers (): Promise<void> {
+  preloadWorkers(): Promise<void> {
     const script = this.inWorldRenderingConfig.wasmMesher ? 'mesherWasm.js' : 'mesher.js'
     return preloadMesherWorkerScript({ script })
   }
@@ -143,7 +146,7 @@ export class AppViewer {
       config: this.config,
       getRendererOptions: this.getRendererOptions,
       callbacks: {
-        displayCriticalError: (error) => {
+        displayCriticalError: error => {
           console.error('[AppViewer] Critical error:', error)
         },
         setRendererSpecificSettings: (key, value) => {
@@ -165,7 +168,7 @@ export class AppViewer {
         this.startMenuBackground(...this.currentState.args)
       } else {
         const { method, args } = this.currentState
-          ; (this.backend as any)[method](...args)
+        ;(this.backend as any)[method](...args)
       }
     }
   }
@@ -290,7 +293,7 @@ export class AppViewer {
     if (this.worldView) {
       // Listen to bot events if worldView supports it
       if (typeof (this.worldView as any).listenToBot === 'function') {
-        (this.worldView as any).listenToBot(bot)
+        ;(this.worldView as any).listenToBot(bot)
       }
     }
   }
@@ -301,7 +304,7 @@ export class AppViewer {
   destroyAll(): void {
     this.disconnectBackend(true)
     if (this.resourcesManager && typeof (this.resourcesManager as any).destroy === 'function') {
-      (this.resourcesManager as any).destroy()
+      ;(this.resourcesManager as any).destroy()
     }
   }
 
@@ -314,7 +317,7 @@ export class AppViewer {
       async waitingForChunks(): Promise<void> {
         if ((backend as any)?.worldState?.allChunksLoaded) return
 
-        return new Promise<void>((resolve) => {
+        return new Promise<void>(resolve => {
           const interval = setInterval(() => {
             if ((backend as any)?.worldState?.allChunksLoaded) {
               clearInterval(interval)

package/src/graphicsBackend/config.ts

@@ -5,11 +5,7 @@
 
 import { proxy } from 'valtio'
 import { defaultPerformanceInstabilityFactors } from '../performanceMonitor'
-import type {
-  GraphicsBackendConfig,
-  RendererReactiveState,
-  NonReactiveState
-} from './types'
+import type { GraphicsBackendConfig, RendererReactiveState, NonReactiveState } from './types'
 
 /**
  * Default world renderer configuration.

package/src/graphicsBackend/playerState.ts

@@ -9,40 +9,41 @@ import { PlayerStateReactive } from '../playerState/playerState'
 /**
  * Get initial player state with default values.
  */
-export const getInitialPlayerState = (): PlayerStateReactive => proxy({
-  playerSkin: undefined,
-  inWater: false,
-  waterBreathing: false,
-  backgroundColor: [0, 0, 0] as [number, number, number],
-  ambientLight: 0,
-  directionalLight: 0,
-  eyeHeight: 0,
-  gameMode: undefined,
-  lookingAtBlock: undefined,
-  diggingBlock: undefined,
-  movementState: 'NOT_MOVING',
-  onGround: true,
-  sneaking: false,
-  flying: false,
-  sprinting: false,
-  walkDist: 0,
-  prevWalkDist: 0,
-  bob: 0,
-  prevBob: 0,
-  itemUsageTicks: 0,
-  username: '',
-  onlineMode: false,
-  cardinalLight: 'default',
-  lightingDisabled: false,
-  shouldHideHand: false,
-  heldItemMain: undefined,
-  heldItemOff: undefined,
-  perspective: 'first_person',
-  onFire: false,
-  fovMultiplier: 1,
-  cameraSpectatingEntity: undefined,
-  team: undefined,
-})
+export const getInitialPlayerState = (): PlayerStateReactive =>
+  proxy({
+    playerSkin: undefined,
+    inWater: false,
+    waterBreathing: false,
+    backgroundColor: [0, 0, 0] as [number, number, number],
+    ambientLight: 0,
+    directionalLight: 0,
+    eyeHeight: 0,
+    gameMode: undefined,
+    lookingAtBlock: undefined,
+    diggingBlock: undefined,
+    movementState: 'NOT_MOVING',
+    onGround: true,
+    sneaking: false,
+    flying: false,
+    sprinting: false,
+    walkDist: 0,
+    prevWalkDist: 0,
+    bob: 0,
+    prevBob: 0,
+    itemUsageTicks: 0,
+    username: '',
+    onlineMode: false,
+    cardinalLight: 'default',
+    lightingDisabled: false,
+    shouldHideHand: false,
+    heldItemMain: undefined,
+    heldItemOff: undefined,
+    perspective: 'first_person',
+    onFire: false,
+    fovMultiplier: 1,
+    cameraSpectatingEntity: undefined,
+    team: undefined
+  })
 
 /**
  * Get player state utils.

package/src/graphicsBackend/preloadWorkers.ts

@@ -56,7 +56,7 @@ export async function preloadMesherWorkerScript(opts?: {
       res = await fetch(scriptUrl, {
         credentials: 'same-origin',
         cache: 'force-cache',
-        signal: ctrl.signal,
+        signal: ctrl.signal
       })
     } finally {
       clearTimeout(t)
@@ -64,40 +64,37 @@ export async function preloadMesherWorkerScript(opts?: {
   } catch (e: unknown) {
     const err = e as { name?: string; message?: string }
     if (err?.name === 'AbortError') {
-      throw new MesherWorkerPreloadError(
-        `Mesher script fetch timed out after ${fetchTimeoutMs}ms (${scriptUrl}).`,
-        { phase: 'fetch', code: 'timeout' }
-      )
+      throw new MesherWorkerPreloadError(`Mesher script fetch timed out after ${fetchTimeoutMs}ms (${scriptUrl}).`, { phase: 'fetch', code: 'timeout' })
     }
-    throw new MesherWorkerPreloadError(
-      `Mesher script fetch failed (network): ${err?.message ?? e}. URL: ${scriptUrl}`,
-      { phase: 'fetch', code: 'network', detail: String(err?.message ?? e) }
-    )
+    throw new MesherWorkerPreloadError(`Mesher script fetch failed (network): ${err?.message ?? e}. URL: ${scriptUrl}`, {
+      phase: 'fetch',
+      code: 'network',
+      detail: String(err?.message ?? e)
+    })
   }
 
   if (!res.ok) {
-    throw new MesherWorkerPreloadError(
-      `Mesher script HTTP ${res.status} ${res.statusText}: ${scriptUrl}`,
-      { phase: 'fetch', code: 'bad-status', status: res.status }
-    )
+    throw new MesherWorkerPreloadError(`Mesher script HTTP ${res.status} ${res.statusText}: ${scriptUrl}`, {
+      phase: 'fetch',
+      code: 'bad-status',
+      status: res.status
+    })
   }
 
   const contentType = res.headers.get('content-type') ?? ''
   const buf = await res.arrayBuffer()
   if (buf.byteLength === 0) {
-    throw new MesherWorkerPreloadError(
-      `Mesher script response was empty: ${scriptUrl}`,
-      { phase: 'fetch', code: 'invalid-body', hint: 'empty' }
-    )
+    throw new MesherWorkerPreloadError(`Mesher script response was empty: ${scriptUrl}`, { phase: 'fetch', code: 'invalid-body', hint: 'empty' })
   }
 
   const headSize = Math.min(1024, buf.byteLength)
   const head = new TextDecoder().decode(buf.slice(0, headSize)).trimStart()
   if (head.startsWith('<!DOCTYPE') || head.startsWith('<html') || head.startsWith('<HTML')) {
-    throw new MesherWorkerPreloadError(
-      `Mesher URL returned HTML (wrong path, redirect, or SPA fallback), not JavaScript: ${scriptUrl}`,
-      { phase: 'fetch', code: 'invalid-body', hint: 'html' }
-    )
+    throw new MesherWorkerPreloadError(`Mesher URL returned HTML (wrong path, redirect, or SPA fallback), not JavaScript: ${scriptUrl}`, {
+      phase: 'fetch',
+      code: 'invalid-body',
+      hint: 'html'
+    })
   }
 
   if (contentType.length > 0 && !/javascript|ecmascript/i.test(contentType)) {
@@ -109,10 +106,11 @@ export async function preloadMesherWorkerScript(opts?: {
     worker = new Worker(scriptUrl)
   } catch (e: unknown) {
     const msg = e instanceof Error ? e.message : String(e)
-    throw new MesherWorkerPreloadError(
-      `Could not construct Worker for mesher (${scriptUrl}): ${msg}`,
-      { phase: 'worker', code: 'construct-failed', message: msg }
-    )
+    throw new MesherWorkerPreloadError(`Could not construct Worker for mesher (${scriptUrl}): ${msg}`, {
+      phase: 'worker',
+      code: 'construct-failed',
+      message: msg
+    })
   }
 
   await new Promise<void>((resolve, reject) => {
@@ -121,10 +119,12 @@ export async function preloadMesherWorkerScript(opts?: {
       if (settled) return
       settled = true
       cleanup()
-      reject(new MesherWorkerPreloadError(
-        `Mesher worker did not reply with mc-web-pong within ${pingTimeoutMs}ms (wrong script, SW stale cache, worker blocked, or COEP/CORP). URL: ${scriptUrl}`,
-        { phase: 'ping', code: 'timeout' }
-      ))
+      reject(
+        new MesherWorkerPreloadError(
+          `Mesher worker did not reply with mc-web-pong within ${pingTimeoutMs}ms (wrong script, SW stale cache, worker blocked, or COEP/CORP). URL: ${scriptUrl}`,
+          { phase: 'ping', code: 'timeout' }
+        )
+      )
     }, pingTimeoutMs)
 
     const cleanup = () => {
@@ -157,17 +157,22 @@ export async function preloadMesherWorkerScript(opts?: {
     }
 
     function onError(ev: ErrorEvent) {
-      fail(new MesherWorkerPreloadError(
-        `Mesher worker script failed to load or threw during startup: ${ev.message || 'unknown'} @ ${scriptUrl}`,
-        { phase: 'worker', code: 'script-error', message: ev.message }
-      ))
+      fail(
+        new MesherWorkerPreloadError(`Mesher worker script failed to load or threw during startup: ${ev.message || 'unknown'} @ ${scriptUrl}`, {
+          phase: 'worker',
+          code: 'script-error',
+          message: ev.message
+        })
+      )
     }
 
     function onMessageError() {
-      fail(new MesherWorkerPreloadError(
-        `Mesher worker message channel error (structured clone / deserialization). URL: ${scriptUrl}`,
-        { phase: 'ping', code: 'messageerror' }
-      ))
+      fail(
+        new MesherWorkerPreloadError(`Mesher worker message channel error (structured clone / deserialization). URL: ${scriptUrl}`, {
+          phase: 'ping',
+          code: 'messageerror'
+        })
+      )
     }
 
     worker!.addEventListener('message', onMessage)
@@ -178,10 +183,7 @@ export async function preloadMesherWorkerScript(opts?: {
       worker!.postMessage({ type: 'mc-web-ping', t: performance.now(), workerIndex: 0 })
     } catch (e: unknown) {
       const detail = e instanceof Error ? e.message : String(e)
-      fail(new MesherWorkerPreloadError(
-        `Failed to post mc-web-ping to mesher worker: ${detail}`,
-        { phase: 'ping', code: 'post-failed', detail }
-      ))
+      fail(new MesherWorkerPreloadError(`Failed to post mc-web-ping to mesher worker: ${detail}`, { phase: 'ping', code: 'post-failed', detail }))
     }
   })
 }

package/src/graphicsBackend/rendererDefaultOptions.ts

@@ -24,19 +24,14 @@ export type RendererOptionMeta = {
 
 export type RendererMesherPipeline = 'wasm' | 'legacy-js'
 
-export type RendererShaderCubeDebugMode =
-  | 'off'
-  | 'holes'
-  | 'texIndex'
-  | 'faces'
-  | 'atlasAlpha'
+export type RendererShaderCubeDebugMode = 'off' | 'holes' | 'texIndex' | 'faces' | 'atlasAlpha'
 
 const SHADER_CUBE_DEBUG_MODE_TO_VALUE: Record<RendererShaderCubeDebugMode, number> = {
   off: 0,
   holes: 1,
   texIndex: 2,
   faces: 3,
-  atlasAlpha: 4,
+  atlasAlpha: 4
 }
 
 /** Maps stored option → `inWorldRenderingConfig.shaderCubeDebugMode` (0–4). */
@@ -119,7 +114,7 @@ export function migrateRendererOptions(saved: Record<string, unknown>): void {
     ['menuBackgroundFuturisticCamera', 'menuBackgroundV2Camera'],
     ['menuBackgroundFuturisticBlockGroup', 'menuBackgroundV2BlockGroup'],
     ['menuBackgroundFuturisticCameraSpeed', 'menuBackgroundV2CameraSpeed'],
-    ['menuBackgroundFuturisticBlockSpeed', 'menuBackgroundV2BlockSpeed'],
+    ['menuBackgroundFuturisticBlockSpeed', 'menuBackgroundV2BlockSpeed']
   ]
   for (const [oldKey, newKey] of futuristicToV2) {
     if (saved[oldKey] !== undefined && saved[newKey] === undefined) {
@@ -132,7 +127,10 @@ export function migrateRendererOptions(saved: Record<string, unknown>): void {
 /** Settings UI metadata for {@link RENDERER_DEFAULT_OPTIONS} keys. */
 export const RENDERER_OPTIONS_META: Partial<Record<RendererDefaultOptionKey, RendererOptionMeta>> = {
   menuBackgroundMode: {
-    possibleValues: [['classic', 'Classic'], ['v2', 'V2']],
+    possibleValues: [
+      ['classic', 'Classic'],
+      ['v2', 'V2']
+    ],
     requiresRestart: true
   },
   menuBackgroundMinecraftTextures: {
@@ -191,10 +189,14 @@ export const RENDERER_OPTIONS_META: Partial<Record<RendererDefaultOptionKey, Ren
     tooltip: 'Skips signs, banners, heads, maps, etc.'
   },
   rendererMesher: {
-    possibleValues: [['wasm', 'WASM'], ['legacy-js', 'Legacy JS']],
+    possibleValues: [
+      ['wasm', 'WASM'],
+      ['legacy-js', 'Legacy JS']
+    ],
     text: 'Mesher pipeline',
-    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,
+    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
   },
   rendererShaderCubeDebugMode: {
     text: 'Shader cube debug',
@@ -204,8 +206,8 @@ export const RENDERER_OPTIONS_META: Partial<Record<RendererDefaultOptionKey, Ren
       ['holes', 'Hole test (red)'],
       ['texIndex', 'Tile index colors'],
       ['faces', 'Face id colors'],
-      ['atlasAlpha', 'Atlas alpha'],
-    ],
+      ['atlasAlpha', 'Atlas alpha']
+    ]
   },
   showChunkBorders: {
     text: 'Chunk borders'
@@ -291,59 +293,55 @@ export const RENDERER_RENDER_GUI_SECTIONS: ReadonlyArray<{
   title: string
   keys: readonly RendererDefaultOptionKey[]
 }> = [
-    {
-      title: 'World rendering',
-      keys: [
-        'rendererWorldPerformance',
-        'starfieldRendering',
-        'defaultSkybox',
-        'disableBlockEntityTextures',
-        'showChunkBorders',
-        'renderEntities',
-        'smoothLighting',
-        'vanillaLook',
-        'newVersionsLighting',
-        'dayCycleAndLighting',
-        'loadPlayerSkins',
-        'renderEars',
-        'showHand',
-        'viewBobbing',
-        'fov',
-        'keepChunksDistance',
-        'highlightBlockColor',
-        'clipWorldBelowY'
-      ]
-    },
-    {
-      title: 'Frame pacing',
-      keys: ['frameLimit', 'backgroundRendering', 'renderDebug', 'gpuPreference']
-    },
-    {
-      title: 'VR',
-      keys: ['vrSupport', 'vrPageGameRendering']
-    },
-    {
-      title: 'Menu background',
-      keys: [
-        'menuBackgroundMode',
-        'menuBackgroundMinecraftTextures',
-        'menuBackgroundV2Scene',
-        'menuBackgroundV2Camera',
-        'menuBackgroundV2BlockGroup',
-        'menuBackgroundV2CameraSpeed',
-        'menuBackgroundV2BlockSpeed'
-      ]
-    },
-    {
-      title: 'Mesher',
-      keys: ['rendererMesher']
-    },
-    {
-      title: 'Renderer debug',
-      keys: [
-        'rendererFuturisticReveal',
-        'rendererPerfDebugOverlay',
-        'rendererShaderCubeDebugMode',
-      ]
-    }
-  ]
+  {
+    title: 'World rendering',
+    keys: [
+      'rendererWorldPerformance',
+      'starfieldRendering',
+      'defaultSkybox',
+      'disableBlockEntityTextures',
+      'showChunkBorders',
+      'renderEntities',
+      'smoothLighting',
+      'vanillaLook',
+      'newVersionsLighting',
+      'dayCycleAndLighting',
+      'loadPlayerSkins',
+      'renderEars',
+      'showHand',
+      'viewBobbing',
+      'fov',
+      'keepChunksDistance',
+      'highlightBlockColor',
+      'clipWorldBelowY'
+    ]
+  },
+  {
+    title: 'Frame pacing',
+    keys: ['frameLimit', 'backgroundRendering', 'renderDebug', 'gpuPreference']
+  },
+  {
+    title: 'VR',
+    keys: ['vrSupport', 'vrPageGameRendering']
+  },
+  {
+    title: 'Menu background',
+    keys: [
+      'menuBackgroundMode',
+      'menuBackgroundMinecraftTextures',
+      'menuBackgroundV2Scene',
+      'menuBackgroundV2Camera',
+      'menuBackgroundV2BlockGroup',
+      'menuBackgroundV2CameraSpeed',
+      'menuBackgroundV2BlockSpeed'
+    ]
+  },
+  {
+    title: 'Mesher',
+    keys: ['rendererMesher']
+  },
+  {
+    title: 'Renderer debug',
+    keys: ['rendererFuturisticReveal', 'rendererPerfDebugOverlay', 'rendererShaderCubeDebugMode']
+  }
+]