@tresjs/core 5.3.1 → 5.3.3

package/dist/template-compiler-options.d.mts

@@ -1,6 +1,6 @@
 /**
   * name: @tresjs/core
-  * version: v5.3.1
+  * version: v5.3.3
   * (c) 2026
   * description: Declarative ThreeJS using Vue Components
   * author: Alvaro Saburido <hola@alvarosaburido.dev> (https://github.com/alvarosabu/)

package/dist/template-compiler-options.mjs

@@ -1,6 +1,6 @@
 /**
   * name: @tresjs/core
-  * version: v5.3.1
+  * version: v5.3.3
   * (c) 2026
   * description: Declarative ThreeJS using Vue Components
   * author: Alvaro Saburido <hola@alvarosaburido.dev> (https://github.com/alvarosabu/)

package/dist/tres.d.ts

@@ -1,11 +1,11 @@
 /**
   * name: @tresjs/core
-  * version: v5.3.1
+  * version: v5.3.3
   * (c) 2026
   * description: Declarative ThreeJS using Vue Components
   * author: Alvaro Saburido <hola@alvarosaburido.dev> (https://github.com/alvarosabu/)
   */
-import * as vue9 from "vue";
+import * as vue4 from "vue";
 import { App, ComputedRef, DefineComponent, MaybeRef, MaybeRefOrGetter, Reactive, Ref, ShallowRef, VNode, VNodeRef } from "vue";
 import * as THREE from "three";
 import { BufferGeometry, Camera, Color, ColorRepresentation, ColorSpace, Event, Fog, Group, Layers, Light, Loader, LoadingManager, Material, Mesh, Object3D, Object3DEventMap, OrthographicCamera, PerspectiveCamera, Scene, ShadowMapType, ToneMapping, Vector3, WebGLRenderer } from "three";
@@ -121,6 +121,14 @@ declare const useCameraManager: ({
   sizes
 }: UseCameraParams) => UseCameraReturn;
 //#endregion
+//#region src/utils/error.d.ts
+type TresRendererErrorCode = 'INITIALIZATION_FAILED';
+declare class TresRendererError extends Error {
+  readonly code: TresRendererErrorCode;
+  readonly name = "TresRendererError";
+  constructor(message: string, code: TresRendererErrorCode, options?: ErrorOptions);
+}
+//#endregion
 //#region src/composables/useRenderer/useRendererManager.d.ts
 /**
  * If set to 'on-demand', the scene will only be rendered when the current frame is invalidated
@@ -311,10 +319,13 @@ declare function useRendererManager({
   advance: () => void;
   onReady: _vueuse_core0.EventHookOn<TresRenderer>;
   onRender: _vueuse_core0.EventHookOn<TresRenderer>;
+  onError: _vueuse_core0.EventHookOn<TresRendererError>;
   invalidate: (amountOfFramesToInvalidate?: number) => void;
-  canBeInvalidated: vue9.ComputedRef<boolean>;
+  canBeInvalidated: vue4.ComputedRef<boolean>;
   mode: "always" | "on-demand" | "manual" | undefined;
   replaceRenderFunction: (fn: RenderFunction) => void;
+  isInitialized: vue4.Ref<boolean, boolean>;
+  error: vue4.Ref<TresRendererError | null, TresRendererError | null>;
 };
 type UseRendererManagerReturn = ReturnType<typeof useRendererManager>;
 //#endregion
@@ -499,7 +510,7 @@ declare function buildGraph(object: Object3D | TresObject): TresObjectMap;
 //#endregion
 //#region src/composables/useLoader/component.vue.d.ts
 declare const __VLS_export$1: <T extends TresObjectMap>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-  props: vue9.PublicProps & __VLS_PrettifyLocal<{
+  props: vue4.PublicProps & __VLS_PrettifyLocal<{
     /**
      * The THREE.js loader to use
      */
@@ -522,20 +533,20 @@ declare const __VLS_export$1: <T extends TresObjectMap>(__VLS_props: NonNullable
   attrs: any;
   slots: {
     default?: (props: {
-      state: vue9.UnwrapRef<T>;
+      state: vue4.UnwrapRef<T>;
       isLoading: boolean;
       error: unknown;
     }) => any;
   };
   emit: ((evt: "loaded", result: T) => void) & ((evt: "error", error: unknown) => void);
-}>) => vue9.VNode & {
+}>) => vue4.VNode & {
   __ctx?: Awaited<typeof __VLS_setup>;
 };
 declare const _default$1: typeof __VLS_export$1;
 type __VLS_PrettifyLocal<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
 //#endregion
 //#region src/composables/useGraph/index.d.ts
-declare const useGraph: (object: MaybeRef$1<TresObject | undefined>) => vue9.ComputedRef<TresObjectMap | undefined>;
+declare const useGraph: (object: MaybeRef$1<TresObject | undefined>) => vue4.ComputedRef<TresObjectMap | undefined>;
 //#endregion
 //#region src/utils/createPriorityEventHook.d.ts
 type Callback<T> = Parameters<EventHookOff<T>>[0];
@@ -586,7 +597,7 @@ type LoopContext = RafLoopContext & TresPartialContext;
 declare const useLoop: () => {
   stop: () => void;
   start: () => void;
-  isActive: Readonly<vue9.ShallowRef<boolean>>;
+  isActive: Readonly<vue4.ShallowRef<boolean>>;
   onBeforeRender: PriorityEventHookOn<LoopContext>;
   onRender: PriorityEventHookOn<LoopContext>;
   render: (fn: RenderFunction) => void;
@@ -676,6 +687,7 @@ interface ContextProps extends RendererOptions {
 }
 type ContextEmits = {
   ready: [context: TresContext];
+  error: [error: Error];
   pointermissed: [event: TresPointerEvent];
   render: [context: TresContext];
   beforeLoop: [context: TresContextWithClock];
@@ -692,7 +704,7 @@ interface TresCanvasInstance {
 type __VLS_Slots = {
   default: () => any;
 };
-declare const __VLS_base: vue9.DefineComponent<ContextProps, TresCanvasInstance, {}, {}, {}, vue9.ComponentOptionsMixin, vue9.ComponentOptionsMixin, {
+declare const __VLS_base: vue4.DefineComponent<ContextProps, TresCanvasInstance, {}, {}, {}, vue4.ComponentOptionsMixin, vue4.ComponentOptionsMixin, {
   click: (event: TresPointerEvent) => any;
   contextmenu: (event: TresPointerEvent) => any;
   pointermove: (event: TresPointerEvent) => any;
@@ -706,12 +718,13 @@ declare const __VLS_base: vue9.DefineComponent<ContextProps, TresCanvasInstance,
   pointercancel: (event: TresPointerEvent) => any;
   lostpointercapture: (event: TresPointerEvent) => any;
   wheel: (event: TresPointerEvent) => any;
+  error: (error: Error) => any;
   ready: (context: TresContext) => any;
   pointermissed: (event: TresPointerEvent) => any;
   render: (context: TresContext) => any;
   beforeLoop: (context: TresContextWithClock) => any;
   loop: (context: TresContextWithClock) => any;
-}, string, vue9.PublicProps, Readonly<ContextProps> & Readonly<{
+}, string, vue4.PublicProps, Readonly<ContextProps> & Readonly<{
   onClick?: ((event: TresPointerEvent) => any) | undefined;
   onContextmenu?: ((event: TresPointerEvent) => any) | undefined;
   onPointermove?: ((event: TresPointerEvent) => any) | undefined;
@@ -725,6 +738,7 @@ declare const __VLS_base: vue9.DefineComponent<ContextProps, TresCanvasInstance,
   onPointercancel?: ((event: TresPointerEvent) => any) | undefined;
   onLostpointercapture?: ((event: TresPointerEvent) => any) | undefined;
   onWheel?: ((event: TresPointerEvent) => any) | undefined;
+  onError?: ((error: Error) => any) | undefined;
   onReady?: ((context: TresContext) => any) | undefined;
   onPointermissed?: ((event: TresPointerEvent) => any) | undefined;
   onRender?: ((context: TresContext) => any) | undefined;
@@ -732,7 +746,6 @@ declare const __VLS_base: vue9.DefineComponent<ContextProps, TresCanvasInstance,
   onLoop?: ((context: TresContextWithClock) => any) | undefined;
 }>, {
   windowSize: boolean;
-  enableProvideBridge: boolean;
   antialias: boolean;
   stencil: boolean;
   depth: boolean;
@@ -747,7 +760,8 @@ declare const __VLS_base: vue9.DefineComponent<ContextProps, TresCanvasInstance,
   shadowMapType: THREE.ShadowMapType;
   useLegacyLights: boolean;
   renderMode: "always" | "on-demand" | "manual";
-}, {}, {}, {}, string, vue9.ComponentProvideOptions, false, {}, any>;
+  enableProvideBridge: boolean;
+}, {}, {}, {}, string, vue4.ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 type __VLS_WithSlots<T, S> = T & {
@@ -992,7 +1006,7 @@ declare const isFog: (value: unknown) => value is Fog;
  * }
  * ```
  */
-declare const isScene: (value: unknown) => value is Scene;
+declare const isScene: (value: unknown) => value is Scene<THREE.Object3DEventMap>;
 /**
  * Type guard to check if a value is a Three.js Group
  * @param value - The value to check
@@ -1081,4 +1095,4 @@ interface TresPlugin {
 }
 declare const plugin: TresPlugin;
 //#endregion
-export { Args, AssetLoadData, AttachFnType, AttachType, ConstructorRepresentation, DevtoolsMessage, DevtoolsMessageType, DevtoolsMessenger, DevtoolsSubscriber, DisposeType, ElementProps, InstanceProps, LoaderMethods, LoaderProto, LocalState, LoopContext, MathType, Mutable, NonFunctionKeys, Overwrite, Properties, RenderFunction, RenderMode, RendererOptions, ThreeElement, ThreeInstances, TresCamera, _default as TresCanvas, type TresCanvasEmits, type TresCanvasInstance, type TresCanvasProps, TresCatalogue, TresColor, TresColorArray, TresComponents, type TresContext, TresContextWithClock, TresControl, type TresCustomRendererOptions, TresEuler, TresInstance, TresLayers, TresLoader, TresLoaderOptions, TresMaterial, TresObject, TresObject3D, TresObjectMap, TresOptions, TresPartialContext, TresPlugin, type TresPointerEvent, TresPrimitive, TresQuaternion, TresRenderer, TresRendererSetupContext, TresScene, TresVector2, TresVector3, TresVector4, UseCameraReturn, _default$1 as UseLoader, UseLoaderReturn, UseRendererManagerReturn, UseRendererOptions, VectorCoordinates, type VectorFlexibleParams, VueProps, WithMathProps, buildGraph, catalogue, plugin as default, disposeObject3D as dispose, extend, isBufferGeometry, isCamera, isClassInstance, isColor, isColorRepresentation, isCopyable, isFog, isGroup, isLayers, isLight, isMaterial, isMesh, isObject3D, isOrthographicCamera, isPerspectiveCamera, isProd, isScene, isTresCamera, isTresInstance, isTresObject, isTresPrimitive, isVectorLike, logError, logMessage, logWarning, normalizeColor, normalizeVectorFlexibleParam, registerTresDevtools, templateCompilerOptions, useCameraManager, useGraph, useLoader, useLoop, useRendererManager, useTres, useTresContext, useTresContextProvider, vDistanceTo, vLightHelper, vLog };
+export { Args, AssetLoadData, AttachFnType, AttachType, ConstructorRepresentation, DevtoolsMessage, DevtoolsMessageType, DevtoolsMessenger, DevtoolsSubscriber, DisposeType, ElementProps, InstanceProps, LoaderMethods, LoaderProto, LocalState, LoopContext, MathType, Mutable, NonFunctionKeys, Overwrite, Properties, RenderFunction, RenderMode, RendererOptions, ThreeElement, ThreeInstances, TresCamera, _default as TresCanvas, type TresCanvasEmits, type TresCanvasInstance, type TresCanvasProps, TresCatalogue, TresColor, TresColorArray, TresComponents, type TresContext, TresContextWithClock, TresControl, type TresCustomRendererOptions, TresEuler, TresInstance, TresLayers, TresLoader, TresLoaderOptions, TresMaterial, TresObject, TresObject3D, TresObjectMap, TresOptions, TresPartialContext, TresPlugin, type TresPointerEvent, TresPrimitive, TresQuaternion, TresRenderer, TresRendererError, TresRendererErrorCode, TresRendererSetupContext, TresScene, TresVector2, TresVector3, TresVector4, UseCameraReturn, _default$1 as UseLoader, UseLoaderReturn, UseRendererManagerReturn, UseRendererOptions, VectorCoordinates, type VectorFlexibleParams, VueProps, WithMathProps, buildGraph, catalogue, plugin as default, disposeObject3D as dispose, extend, isBufferGeometry, isCamera, isClassInstance, isColor, isColorRepresentation, isCopyable, isFog, isGroup, isLayers, isLight, isMaterial, isMesh, isObject3D, isOrthographicCamera, isPerspectiveCamera, isProd, isScene, isTresCamera, isTresInstance, isTresObject, isTresPrimitive, isVectorLike, logError, logMessage, logWarning, normalizeColor, normalizeVectorFlexibleParam, registerTresDevtools, templateCompilerOptions, useCameraManager, useGraph, useLoader, useLoop, useRendererManager, useTres, useTresContext, useTresContextProvider, vDistanceTo, vLightHelper, vLog };

package/dist/tres.js

@@ -1,11 +1,11 @@
 /**
   * name: @tresjs/core
-  * version: v5.3.1
+  * version: v5.3.3
   * (c) 2026
   * description: Declarative ThreeJS using Vue Components
   * author: Alvaro Saburido <hola@alvarosaburido.dev> (https://github.com/alvarosabu/)
   */
-import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createRenderer, defineComponent, getCurrentInstance, h, isRef, mergeProps, normalizeClass, normalizeStyle, onMounted, onUnmounted, openBlock, provide, reactive, readonly, ref, renderSlot, shallowRef, toValue, unref, useSlots, watch, watchEffect, withCtx } from "vue";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createRenderer, defineComponent, getCurrentInstance, h, isRef, mergeProps, nextTick, normalizeClass, normalizeStyle, onMounted, onUnmounted, openBlock, provide, reactive, readonly, ref, renderSlot, shallowRef, toValue, unref, useSlots, watch, watchEffect, withCtx } from "vue";
 import * as THREE from "three";
 import { ACESFilmicToneMapping, ArrowHelper, BackSide, BufferAttribute, BufferGeometry, Clock, Color, DirectionalLightHelper, DoubleSide, Float32BufferAttribute, HemisphereLightHelper, Layers, Line, LineBasicMaterial, Material, MathUtils, Mesh, MeshBasicMaterial, Object3D, PCFSoftShadowMap, PerspectiveCamera, PointLightHelper, Scene, SpotLightHelper, Vector3, WebGLRenderer } from "three";
 import { createEventHook, createInjectionState, promiseTimeout, refDebounced, tryOnScopeDispose, unrefElement, useAsyncState, useDevicePixelRatio, useElementSize, useFps, useMemory, useRafFn, useTimeout, useWindowSize, whenever } from "@vueuse/core";
@@ -14,7 +14,7 @@ import { forwardHtmlEvents, getVoidObject } from "@pmndrs/pointer-events";
 import { setupDevtoolsPlugin } from "@vue/devtools-api";
 
 //#region package.json
-var version = "5.3.1";
+var version = "5.3.3";
 
 //#endregion
 //#region src/utils/makeMap.ts
@@ -753,6 +753,16 @@ const useCreateRafLoop = (cycleFn) => {
 	};
 };
 
+//#endregion
+//#region src/utils/error.ts
+var TresRendererError = class extends Error {
+	name = "TresRendererError";
+	constructor(message, code, options) {
+		super(message, options);
+		this.code = code;
+	}
+};
+
 //#endregion
 //#region src/composables/useRenderer/useRendererManager.ts
 function useRendererManager({ scene, canvas, options, contextParts: { sizes, camera } }) {
@@ -795,11 +805,26 @@ function useRendererManager({ scene, canvas, options, contextParts: { sizes, cam
 	const isModeAlways = computed(() => toValue(options.renderMode) === "always");
 	const isRenderer = (value) => isObject(value) && "isRenderer" in value && Boolean(value.isRenderer);
 	const readyEventHook = createEventHook();
+	const errorEventHook = createEventHook();
 	let hasTriggeredReady = false;
-	if (isRenderer(renderer)) {
-		renderer.init();
-		readyEventHook.trigger(renderer);
-	}
+	const isInitialized = ref(false);
+	const error = ref(null);
+	const initializeRenderer = async () => {
+		try {
+			if (isRenderer(renderer)) await renderer.init();
+			isInitialized.value = true;
+		} catch (e) {
+			const rendererError = new TresRendererError(e instanceof Error ? e.message : "Unknown error", "INITIALIZATION_FAILED", { cause: e instanceof Error ? e : void 0 });
+			error.value = rendererError;
+			console.error(`[TresJS] Renderer initialization failed. This may occur if:
+  - WebGPU is not supported by your browser
+  - GPU is not available or lacks required features
+  - GPU drivers are outdated
+Error details: ${rendererError.message}`, rendererError);
+			errorEventHook.trigger(rendererError);
+		}
+	};
+	initializeRenderer();
 	const renderEventHook = createEventHook();
 	const notifyFrameRendered = () => {
 		frames.value = isModeAlways.value ? 1 : Math.max(0, frames.value - 1);
@@ -817,16 +842,26 @@ function useRendererManager({ scene, canvas, options, contextParts: { sizes, cam
 	const loop = useCreateRafLoop(() => {
 		if (frames.value) renderFunction(notifyFrameRendered);
 	});
-	readyEventHook.on(loop.start);
-	watch([sizes.width, sizes.height], () => {
+	readyEventHook.on(() => {
+		if (isInitialized.value) loop.start();
+	});
+	watch([
+		sizes.width,
+		sizes.height,
+		isInitialized
+	], () => {
+		if (!isInitialized.value) return;
 		renderer.setSize(sizes.width.value, sizes.height.value);
 		if (!hasTriggeredReady && renderer.domElement.width && renderer.domElement.height) {
-			readyEventHook.trigger(renderer);
 			hasTriggeredReady = true;
+			nextTick(() => {
+				readyEventHook.trigger(renderer);
+			});
 		}
 		invalidateOnDemand();
 	}, { immediate: true });
 	watchEffect(() => {
+		if (!isInitialized.value) return;
 		setPixelRatio(renderer, sizes.pixelRatio.value, toValue(options.dpr));
 	});
 	if (toValue(options.renderMode) === "on-demand") invalidate();
@@ -846,29 +881,35 @@ function useRendererManager({ scene, canvas, options, contextParts: { sizes, cam
 		};
 	});
 	watchEffect(() => {
+		if (!isInitialized.value) return;
 		const value = clearColorAndAlpha.value;
 		if (value.color === void 0 || value.alpha === void 0) return;
 		renderer.setClearColor(value.color, value.alpha);
 	});
 	watchEffect(() => {
+		if (!isInitialized.value) return;
 		const value = options.toneMapping;
 		if (value) renderer.toneMapping = value;
 	});
 	watchEffect(() => {
+		if (!isInitialized.value) return;
 		const value = options.toneMappingExposure;
 		if (value) renderer.toneMappingExposure = value;
 	});
 	watchEffect(() => {
+		if (!isInitialized.value) return;
 		const value = options.outputColorSpace;
 		if (value) renderer.outputColorSpace = value;
 	});
 	watchEffect(() => {
+		if (!isInitialized.value) return;
 		const value = options.shadows;
 		if (value === void 0) return;
 		renderer.shadowMap.enabled = value;
 		forceMaterialUpdate();
 	});
 	watchEffect(() => {
+		if (!isInitialized.value) return;
 		const value = options.shadowMapType;
 		if (value === void 0) return;
 		renderer.shadowMap.type = value;
@@ -884,10 +925,13 @@ function useRendererManager({ scene, canvas, options, contextParts: { sizes, cam
 		advance,
 		onReady: readyEventHook.on,
 		onRender: renderEventHook.on,
+		onError: errorEventHook.on,
 		invalidate,
 		canBeInvalidated,
 		mode: toValue(options.renderMode),
-		replaceRenderFunction
+		replaceRenderFunction,
+		isInitialized,
+		error
 	};
 }
 
@@ -1924,6 +1968,7 @@ var Context_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ define
 	},
 	emits: [
 		"ready",
+		"error",
 		"pointermissed",
 		"render",
 		"beforeLoop",
@@ -2008,7 +2053,6 @@ var Context_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ define
 		};
 		const { camera, renderer } = context.value;
 		const { registerCamera, cameras, activeCamera, deregisterCamera } = camera;
-		mountCustomRenderer(context.value);
 		const addDefaultCamera = () => {
 			const camera$1 = new PerspectiveCamera(45, window.innerWidth / window.innerHeight, .1, 1e3);
 			camera$1.position.set(3, 3, 3);
@@ -2032,7 +2076,6 @@ var Context_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ define
 				deregisterCamera(toValue(oldCamera));
 			}
 		}, { immediate: true });
-		if (!activeCamera.value) addDefaultCamera();
 		renderer.onRender(() => {
 			if (context.value) emit("render", context.value);
 		});
@@ -2049,7 +2092,12 @@ var Context_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ define
 			});
 		});
 		renderer.onReady(() => {
+			mountCustomRenderer(context.value, false);
 			emit("ready", context.value);
+			if (!activeCamera.value) addDefaultCamera();
+		});
+		renderer.onError((error) => {
+			emit("error", error);
 		});
 		if (import.meta.hot) import.meta.hot.on("vite:afterUpdate", () => handleHMR(context.value));
 		onMounted(async () => {
@@ -2194,6 +2242,7 @@ var TresCanvas_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ def
 	},
 	emits: [
 		"ready",
+		"error",
 		"pointermissed",
 		"render",
 		"beforeLoop",
@@ -2248,23 +2297,24 @@ var TresCanvas_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ def
 				canvas: canvasRef.value
 			}, props, {
 				onReady: _cache[0] || (_cache[0] = ($event) => emit("ready", $event)),
-				onPointermissed: _cache[1] || (_cache[1] = ($event) => emit("pointermissed", $event)),
-				onRender: _cache[2] || (_cache[2] = ($event) => emit("render", $event)),
-				onBeforeLoop: _cache[3] || (_cache[3] = ($event) => emit("beforeLoop", $event)),
-				onLoop: _cache[4] || (_cache[4] = ($event) => emit("loop", $event)),
-				onClick: _cache[5] || (_cache[5] = ($event) => emit("click", $event)),
-				onContextmenu: _cache[6] || (_cache[6] = ($event) => emit("contextmenu", $event)),
-				onPointermove: _cache[7] || (_cache[7] = ($event) => emit("pointermove", $event)),
-				onPointerenter: _cache[8] || (_cache[8] = ($event) => emit("pointerenter", $event)),
-				onPointerleave: _cache[9] || (_cache[9] = ($event) => emit("pointerleave", $event)),
-				onPointerover: _cache[10] || (_cache[10] = ($event) => emit("pointerover", $event)),
-				onPointerout: _cache[11] || (_cache[11] = ($event) => emit("pointerout", $event)),
-				onDblclick: _cache[12] || (_cache[12] = ($event) => emit("dblclick", $event)),
-				onPointerdown: _cache[13] || (_cache[13] = ($event) => emit("pointerdown", $event)),
-				onPointerup: _cache[14] || (_cache[14] = ($event) => emit("pointerup", $event)),
-				onPointercancel: _cache[15] || (_cache[15] = ($event) => emit("pointercancel", $event)),
-				onLostpointercapture: _cache[16] || (_cache[16] = ($event) => emit("lostpointercapture", $event)),
-				onWheel: _cache[17] || (_cache[17] = ($event) => emit("wheel", $event))
+				onError: _cache[1] || (_cache[1] = ($event) => emit("error", $event)),
+				onPointermissed: _cache[2] || (_cache[2] = ($event) => emit("pointermissed", $event)),
+				onRender: _cache[3] || (_cache[3] = ($event) => emit("render", $event)),
+				onBeforeLoop: _cache[4] || (_cache[4] = ($event) => emit("beforeLoop", $event)),
+				onLoop: _cache[5] || (_cache[5] = ($event) => emit("loop", $event)),
+				onClick: _cache[6] || (_cache[6] = ($event) => emit("click", $event)),
+				onContextmenu: _cache[7] || (_cache[7] = ($event) => emit("contextmenu", $event)),
+				onPointermove: _cache[8] || (_cache[8] = ($event) => emit("pointermove", $event)),
+				onPointerenter: _cache[9] || (_cache[9] = ($event) => emit("pointerenter", $event)),
+				onPointerleave: _cache[10] || (_cache[10] = ($event) => emit("pointerleave", $event)),
+				onPointerover: _cache[11] || (_cache[11] = ($event) => emit("pointerover", $event)),
+				onPointerout: _cache[12] || (_cache[12] = ($event) => emit("pointerout", $event)),
+				onDblclick: _cache[13] || (_cache[13] = ($event) => emit("dblclick", $event)),
+				onPointerdown: _cache[14] || (_cache[14] = ($event) => emit("pointerdown", $event)),
+				onPointerup: _cache[15] || (_cache[15] = ($event) => emit("pointerup", $event)),
+				onPointercancel: _cache[16] || (_cache[16] = ($event) => emit("pointercancel", $event)),
+				onLostpointercapture: _cache[17] || (_cache[17] = ($event) => emit("lostpointercapture", $event)),
+				onWheel: _cache[18] || (_cache[18] = ($event) => emit("wheel", $event))
 			}), {
 				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
 				_: 3
@@ -2345,7 +2395,7 @@ const vDistanceTo = {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/three-stdlib@2.36.1_three@0.180.0/node_modules/three-stdlib/helpers/RectAreaLightHelper.js
+//#region ../../node_modules/.pnpm/three-stdlib@2.36.1_three@0.182.0/node_modules/three-stdlib/helpers/RectAreaLightHelper.js
 var RectAreaLightHelper = class extends Line {
 	constructor(light, color) {
 		const positions = [
@@ -2478,4 +2528,4 @@ const plugin = { install(app) {
 var src_default = plugin;
 
 //#endregion
-export { DevtoolsMessenger, TresCanvas_default as TresCanvas, component_default as UseLoader, buildGraph, catalogue, src_default as default, disposeObject3D as dispose, extend, isBufferGeometry, isCamera, isClassInstance, isColor, isColorRepresentation, isCopyable, isFog, isGroup, isLayers, isLight, isMaterial, isMesh, isObject3D, isOrthographicCamera, isPerspectiveCamera, isProd, isScene, isTresCamera, isTresInstance, isTresObject, isTresPrimitive, isVectorLike, logError, logMessage, logWarning, normalizeColor, normalizeVectorFlexibleParam, registerTresDevtools, template_compiler_options_default as templateCompilerOptions, useCameraManager, useGraph, useLoader, useLoop, useRendererManager, useTres, useTresContext, useTresContextProvider, vDistanceTo, vLightHelper, vLog };
+export { DevtoolsMessenger, TresCanvas_default as TresCanvas, TresRendererError, component_default as UseLoader, buildGraph, catalogue, src_default as default, disposeObject3D as dispose, extend, isBufferGeometry, isCamera, isClassInstance, isColor, isColorRepresentation, isCopyable, isFog, isGroup, isLayers, isLight, isMaterial, isMesh, isObject3D, isOrthographicCamera, isPerspectiveCamera, isProd, isScene, isTresCamera, isTresInstance, isTresObject, isTresPrimitive, isVectorLike, logError, logMessage, logWarning, normalizeColor, normalizeVectorFlexibleParam, registerTresDevtools, template_compiler_options_default as templateCompilerOptions, useCameraManager, useGraph, useLoader, useLoop, useRendererManager, useTres, useTresContext, useTresContextProvider, vDistanceTo, vLightHelper, vLog };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tresjs/core",
   "type": "module",
-  "version": "5.3.1",
+  "version": "5.3.3",
   "description": "Declarative ThreeJS using Vue Components",
   "author": "Alvaro Saburido <hola@alvarosaburido.dev> (https://github.com/alvarosabu/)",
   "license": "MIT",
@@ -51,7 +51,7 @@
     "radashi": "^12.6.2"
   },
   "devDependencies": {
-    "@types/three": "^0.180.0",
+    "@types/three": "^0.182.0",
     "@typescript-eslint/eslint-plugin": "^8.42.0",
     "@typescript-eslint/parser": "^8.42.0",
     "@vitejs/plugin-vue": "^6.0.1",
@@ -66,7 +66,7 @@
     "rollup-plugin-analyzer": "^4.0.0",
     "rollup-plugin-copy": "^3.5.0",
     "rollup-plugin-visualizer": "^6.0.3",
-    "three": "^0.180.0",
+    "three": "^0.182.0",
     "tsdown": "0.18.3",
     "typescript": "^5.8.3",
     "vite": "^7.1.9",