angular-three 2.0.0-beta.21 → 2.0.0-beta.223

package/fesm2022/angular-three.mjs

@@ -1,16 +1,19 @@
 import * as i0 from '@angular/core';
-import { untracked, computed, signal, ElementRef, inject, Injector, assertInInjectionContext, runInInjectionContext, DestroyRef, effect, InjectionToken, ChangeDetectorRef, Optional, SkipSelf, ViewContainerRef, NgZone, TemplateRef, Directive, Input, EventEmitter, getDebugNode, RendererFactory2, Injectable, makeEnvironmentProviders, provideZoneChangeDetection, EnvironmentInjector, createEnvironmentInjector, Component, ChangeDetectionStrategy, Output, ViewChild, ContentChild } from '@angular/core';
-import { DOCUMENT, NgForOf, NgIf } from '@angular/common';
-import { Subject, filter } from 'rxjs';
+import { untracked, computed, signal, ElementRef, inject, effect, InjectionToken, Optional, SkipSelf, ViewContainerRef, NgZone, TemplateRef, DestroyRef, Directive, Input, EventEmitter, getDebugNode, RendererFactory2, Injectable, Injector, provideZoneChangeDetection, makeEnvironmentProviders, EnvironmentInjector, afterNextRender, createEnvironmentInjector, Component, ChangeDetectionStrategy, Output, ViewChild, CUSTOM_ELEMENTS_SCHEMA, ContentChild, ChangeDetectorRef, forwardRef } from '@angular/core';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { provideResizeOptions, NgxResize } from 'ngxtension/resize';
 import * as THREE from 'three';
-import { provideNgxResizeOptions, NgxResize } from 'ngx-resize';
+import { DOCUMENT } from '@angular/common';
+import { createInjectionToken } from 'ngxtension/create-injection-token';
+import { Subject, filter } from 'rxjs';
+import { assertInjector } from 'ngxtension/assert-injector';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import * as i1 from '@angular/router';
 import { ActivationEnd, RouterOutlet } from '@angular/router';
 
 const STORE_COMPUTED_KEY = '__ngt_signal_store_computed__';
-const setter = (_source) => (state) => {
-    const updater = (previous) => {
+function reducer(state) {
+    return (previous) => {
         const partial = typeof state === 'function' ? state(previous) : state;
         Object.keys(partial).forEach((key) => {
             const typedKey = key;
@@ -20,83 +23,93 @@ const setter = (_source) => (state) => {
         });
         return partial;
     };
-    untracked(() => {
-        _source.update((previous) => ({ ...previous, ...updater(previous) }));
-    });
-};
-const patcher = (_source) => (state) => {
-    const updater = (previous) => {
-        Object.keys(state).forEach((key) => {
-            const typedKey = key;
-            if (state[typedKey] === undefined && previous[typedKey] != null) {
-                state[typedKey] = previous[typedKey];
-            }
+}
+function updater(_source) {
+    return (state) => {
+        const updater = reducer(state);
+        untracked(() => {
+            _source.update((previous) => ({ ...previous, ...updater(previous) }));
         });
-        return state;
     };
-    untracked(() => {
-        _source.update((previous) => ({ ...updater(previous), ...previous }));
-    });
-};
-const getter = (_source) => (...keys) => {
-    const root = untracked(_source);
-    if (keys.length === 0)
-        return root;
-    return keys.reduce((value, key) => value[key], root);
-};
-const selector = (_state, computedCache) => (...keysAndOptions) => {
-    if (keysAndOptions.length === 0)
-        return _state;
-    if (keysAndOptions.length === 1 && typeof keysAndOptions[0] === 'object') {
-        const cachedKey = STORE_COMPUTED_KEY.concat(JSON.stringify(keysAndOptions[0]));
-        if (!computedCache.has(cachedKey)) {
-            computedCache.set(cachedKey, computed(_state, keysAndOptions));
-        }
-        return computedCache.get(cachedKey);
-    }
-    const [keys, options] = parseStoreOptions(keysAndOptions);
-    const joinedKeys = keys.join('-');
-    const cachedKeys = joinedKeys.concat(options ? JSON.stringify(options) : '');
-    if (!computedCache.has(cachedKeys)) {
-        computedCache.set(cachedKeys, computed(() => keys.reduce((value, key) => value[key], _state()), options));
-    }
-    return computedCache.get(cachedKeys);
-};
+}
+function patcher(_source) {
+    return (state) => {
+        const updater = reducer(state);
+        untracked(() => {
+            _source.update((previous) => ({ ...updater(previous), ...previous }));
+        });
+    };
+}
+function getter(_source) {
+    return (...keys) => {
+        const root = untracked(_source);
+        if (keys.length === 0)
+            return root;
+        return keys.reduce((value, key) => value[key], root);
+    };
+}
+function selector(_state, computedCache) {
+    return (...keysAndOptions) => {
+        if (keysAndOptions.length === 0)
+            return _state;
+        if (keysAndOptions.length === 1 && typeof keysAndOptions[0] === 'object') {
+            const cachedKey = STORE_COMPUTED_KEY.concat(JSON.stringify(keysAndOptions[0]));
+            if (!computedCache.has(cachedKey)) {
+                computedCache.set(cachedKey, computed(_state, keysAndOptions));
+            }
+            return computedCache.get(cachedKey);
+        }
+        const [keys, options] = parseStoreOptions(keysAndOptions);
+        const joinedKeys = keys.join('-');
+        const cachedKeys = joinedKeys.concat(JSON.stringify(options));
+        if (!computedCache.has(cachedKeys)) {
+            computedCache.set(cachedKeys, computed(() => keys.reduce((value, key) => value[key], _state()), options));
+        }
+        return computedCache.get(cachedKeys);
+    };
+}
+function parseStoreOptions(keysAndOptions) {
+    if (typeof keysAndOptions.at(-1) === 'object') {
+        return [keysAndOptions.slice(0, -1), keysAndOptions.at(-1)];
+    }
+    return [keysAndOptions, { equal: Object.is }];
+}
 function signalStore(initialState = {}, options) {
     let source;
-    let set;
+    let update;
     let get;
     let patch;
+    let select;
+    let state;
+    const computedCache = new Map();
+    if (!options) {
+        options = { equal: Object.is };
+    }
     if (typeof initialState === 'function') {
         source = signal({}, options);
+        state = source.asReadonly();
         get = getter(source);
-        set = setter(source);
+        update = updater(source);
         patch = patcher(source);
-        source.set(initialState({ set, get, patch }));
+        select = selector(state, computedCache);
+        source.set(initialState({ update, get, patch, select }));
     }
     else {
         source = signal(initialState, options);
+        state = source.asReadonly();
         get = getter(source);
-        set = setter(source);
+        update = updater(source);
         patch = patcher(source);
+        select = selector(state, computedCache);
     }
-    const state = source.asReadonly();
-    const computedCache = new Map();
-    const store = { select: selector(state, computedCache), get, set, patch, state };
-    // NOTE: internal _snapshot to debug current state
-    Object.defineProperty(store, '_snapshot', {
-        get: state,
+    const store = { select, get, update, patch, state };
+    Object.defineProperty(store, 'snapshot', {
+        get: untracked.bind({}, state),
         configurable: false,
         enumerable: false,
     });
     return store;
 }
-function parseStoreOptions(keysAndOptions) {
-    if (typeof keysAndOptions.at(-1) === 'object') {
-        return [keysAndOptions.slice(0, -1), keysAndOptions.at(-1)];
-    }
-    return [keysAndOptions];
-}
 
 const is = {
     obj: (a) => a === Object(a) && !Array.isArray(a) && typeof a !== 'function',
@@ -105,11 +118,13 @@ const is = {
     orthographicCamera: (a) => !!a && a.isOrthographicCamera,
     perspectiveCamera: (a) => !!a && a.isPerspectiveCamera,
     camera: (a) => !!a && a.isCamera,
-    renderer: (a) => !!a && a instanceof THREE.WebGLRenderer,
+    renderer: (a) => !!a && typeof a === 'object' && 'render' in a && typeof a['render'] === 'function',
     scene: (a) => !!a && a.isScene,
-    object3D: (a) => !!a && a.isObject3D,
-    instance: (a) => !!a && !!a['__ngt__'],
     ref: (a) => a instanceof ElementRef,
+    instance: (a) => !!a && !!a['__ngt__'],
+    object3D: (a) => !!a && a.isObject3D,
+    // instance: (a: unknown): a is NgtInstanceNode => !!a && !!(a as NgtAnyRecord)['__ngt__'],
+    // ref: (a: unknown): a is ElementRef => a instanceof ElementRef,
     colorSpaceExist: (object) => 'colorSpace' in object || 'outputColorSpace' in object,
     equ(a, b, { arrays = 'shallow', objects = 'reference', strict = true } = {}) {
         // Wrong type or one of the two undefined, doesn't match
@@ -172,8 +187,9 @@ function updateCamera(camera, size) {
             camera.top = size.height / 2;
             camera.bottom = size.height / -2;
         }
-        else
+        else {
             camera.aspect = size.width / size.height;
+        }
         camera.updateProjectionMatrix();
         camera.updateMatrixWorld();
     }
@@ -181,11 +197,11 @@ function updateCamera(camera, size) {
 
 function getLocalState(obj) {
     if (!obj)
-        return {};
-    return obj['__ngt__'] || {};
+        return undefined;
+    return obj['__ngt__'];
 }
 function invalidateInstance(instance) {
-    const state = getLocalState(instance).store?.get();
+    const state = getLocalState(instance)?.store.snapshot;
     if (state && state.internal.frames === 0)
         state.invalidate();
     checkUpdate(instance);
@@ -193,37 +209,44 @@ function invalidateInstance(instance) {
 function prepare(object, localState) {
     const instance = object;
     if (localState?.primitive || !instance.__ngt__) {
-        const { objects = signal([]), nonObjects = signal([]), ...rest } = localState || {};
+        const { instanceStore = signalStore({
+            nativeProps: {},
+            parent: null,
+            objects: [],
+            nonObjects: [],
+        }), ...rest } = localState || {};
         instance.__ngt__ = {
             previousAttach: null,
             store: null,
-            parent: signal(null),
             memoized: {},
             eventCount: 0,
             handlers: {},
-            objects,
-            nonObjects,
-            nativeProps: signalStore(),
-            add: (object, type) => {
-                untracked(() => {
-                    const current = instance.__ngt__[type]();
-                    const foundIndex = current.indexOf((obj) => obj === object);
-                    if (foundIndex > -1) {
-                        // if we add an object with the same reference, then we switch it out
-                        current.splice(foundIndex, 1, object);
-                        instance.__ngt__[type].set(current);
-                    }
-                    else {
-                        instance.__ngt__[type].update((prev) => [...prev, object]);
-                    }
-                    notifyAncestors(instance.__ngt__.parent());
-                });
+            instanceStore,
+            parent: instanceStore.select('parent'),
+            objects: instanceStore.select('objects'),
+            nonObjects: instanceStore.select('nonObjects'),
+            nativeProps: instanceStore.select('nativeProps'),
+            add(object, type) {
+                const current = instance.__ngt__.instanceStore.get(type);
+                const foundIndex = current.indexOf((node) => object === node);
+                if (foundIndex > -1) {
+                    current.splice(foundIndex, 1, object);
+                    instance.__ngt__.instanceStore.update({ [type]: current });
+                }
+                else {
+                    instance.__ngt__.instanceStore.update((prev) => ({ [type]: [...prev[type], object] }));
+                }
+                notifyAncestors(instance.__ngt__.instanceStore.get('parent'));
             },
-            remove: (object, type) => {
-                untracked(() => {
-                    instance.__ngt__[type].update((prev) => prev.filter((o) => o !== object));
-                    notifyAncestors(instance.__ngt__.parent());
-                });
+            remove(object, type) {
+                instance.__ngt__.instanceStore.update((prev) => ({ [type]: prev[type].filter((node) => node !== object) }));
+                notifyAncestors(instance.__ngt__.instanceStore.get('parent'));
+            },
+            setNativeProps(key, value) {
+                instance.__ngt__.instanceStore.update((prev) => ({ nativeProps: { ...prev.nativeProps, [key]: value } }));
+            },
+            setParent(parent) {
+                instance.__ngt__.instanceStore.update({ parent });
             },
             ...rest,
         };
@@ -234,146 +257,10 @@ function notifyAncestors(instance) {
     if (!instance)
         return;
     const localState = getLocalState(instance);
-    if (localState.objects)
-        localState.objects.update((prev) => prev);
-    if (localState.nonObjects)
-        localState.nonObjects.update((prev) => prev);
-    notifyAncestors(localState.parent());
-}
-
-// This function prepares a set of changes to be applied to the instance
-function diffProps(instance, props) {
-    const propsEntries = Object.entries(props);
-    const changes = [];
-    for (const [propKey, propValue] of propsEntries) {
-        let key = propKey;
-        if (is.colorSpaceExist(instance)) {
-            if (propKey === 'encoding') {
-                key = 'colorSpace';
-            }
-            else if (propKey === 'outputEncoding') {
-                key = 'outputColorSpace';
-            }
-        }
-        if (is.equ(propValue, instance[key]))
-            continue;
-        changes.push([propKey, propValue]);
-    }
-    return changes;
-}
-// This function applies a set of changes to the instance
-function applyProps(instance, props) {
-    // if props is empty
-    if (!Object.keys(props).length)
-        return instance;
-    // Filter equals, events and reserved props
-    // filter equals, events , and reserved props
-    const localState = getLocalState(instance);
-    const rootState = localState.store?.get();
-    const changes = diffProps(instance, props);
-    for (let i = 0; i < changes.length; i++) {
-        let [key, value] = changes[i];
-        // Alias (output)encoding => (output)colorSpace (since r152)
-        // https://github.com/pmndrs/react-three-fiber/pull/2829
-        if (is.colorSpaceExist(instance)) {
-            const sRGBEncoding = 3001;
-            const SRGBColorSpace = 'srgb';
-            const LinearSRGBColorSpace = 'srgb-linear';
-            if (key === 'encoding') {
-                key = 'colorSpace';
-                value = value === sRGBEncoding ? SRGBColorSpace : LinearSRGBColorSpace;
-            }
-            else if (key === 'outputEncoding') {
-                key = 'outputColorSpace';
-                value = value === sRGBEncoding ? SRGBColorSpace : LinearSRGBColorSpace;
-            }
-        }
-        const currentInstance = instance;
-        const targetProp = currentInstance[key];
-        // special treatmen for objects with support for set/copy, and layers
-        if (targetProp && targetProp['set'] && (targetProp['copy'] || targetProp instanceof THREE.Layers)) {
-            const isColor = targetProp instanceof THREE.Color;
-            // if value is an array
-            if (Array.isArray(value)) {
-                if (targetProp['fromArray'])
-                    targetProp['fromArray'](value);
-                else
-                    targetProp['set'](...value);
-            }
-            // test again target.copy
-            else if (targetProp['copy'] &&
-                value &&
-                value.constructor &&
-                targetProp.constructor.name === value.constructor.name) {
-                targetProp['copy'](value);
-                if (!THREE.ColorManagement && !rootState.linear && isColor)
-                    targetProp['convertSRGBToLinear']();
-            }
-            // if nothing else fits, just set the single value, ignore undefined
-            else if (value !== undefined) {
-                const isColor = targetProp instanceof THREE.Color;
-                // allow setting array scalars
-                if (!isColor && targetProp['setScalar'])
-                    targetProp['setScalar'](value);
-                // layers have no copy function, copy the mask
-                else if (targetProp instanceof THREE.Layers && value instanceof THREE.Layers)
-                    targetProp.mask = value.mask;
-                // otherwise just set ...
-                else
-                    targetProp['set'](value);
-                // auto-convert srgb
-                if (!THREE.ColorManagement && !rootState?.linear && isColor)
-                    targetProp.convertSRGBToLinear();
-            }
-        }
-        // else just overwrite the value
-        else {
-            currentInstance[key] = value;
-            // auto-convert srgb textures
-            if (currentInstance[key] instanceof THREE.Texture &&
-                currentInstance[key].format === THREE.RGBAFormat &&
-                currentInstance[key].type === THREE.UnsignedByteType) {
-                const texture = currentInstance[key];
-                if (rootState?.gl) {
-                    if (is.colorSpaceExist(texture) && is.colorSpaceExist(rootState.gl))
-                        texture.colorSpace = rootState.gl.outputColorSpace;
-                    else
-                        texture.encoding = rootState.gl.outputEncoding;
-                }
-            }
-        }
-        checkUpdate(currentInstance[key]);
-        checkUpdate(targetProp);
-        invalidateInstance(instance);
-    }
-    const instanceHandlers = localState.eventCount;
-    const parent = localState.parent ? untracked(localState.parent) : null;
-    if (parent && rootState.internal && instance['raycast'] && instanceHandlers !== localState.eventCount) {
-        // Pre-emptively remove the instance from the interaction manager
-        const index = rootState.internal.interaction.indexOf(instance);
-        if (index > -1)
-            rootState.internal.interaction.splice(index, 1);
-        // Add the instance to the interaction manager only when it has handlers
-        if (localState.eventCount)
-            rootState.internal.interaction.push(instance);
-    }
-    if (parent && localState.afterUpdate && localState.afterUpdate.observed && changes.length) {
-        localState.afterUpdate.emit(instance);
-    }
-    return instance;
-}
-
-function assertInjectionContext(fn, injector) {
-    try {
-        if (!injector) {
-            return inject(Injector);
-        }
-        return injector;
-    }
-    catch {
-        !injector && assertInInjectionContext(fn);
-        return null;
-    }
+    if (!localState)
+        return;
+    localState.instanceStore.update((prev) => ({ objects: prev.objects, nonObjects: prev.nonObjects }));
+    notifyAncestors(localState.instanceStore.get('parent'));
 }
 
 const idCache = {};
@@ -390,26 +277,28 @@ function makeId(event) {
     return makeId();
 }
 function makeDpr(dpr, window) {
-    const target = window?.devicePixelRatio || 1;
+    // Err on the side of progress by assuming 2x dpr if we can't detect it
+    // This will happen in workers where window is defined but dpr isn't.
+    const target = typeof window !== 'undefined' ? window.devicePixelRatio ?? 2 : 1;
     return Array.isArray(dpr) ? Math.min(Math.max(dpr[0], target), dpr[1]) : dpr;
 }
-function makeDefaultCamera(isOrthographic, size) {
-    if (isOrthographic)
-        return new THREE.OrthographicCamera(0, 0, 0, 0, 0.1, 1000);
-    return new THREE.PerspectiveCamera(75, size.width / size.height, 0.1, 1000);
-}
-function makeDefaultRenderer(glOptions, canvasElement) {
-    const customRenderer = (typeof glOptions === 'function' ? glOptions(canvasElement) : glOptions);
-    if (customRenderer?.render != null)
+function makeRendererInstance(glOptions, canvas) {
+    const customRenderer = (typeof glOptions === 'function' ? glOptions(canvas) : glOptions);
+    if (is.renderer(customRenderer))
         return customRenderer;
     return new THREE.WebGLRenderer({
         powerPreference: 'high-performance',
-        canvas: canvasElement,
+        canvas: canvas,
         antialias: true,
         alpha: true,
-        ...(glOptions || {}),
+        ...glOptions,
     });
 }
+function makeCameraInstance(isOrthographic, size) {
+    if (isOrthographic)
+        return new THREE.OrthographicCamera(0, 0, 0, 0, 0.1, 1000);
+    return new THREE.PerspectiveCamera(75, size.width / size.height, 0.1, 1000);
+}
 function makeObjectGraph(object) {
     const data = { nodes: {}, materials: {} };
     if (object) {
@@ -425,706 +314,62 @@ function makeObjectGraph(object) {
     return data;
 }
 
-const shallowLoose = { objects: 'shallow', strict: false };
-const roots = new Map();
-function injectCanvasRootInitializer(injector) {
-    injector = assertInjectionContext(injectCanvasRootInitializer, injector);
-    return runInInjectionContext(injector, () => {
-        const injectedStore = injectNgtStore();
-        const loop = injectNgtLoop();
-        const destroyRef = inject(DestroyRef);
-        return (canvas) => {
-            const exist = roots.has(canvas);
-            let store = roots.get(canvas);
-            if (store) {
-                console.warn('[NGT] Same canvas root is being created twice');
-            }
-            store ||= injectedStore;
-            if (!store) {
-                throw new Error('[NGT] No store initialized');
-            }
-            if (!exist) {
-                roots.set(canvas, store);
-            }
-            let isConfigured = false;
-            let invalidateRef;
-            destroyRef.onDestroy(() => invalidateRef?.destroy());
-            return {
-                isConfigured,
-                destroy: (timeout = 500) => {
-                    const root = roots.get(canvas);
-                    if (root) {
-                        root.set((state) => ({ internal: { ...state.internal, active: false } }));
-                        setTimeout(() => {
-                            try {
-                                const state = root.get();
-                                state.events.disconnect?.();
-                                state.gl?.renderLists?.dispose?.();
-                                state.gl?.forceContextLoss?.();
-                                if (state.gl?.xr)
-                                    state.xr.disconnect();
-                                dispose(state);
-                                roots.delete(canvas);
-                            }
-                            catch (e) {
-                                console.error('[NGT] Unexpected error while destroying Canvas Root', e);
-                            }
-                        }, timeout);
-                    }
-                },
-                configure: (inputs) => {
-                    const { gl: glOptions, size: sizeOptions, camera: cameraOptions, raycaster: raycasterOptions, scene: sceneOptions, events, orthographic, lookAt, shadows, linear, legacy, flat, dpr, frameloop, performance, } = inputs;
-                    const state = store.get();
-                    const stateToUpdate = {};
-                    // setup renderer
-                    let gl = state.gl;
-                    if (!state.gl)
-                        stateToUpdate.gl = gl = makeDefaultRenderer(glOptions, canvas);
-                    // setup raycaster
-                    let raycaster = state.raycaster;
-                    if (!raycaster)
-                        stateToUpdate.raycaster = raycaster = new THREE.Raycaster();
-                    // set raycaster options
-                    const { params, ...options } = raycasterOptions || {};
-                    if (!is.equ(options, raycaster, shallowLoose))
-                        applyProps(raycaster, { ...options });
-                    if (!is.equ(params, raycaster.params, shallowLoose)) {
-                        applyProps(raycaster, { params: { ...raycaster.params, ...(params || {}) } });
-                    }
-                    // create default camera
-                    if (!state.camera) {
-                        const isCamera = is.camera(cameraOptions);
-                        let camera = isCamera ? cameraOptions : makeDefaultCamera(orthographic || false, state.size);
-                        if (!isCamera) {
-                            if (cameraOptions)
-                                applyProps(camera, cameraOptions);
-                            // set position.z
-                            if (!cameraOptions?.position)
-                                camera.position.z = 5;
-                            // always look at center or passed-in lookAt by default
-                            if (!cameraOptions?.rotation && !cameraOptions?.quaternion) {
-                                if (Array.isArray(lookAt))
-                                    camera.lookAt(lookAt[0], lookAt[1], lookAt[2]);
-                                else if (lookAt instanceof THREE.Vector3)
-                                    camera.lookAt(lookAt);
-                                else
-                                    camera.lookAt(0, 0, 0);
-                            }
-                            // update projection matrix after applyprops
-                            camera.updateProjectionMatrix?.();
-                        }
-                        if (!is.instance(camera))
-                            camera = prepare(camera, { store });
-                        stateToUpdate.camera = camera;
-                    }
-                    // Set up scene (one time only!)
-                    if (!state.scene) {
-                        let scene;
-                        if (sceneOptions instanceof THREE.Scene) {
-                            scene = prepare(sceneOptions, { store });
-                        }
-                        else {
-                            scene = prepare(new THREE.Scene(), { store });
-                            if (sceneOptions)
-                                applyProps(scene, sceneOptions);
-                        }
-                        stateToUpdate.scene = scene;
-                    }
-                    // Set up XR (one time only!)
-                    if (!state.xr) {
-                        // Handle frame behavior in WebXR
-                        const handleXRFrame = (timestamp, frame) => {
-                            const state = store.get();
-                            if (state.frameloop === 'never')
-                                return;
-                            loop.advance(timestamp, true, store, frame);
-                        };
-                        // Toggle render switching on session
-                        const handleSessionChange = () => {
-                            const state = store.get();
-                            state.gl.xr.enabled = state.gl.xr.isPresenting;
-                            state.gl.xr.setAnimationLoop(state.gl.xr.isPresenting ? handleXRFrame : null);
-                            if (!state.gl.xr.isPresenting)
-                                loop.invalidate(store);
-                        };
-                        // WebXR session manager
-                        const xr = {
-                            connect: () => {
-                                gl.xr.addEventListener('sessionstart', handleSessionChange);
-                                gl.xr.addEventListener('sessionend', handleSessionChange);
-                            },
-                            disconnect: () => {
-                                gl.xr.removeEventListener('sessionstart', handleSessionChange);
-                                gl.xr.removeEventListener('sessionend', handleSessionChange);
-                            },
-                        };
-                        // Subscribe to WebXR session events
-                        if (gl.xr && typeof gl.xr.addEventListener === 'function')
-                            xr.connect();
-                        stateToUpdate.xr = xr;
-                    }
-                    // Set shadowmap
-                    if (gl.shadowMap) {
-                        const oldEnabled = gl.shadowMap.enabled;
-                        const oldType = gl.shadowMap.type;
-                        gl.shadowMap.enabled = !!shadows;
-                        if (typeof shadows === 'boolean') {
-                            gl.shadowMap.type = THREE.PCFSoftShadowMap;
-                        }
-                        else if (typeof shadows === 'string') {
-                            const types = {
-                                basic: THREE.BasicShadowMap,
-                                percentage: THREE.PCFShadowMap,
-                                soft: THREE.PCFSoftShadowMap,
-                                variance: THREE.VSMShadowMap,
-                            };
-                            gl.shadowMap.type = types[shadows] ?? THREE.PCFSoftShadowMap;
-                        }
-                        else if (is.obj(shadows)) {
-                            Object.assign(gl.shadowMap, shadows);
-                        }
-                        if (oldEnabled !== gl.shadowMap.enabled || oldType !== gl.shadowMap.type)
-                            checkNeedsUpdate(gl.shadowMap);
-                    }
-                    // Safely set color management if available.
-                    // Avoid accessing THREE.ColorManagement to play nice with older versions
-                    if (THREE.ColorManagement) {
-                        const ColorManagement = THREE.ColorManagement;
-                        if ('enabled' in ColorManagement)
-                            ColorManagement['enabled'] = !legacy ?? false;
-                        else if ('legacyMode' in ColorManagement)
-                            ColorManagement['legacyMode'] = legacy ?? true;
-                    }
-                    // set color space and tonemapping preferences
-                    const LinearEncoding = 3000;
-                    const sRGBEncoding = 3001;
-                    applyProps(gl, {
-                        outputEncoding: linear ? LinearEncoding : sRGBEncoding,
-                        toneMapping: flat ? THREE.NoToneMapping : THREE.ACESFilmicToneMapping,
-                    });
-                    // Update color management state
-                    if (state.legacy !== legacy)
-                        stateToUpdate.legacy = legacy;
-                    if (state.linear !== linear)
-                        stateToUpdate.linear = linear;
-                    if (state.flat !== flat)
-                        stateToUpdate.flat = flat;
-                    // Set gl props
-                    gl.setClearAlpha(0);
-                    gl.setPixelRatio(makeDpr(state.viewport.dpr));
-                    gl.setSize(state.size.width, state.size.height);
-                    if (is.obj(glOptions) &&
-                        !(typeof glOptions === 'function') &&
-                        !is.renderer(glOptions) &&
-                        !is.equ(glOptions, gl, shallowLoose)) {
-                        applyProps(gl, glOptions);
-                    }
-                    // Store events internally
-                    if (events && !state.events.handlers)
-                        stateToUpdate.events = events(store);
-                    // Check performance
-                    if (performance && !is.equ(performance, state.performance, shallowLoose)) {
-                        stateToUpdate.performance = { ...state.performance, ...performance };
-                    }
-                    store.set(stateToUpdate);
-                    // Check size, allow it to take on container bounds initially
-                    const size = computeInitialSize(canvas, sizeOptions);
-                    if (!is.equ(size, state.size, shallowLoose)) {
-                        state.setSize(size.width, size.height, size.top, size.left);
-                    }
-                    // Check pixelratio
-                    if (dpr && state.viewport.dpr !== makeDpr(dpr))
-                        state.setDpr(dpr);
-                    // Check frameloop
-                    if (state.frameloop !== frameloop)
-                        state.setFrameloop(frameloop);
-                    isConfigured = true;
-                    invalidateRef?.destroy();
-                    invalidateRef = effect(() => void store.state().invalidate(), { manualCleanup: true, injector });
-                },
-            };
-        };
-    });
-}
-function computeInitialSize(canvas, defaultSize) {
-    if (defaultSize)
-        return defaultSize;
-    if (canvas instanceof HTMLCanvasElement && canvas.parentElement) {
-        return canvas.parentElement.getBoundingClientRect();
-    }
-    return { width: 0, height: 0, top: 0, left: 0 };
-}
-// Disposes an object and all its properties
-function dispose(obj) {
-    if (obj.dispose && obj.type !== 'Scene')
-        obj.dispose();
-    for (const p in obj) {
-        p.dispose?.();
-        delete obj[p];
-    }
-}
-
-function createInjectFn(token) {
-    return (injectOptions) => inject(token, injectOptions);
-}
-function createProvideFn(token, factory, deps, extraProviders) {
-    return (value) => {
-        let provider;
-        if (value) {
-            provider = { provide: token, useValue: value };
-        }
-        else {
-            provider = { provide: token, useFactory: factory, deps: (deps ?? []) };
-        }
-        return extraProviders ? [extraProviders, provider] : provider;
-    };
-}
-function createInjectionToken(factory, options) {
-    const opts = options ?? { isRoot: true };
-    opts.isRoot ??= true;
-    if (opts.isRoot) {
-        if (opts.token) {
-            throw new Error(`\
-createInjectionToken is creating a root InjectionToken but an external token is passed in.
-`);
-        }
-        const token = new InjectionToken(`Token for ${factory.name}`, {
-            factory: () => {
-                if (opts.deps && Array.isArray(opts.deps)) {
-                    return factory(...opts.deps.map((dep) => inject(dep)));
-                }
-                return factory();
-            },
-        });
-        return [
-            createInjectFn(token),
-            createProvideFn(token, factory, opts.deps),
-            token,
-        ];
-    }
-    const token = opts.token || new InjectionToken(`Token for ${factory.name}`);
-    return [
-        createInjectFn(token),
-        createProvideFn(token, factory, opts.deps, opts.extraProviders),
-        token,
-    ];
-}
-
-function createSubs(callback, subs) {
-    const sub = { callback };
-    subs.add(sub);
-    return () => void subs.delete(sub);
-}
-const globalEffects = new Set();
-const globalAfterEffects = new Set();
-const globalTailEffects = new Set();
-/**
- * Adds a global render callback which is called each frame.
- * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addEffect
- */
-const addEffect = (callback) => createSubs(callback, globalEffects);
-/**
- * Adds a global after-render callback which is called each frame.
- * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addAfterEffect
- */
-const addAfterEffect = (callback) => createSubs(callback, globalAfterEffects);
-/**
- * Adds a global callback which is called when rendering stops.
- * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addTail
- */
-const addTail = (callback) => createSubs(callback, globalTailEffects);
-function run(effects, timestamp) {
-    if (!effects.size)
-        return;
-    for (const { callback } of effects.values()) {
-        callback(timestamp);
-    }
-}
-function flushGlobalEffects(type, timestamp) {
-    switch (type) {
-        case 'before':
-            return run(globalEffects, timestamp);
-        case 'after':
-            return run(globalAfterEffects, timestamp);
-        case 'tail':
-            return run(globalTailEffects, timestamp);
-    }
-}
-function render(timestamp, store, frame) {
-    const state = store.get();
-    // Run local effects
-    let delta = state.clock.getDelta();
-    // In frameloop='never' mode, clock times are updated using the provided timestamp
-    if (state.frameloop === 'never' && typeof timestamp === 'number') {
-        delta = timestamp - state.clock.elapsedTime;
-        state.clock.oldTime = state.clock.elapsedTime;
-        state.clock.elapsedTime = timestamp;
-    }
-    // Call subscribers (useFrame)
-    const subscribers = state.internal.subscribers;
-    for (let i = 0; i < subscribers.length; i++) {
-        const subscription = subscribers[i];
-        subscription.callback({ ...subscription.store.get(), delta, frame });
-    }
-    // Render content
-    if (!state.internal.priority && state.gl.render)
-        state.gl.render(state.scene, state.camera);
-    // Decrease frame count
-    state.internal.frames = Math.max(0, state.internal.frames - 1);
-    return state.frameloop === 'always' ? 1 : state.internal.frames;
-}
-function createLoop(roots) {
-    let running = false;
-    let repeat;
-    let frame;
-    function loop(timestamp) {
-        frame = requestAnimationFrame(loop);
-        running = true;
-        repeat = 0;
-        // Run effects
-        flushGlobalEffects('before', timestamp);
-        // Render all roots
-        for (const root of roots.values()) {
-            const state = root.get();
-            // If the frameloop is invalidated, do not run another frame
-            if (state.internal.active &&
-                (state.frameloop === 'always' || state.internal.frames > 0) &&
-                !state.gl.xr?.isPresenting) {
-                repeat += render(timestamp, root);
-            }
-        }
-        // Run after-effects
-        flushGlobalEffects('after', timestamp);
-        // Stop the loop if nothing invalidates it
-        if (repeat === 0) {
-            // Tail call effects, they are called when rendering stops
-            flushGlobalEffects('tail', timestamp);
-            // Flag end of operation
-            running = false;
-            return cancelAnimationFrame(frame);
-        }
-    }
-    function invalidate(store, frames = 1) {
-        const state = store?.get();
-        if (!state)
-            return roots.forEach((root) => invalidate(root, frames));
-        if (state.gl.xr?.isPresenting || !state.internal.active || state.frameloop === 'never')
-            return;
-        // Increase frames, do not go higher than 60
-        state.internal.frames = Math.min(60, state.internal.frames + frames);
-        // If the render-loop isn't active, start it
-        if (!running) {
-            running = true;
-            requestAnimationFrame(loop);
-        }
-    }
-    function advance(timestamp, runGlobalEffects = true, store, frame) {
-        if (runGlobalEffects)
-            flushGlobalEffects('before', timestamp);
-        const state = store?.get();
-        if (!state)
-            for (const root of roots.values())
-                render(timestamp, root);
-        else
-            render(timestamp, store, frame);
-        if (runGlobalEffects)
-            flushGlobalEffects('after', timestamp);
-    }
-    return {
-        loop,
-        /**
-         * Invalidates the view, requesting a frame to be rendered. Will globally invalidate unless passed a root's state.
-         * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#invalidate
-         */
-        invalidate,
-        /**
-         * Advances the frameloop and runs render effects, useful for when manually rendering via `frameloop="never"`.
-         * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#advance
-         */
-        advance,
-    };
-}
-const [injectNgtLoop, , NGT_LOOP] = createInjectionToken(() => createLoop(roots));
-
-function safeDetectChanges(...cdrs) {
-    cdrs.forEach((cdr) => {
-        if (!cdr)
-            return;
-        try {
-            // dynamic created component with ViewContainerRef#createComponent does not have Context
-            // but it has _attachedToViewContainer
-            if (cdr['_attachedToViewContainer'] || !!cdr['context']) {
-                cdr.detectChanges();
-            }
-        }
-        catch (e) {
-            cdr.markForCheck();
-        }
-    });
-}
-
-function storeFactory(loop, document, injector, parent) {
-    return runInInjectionContext(injector, () => {
-        const window = document.defaultView;
-        if (!window) {
-            // TODO: revisit this when we need to support multiple platforms
-            throw new Error(`[NGT] Window is not available.`);
-        }
-        const cdr = inject(ChangeDetectorRef);
-        // NOTE: using Subject because we do not care about late-subscribers
-        const pointerMissed$ = new Subject();
-        const store = signalStore(({ get, set }) => {
-            const { invalidate, advance } = loop;
-            const position = new THREE.Vector3();
-            const defaultTarget = new THREE.Vector3();
-            const tempTarget = new THREE.Vector3();
-            function getCurrentViewport(camera = get('camera'), target = defaultTarget, size = get('size')) {
-                const { width, height, top, left } = size;
-                const aspect = width / height;
-                if (target instanceof THREE.Vector3)
-                    tempTarget.copy(target);
-                else
-                    tempTarget.set(...target);
-                const distance = camera.getWorldPosition(position).distanceTo(tempTarget);
-                if (is.orthographicCamera(camera)) {
-                    return {
-                        width: width / camera.zoom,
-                        height: height / camera.zoom,
-                        top,
-                        left,
-                        factor: 1,
-                        distance,
-                        aspect,
-                    };
-                }
-                else {
-                    const fov = (camera.fov * Math.PI) / 180; // convert vertical fov to radians
-                    const h = 2 * Math.tan(fov / 2) * distance; // visible height
-                    const w = h * (width / height);
-                    return { width: w, height: h, top, left, factor: width / w, distance, aspect };
-                }
-            }
-            let performanceTimeout = undefined;
-            const setPerformanceCurrent = (current) => set((state) => ({ performance: { ...state.performance, current } }));
-            const pointer = new THREE.Vector2();
-            return {
-                pointerMissed$: pointerMissed$.asObservable(),
-                events: { priority: 1, enabled: true, connected: false },
-                invalidate: (frames = 1) => invalidate(store, frames),
-                advance: (timestamp, runGlobalEffects) => advance(timestamp, runGlobalEffects, store),
-                legacy: false,
-                linear: false,
-                flat: false,
-                controls: null,
-                clock: new THREE.Clock(),
-                pointer,
-                frameloop: 'always',
-                performance: {
-                    current: 1,
-                    min: 0.5,
-                    max: 1,
-                    debounce: 200,
-                    regress: () => {
-                        const state = get();
-                        // Clear timeout
-                        if (performanceTimeout)
-                            clearTimeout(performanceTimeout);
-                        // Set lower bound performance
-                        if (state.performance.current !== state.performance.min)
-                            setPerformanceCurrent(state.performance.min);
-                        // Go back to upper bound performance after a while unless something regresses meanwhile
-                        performanceTimeout = setTimeout(() => {
-                            setPerformanceCurrent(get('performance', 'max'));
-                            safeDetectChanges(cdr);
-                        }, state.performance.debounce);
-                    },
-                },
-                size: { width: 0, height: 0, top: 0, left: 0, updateStyle: false },
-                viewport: {
-                    initialDpr: 0,
-                    dpr: 0,
-                    width: 0,
-                    height: 0,
-                    top: 0,
-                    left: 0,
-                    aspect: 0,
-                    distance: 0,
-                    factor: 0,
-                    getCurrentViewport,
-                },
-                setEvents: (events) => set((state) => ({ ...state, events: { ...state.events, ...events } })),
-                setSize: (width, height, top, left) => {
-                    const camera = get('camera');
-                    const size = { width, height, top: top || 0, left: left || 0 };
-                    set((state) => ({
-                        size,
-                        viewport: { ...state.viewport, ...getCurrentViewport(camera, defaultTarget, size) },
-                    }));
-                },
-                setDpr: (dpr) => set((state) => {
-                    const resolved = makeDpr(dpr, window);
-                    return {
-                        viewport: {
-                            ...state.viewport,
-                            dpr: resolved,
-                            initialDpr: state.viewport.initialDpr || resolved,
-                        },
-                    };
-                }),
-                setFrameloop: (frameloop = 'always') => {
-                    const clock = get('clock');
-                    // if frameloop === "never" clock.elapsedTime is updated using advance(timestamp)
-                    clock.stop();
-                    clock.elapsedTime = 0;
-                    if (frameloop !== 'never') {
-                        clock.start();
-                        clock.elapsedTime = 0;
-                    }
-                    set(() => ({ frameloop }));
-                },
-                previousRoot: parent,
-                internal: {
-                    active: false,
-                    priority: 0,
-                    frames: 0,
-                    lastEvent: new ElementRef(null),
-                    interaction: [],
-                    hovered: new Map(),
-                    subscribers: [],
-                    initialClick: [0, 0],
-                    initialHits: [],
-                    capturedMap: new Map(),
-                    subscribe: (callback, priority = 0, _store = store) => {
-                        const internal = get('internal');
-                        // If this subscription was given a priority, it takes rendering into its own hands
-                        // For that reason we switch off automatic rendering and increase the manual flag
-                        // As long as this flag is positive there can be no internal rendering at all
-                        // because there could be multiple render subscriptions
-                        internal.priority = internal.priority + (priority > 0 ? 1 : 0);
-                        internal.subscribers.push({ callback, priority, store });
-                        // Register subscriber and sort layers from lowest to highest, meaning,
-                        // highest priority renders last (on top of the other frames)
-                        internal.subscribers = internal.subscribers.sort((a, b) => (a.priority || 0) - (b.priority || 0));
-                        return () => {
-                            const internal = get('internal');
-                            if (internal?.subscribers) {
-                                // Decrease manual flag if this subscription had a priority
-                                internal.priority = internal.priority - (priority > 0 ? 1 : 0);
-                                // Remove subscriber from list
-                                internal.subscribers = internal.subscribers.filter((s) => s.callback !== callback);
-                            }
-                        };
-                    },
-                },
-            };
-        });
-        // NOTE: assign pointerMissed$ so we can use it in events
-        Object.defineProperty(store, 'pointerMissed$', { get: () => pointerMissed$ });
-        const state = store.get();
-        let oldSize = state.size;
-        let oldDpr = state.viewport.dpr;
-        let oldCamera = state.camera;
-        const _camera = store.select('camera');
-        const _size = store.select('size');
-        const _viewport = store.select('viewport');
-        effect(() => {
-            const [camera, size, viewport, gl] = [_camera(), _size(), _viewport(), store.get('gl')];
-            // Resize camera and renderer on changes to size and pixelratio
-            if (size !== oldSize || viewport.dpr !== oldDpr) {
-                oldSize = size;
-                oldDpr = viewport.dpr;
-                // Update camera & renderer
-                updateCamera(camera, size);
-                gl.setPixelRatio(viewport.dpr);
-                const updateStyle = typeof HTMLCanvasElement !== 'undefined' && gl.domElement instanceof HTMLCanvasElement;
-                gl.setSize(size.width, size.height, updateStyle);
-            }
-            // Update viewport once the camera changes
-            if (camera !== oldCamera) {
-                oldCamera = camera;
-                updateCamera(camera, size);
-                // Update viewport
-                store.set((state) => ({
-                    viewport: { ...state.viewport, ...state.viewport.getCurrentViewport(camera) },
-                }));
-            }
-        });
-        return store;
-    });
-}
-const NGT_STORE = new InjectionToken('NgtStore token');
-const [injectNgtStore, provideNgtStore] = createInjectionToken(storeFactory, {
-    isRoot: false,
-    deps: [NGT_LOOP, DOCUMENT, Injector, [new Optional(), new SkipSelf(), NGT_STORE]],
-    token: NGT_STORE,
-});
-
-function injectBeforeRender(cb, { priority = 0, injector } = {}) {
-    injector = assertInjectionContext(injectBeforeRender, injector);
-    return runInInjectionContext(injector, () => {
-        const store = injectNgtStore();
-        const sub = store.get('internal').subscribe(cb, priority, store);
-        inject(DestroyRef).onDestroy(() => void sub());
-        return sub;
-    });
-}
-
-/**
- * Release pointer captures.
- * This is called by releasePointerCapture in the API, and when an object is removed.
- */
-function releaseInternalPointerCapture(capturedMap, obj, captures, pointerId) {
-    const captureData = captures.get(obj);
-    if (captureData) {
-        captures.delete(obj);
-        // If this was the last capturing object for this pointer
-        if (captures.size === 0) {
-            capturedMap.delete(pointerId);
-            captureData.target.releasePointerCapture(pointerId);
-        }
-    }
-}
-function removeInteractivity(store, object) {
-    const { internal } = store.get();
-    // Removes every trace of an object from the data store
-    internal.interaction = internal.interaction.filter((o) => o !== object);
-    internal.initialHits = internal.initialHits.filter((o) => o !== object);
-    internal.hovered.forEach((value, key) => {
-        if (value.eventObject === object || value.object === object) {
-            // Clear out intersects, they are outdated by now
-            internal.hovered.delete(key);
-        }
-    });
-    internal.capturedMap.forEach((captures, pointerId) => {
-        releaseInternalPointerCapture(internal.capturedMap, object, captures, pointerId);
-    });
-}
-function createEvents(store) {
-    /** Calculates delta */
-    function calculateDistance(event) {
-        const internal = store.get('internal');
-        const dx = event.offsetX - internal.initialClick[0];
-        const dy = event.offsetY - internal.initialClick[1];
-        return Math.round(Math.sqrt(dx * dx + dy * dy));
-    }
-    /** Returns true if an instance has a valid pointer-event registered, this excludes scroll, clicks etc */
-    function filterPointerEvents(objects) {
-        return objects.filter((obj) => ['move', 'over', 'enter', 'out', 'leave'].some((name) => {
-            const eventName = `pointer${name}`;
-            return getLocalState(obj).handlers?.[eventName];
-        }));
-    }
-    function intersect(event, filter) {
-        const state = store.get();
-        const duplicates = new Set();
-        const intersections = [];
-        // Allow callers to eliminate event objects
-        const eventsObjects = filter ? filter(state.internal.interaction) : state.internal.interaction;
-        // Reset all raycaster cameras to undefined
-        for (let i = 0; i < eventsObjects.length; i++) {
-            const state = getLocalState(eventsObjects[i]).store.get();
-            if (state) {
-                state.raycaster.camera = undefined;
+/**
+ * Release pointer captures.
+ * This is called by releasePointerCapture in the API, and when an object is removed.
+ */
+function releaseInternalPointerCapture(capturedMap, obj, captures, pointerId) {
+    const captureData = captures.get(obj);
+    if (captureData) {
+        captures.delete(obj);
+        // If this was the last capturing object for this pointer
+        if (captures.size === 0) {
+            capturedMap.delete(pointerId);
+            captureData.target.releasePointerCapture(pointerId);
+        }
+    }
+}
+function removeInteractivity(store, object) {
+    const { internal } = store.snapshot;
+    // Removes every trace of an object from the data store
+    internal.interaction = internal.interaction.filter((o) => o !== object);
+    internal.initialHits = internal.initialHits.filter((o) => o !== object);
+    internal.hovered.forEach((value, key) => {
+        if (value.eventObject === object || value.object === object) {
+            // Clear out intersects, they are outdated by now
+            internal.hovered.delete(key);
+        }
+    });
+    internal.capturedMap.forEach((captures, pointerId) => {
+        releaseInternalPointerCapture(internal.capturedMap, object, captures, pointerId);
+    });
+}
+function createEvents(store) {
+    /** Calculates delta */
+    function calculateDistance(event) {
+        const internal = store.get('internal');
+        const dx = event.offsetX - internal.initialClick[0];
+        const dy = event.offsetY - internal.initialClick[1];
+        return Math.round(Math.sqrt(dx * dx + dy * dy));
+    }
+    /** Returns true if an instance has a valid pointer-event registered, this excludes scroll, clicks etc */
+    function filterPointerEvents(objects) {
+        return objects.filter((obj) => ['move', 'over', 'enter', 'out', 'leave'].some((name) => {
+            const eventName = `pointer${name}`;
+            return getLocalState(obj)?.handlers?.[eventName];
+        }));
+    }
+    function intersect(event, filter) {
+        const state = store.get();
+        const duplicates = new Set();
+        const intersections = [];
+        // Allow callers to eliminate event objects
+        const eventsObjects = filter ? filter(state.internal.interaction) : state.internal.interaction;
+        // Reset all raycaster cameras to undefined
+        for (let i = 0; i < eventsObjects.length; i++) {
+            const state = getLocalState(eventsObjects[i])?.store.snapshot;
+            if (state) {
+                state.raycaster.camera = undefined;
             }
         }
         if (!state.previousRoot) {
@@ -1133,8 +378,8 @@ function createEvents(store) {
         }
         function handleRaycast(obj) {
             const objLocalState = getLocalState(obj);
-            const objStore = objLocalState.store;
-            const objState = objStore?.get();
+            const objStore = objLocalState?.store;
+            const objState = objStore?.snapshot;
             // Skip event handling when noEvents is set, or when the raycasters camera is null
             if (!objState || !objState.events.enabled || objState.raycaster.camera === null)
                 return [];
@@ -1154,8 +399,8 @@ function createEvents(store) {
             .flatMap(handleRaycast)
             // Sort by event priority and distance
             .sort((a, b) => {
-            const aState = getLocalState(a.object).store.get();
-            const bState = getLocalState(b.object).store.get();
+            const aState = getLocalState(a.object)?.store?.snapshot;
+            const bState = getLocalState(b.object)?.store?.snapshot;
             if (!aState || !bState)
                 return a.distance - b.distance;
             return bState.events.priority - aState.events.priority || a.distance - b.distance;
@@ -1177,7 +422,7 @@ function createEvents(store) {
             let eventObject = hit.object;
             // bubble event up
             while (eventObject) {
-                if (getLocalState(eventObject).eventCount) {
+                if (getLocalState(eventObject)?.eventCount) {
                     intersections.push({ ...hit, eventObject });
                 }
                 eventObject = eventObject.parent;
@@ -1185,7 +430,7 @@ function createEvents(store) {
         }
         // If the interaction is captured, make all capturing targets part of the intersect.
         if ('pointerId' in event && state.internal.capturedMap.has(event.pointerId)) {
-            for (let captureData of state.internal.capturedMap.get(event.pointerId).values()) {
+            for (const captureData of state.internal.capturedMap.get(event.pointerId).values()) {
                 if (!duplicates.has(makeId(captureData.intersection)))
                     intersections.push(captureData.intersection);
             }
@@ -1194,13 +439,12 @@ function createEvents(store) {
     }
     /**  Handles intersections by forwarding them to handlers */
     function handleIntersects(intersections, event, delta, callback) {
-        const rootState = store.get();
+        const rootState = store.snapshot;
         // If anything has been found, forward it to the event listeners
         if (intersections.length) {
             const localState = { stopped: false };
             for (const hit of intersections) {
-                const state = getLocalState(hit.object).store?.get() || rootState;
-                const { raycaster, pointer, camera, internal } = state;
+                const { raycaster, pointer, camera, internal } = getLocalState(hit.object)?.store?.snapshot || rootState;
                 const unprojectedPoint = new THREE.Vector3(pointer.x, pointer.y, 0).unproject(camera);
                 const hasPointerCapture = (id) => internal.capturedMap.get(id)?.has(hit.eventObject) ?? false;
                 const setPointerCapture = (id) => {
@@ -1228,8 +472,8 @@ function createEvents(store) {
                 // Add native event props
                 const extractEventProps = {};
                 // This iterates over the event's properties including the inherited ones. Native PointerEvents have most of their props as getters which are inherited, but polyfilled PointerEvents have them all as their own properties (i.e. not inherited). We can't use Object.keys() or Object.entries() as they only return "own" properties; nor Object.getPrototypeOf(event) as that *doesn't* return "own" properties, only inherited ones.
-                for (let prop in event) {
-                    let property = event[prop];
+                for (const prop in event) {
+                    const property = event[prop];
                     // Only copy over atomics, leave functions alone as these should be
                     // called as event.nativeEvent.fn()
                     if (typeof property !== 'function')
@@ -1275,289 +519,897 @@ function createEvents(store) {
                 // Call subscribers
                 callback(raycastEvent);
                 // Event bubbling may be interrupted by stopPropagation
-                if (localState.stopped === true)
+                if (localState.stopped)
                     break;
             }
         }
-        return intersections;
-    }
-    function cancelPointer(intersections) {
-        const internal = store.get('internal');
-        for (const hoveredObj of internal.hovered.values()) {
-            // When no objects were hit or the the hovered object wasn't found underneath the cursor
-            // we call onPointerOut and delete the object from the hovered-elements map
-            if (!intersections.length ||
-                !intersections.find((hit) => hit.object === hoveredObj.object &&
-                    hit.index === hoveredObj.index &&
-                    hit.instanceId === hoveredObj.instanceId)) {
-                const eventObject = hoveredObj.eventObject;
-                const instance = getLocalState(eventObject);
-                const handlers = instance?.handlers;
-                internal.hovered.delete(makeId(hoveredObj));
-                if (instance?.eventCount) {
-                    // Clear out intersects, they are outdated by now
-                    const data = { ...hoveredObj, intersections };
-                    handlers?.pointerout?.(data);
-                    handlers?.pointerleave?.(data);
+        return intersections;
+    }
+    function cancelPointer(intersections) {
+        const internal = store.get('internal');
+        for (const hoveredObj of internal.hovered.values()) {
+            // When no objects were hit or the the hovered object wasn't found underneath the cursor
+            // we call onPointerOut and delete the object from the hovered-elements map
+            if (!intersections.length ||
+                !intersections.find((hit) => hit.object === hoveredObj.object &&
+                    hit.index === hoveredObj.index &&
+                    hit.instanceId === hoveredObj.instanceId)) {
+                const eventObject = hoveredObj.eventObject;
+                const instance = getLocalState(eventObject);
+                const handlers = instance?.handlers;
+                internal.hovered.delete(makeId(hoveredObj));
+                if (instance?.eventCount) {
+                    // Clear out intersects, they are outdated by now
+                    const data = { ...hoveredObj, intersections };
+                    handlers?.pointerout?.(data);
+                    handlers?.pointerleave?.(data);
+                }
+            }
+        }
+    }
+    function pointerMissed(event, objects) {
+        for (let i = 0; i < objects.length; i++) {
+            const instance = getLocalState(objects[i]);
+            instance?.handlers.pointermissed?.(event);
+        }
+    }
+    function handlePointer(name) {
+        // Deal with cancelation
+        switch (name) {
+            case 'pointerleave':
+            case 'pointercancel':
+                return () => cancelPointer([]);
+            case 'lostpointercapture':
+                return (event) => {
+                    const { internal } = store.snapshot;
+                    if ('pointerId' in event && internal.capturedMap.has(event.pointerId)) {
+                        // If the object event interface had lostpointercapture, we'd call it here on every
+                        // object that's getting removed. We call it on the next frame because lostpointercapture
+                        // fires before pointerup. Otherwise pointerUp would never be called if the event didn't
+                        // happen in the object it originated from, leaving components in a in-between state.
+                        requestAnimationFrame(() => {
+                            // Only release if pointer-up didn't do it already
+                            if (internal.capturedMap.has(event.pointerId)) {
+                                internal.capturedMap.delete(event.pointerId);
+                                cancelPointer([]);
+                            }
+                        });
+                    }
+                };
+        }
+        // Any other pointer goes here ...
+        return function handleEvent(event) {
+            const pointerMissed$ = store['pointerMissed$'];
+            const internal = store.get('internal');
+            // prepareRay(event)
+            internal.lastEvent.nativeElement = event;
+            // Get fresh intersects
+            const isPointerMove = name === 'pointermove';
+            const isClickEvent = name === 'click' || name === 'contextmenu' || name === 'dblclick';
+            const filter = isPointerMove ? filterPointerEvents : undefined;
+            const hits = intersect(event, filter);
+            const delta = isClickEvent ? calculateDistance(event) : 0;
+            // Save initial coordinates on pointer-down
+            if (name === 'pointerdown') {
+                internal.initialClick = [event.offsetX, event.offsetY];
+                internal.initialHits = hits.map((hit) => hit.eventObject);
+            }
+            // If a click yields no results, pass it back to the user as a miss
+            // Missed events have to come first in order to establish user-land side-effect clean up
+            if (isClickEvent && !hits.length) {
+                if (delta <= 2) {
+                    pointerMissed(event, internal.interaction);
+                    pointerMissed$.next(event);
+                }
+            }
+            // Take care of unhover
+            if (isPointerMove)
+                cancelPointer(hits);
+            function onIntersect(data) {
+                const eventObject = data.eventObject;
+                const instance = getLocalState(eventObject);
+                const handlers = instance?.handlers;
+                // Check presence of handlers
+                if (!instance?.eventCount)
+                    return;
+                /*
+        MAYBE TODO, DELETE IF NOT:
+          Check if the object is captured, captured events should not have intersects running in parallel
+          But wouldn't it be better to just replace capturedMap with a single entry?
+          Also, are we OK with straight up making picking up multiple objects impossible?
+
+        const pointerId = (data as ThreeEvent<PointerEvent>).pointerId
+        if (pointerId !== undefined) {
+          const capturedMeshSet = internal.capturedMap.get(pointerId)
+          if (capturedMeshSet) {
+            const captured = capturedMeshSet.get(eventObject)
+            if (captured && captured.localState.stopped) return
+          }
+        }*/
+                if (isPointerMove) {
+                    // Move event ...
+                    if (handlers?.pointerover || handlers?.pointerenter || handlers?.pointerout || handlers?.pointerleave) {
+                        // When enter or out is present take care of hover-state
+                        const id = makeId(data);
+                        const hoveredItem = internal.hovered.get(id);
+                        if (!hoveredItem) {
+                            // If the object wasn't previously hovered, book it and call its handler
+                            internal.hovered.set(id, data);
+                            handlers.pointerover?.(data);
+                            handlers.pointerenter?.(data);
+                        }
+                        else if (hoveredItem.stopped) {
+                            // If the object was previously hovered and stopped, we shouldn't allow other items to proceed
+                            data.stopPropagation();
+                        }
+                    }
+                    // Call mouse move
+                    handlers?.pointermove?.(data);
+                }
+                else {
+                    // All other events ...
+                    const handler = handlers?.[name];
+                    if (handler) {
+                        // Forward all events back to their respective handlers with the exception of click events,
+                        // which must use the initial target
+                        if (!isClickEvent || internal.initialHits.includes(eventObject)) {
+                            // Missed events have to come first
+                            pointerMissed(event, internal.interaction.filter((object) => !internal.initialHits.includes(object)));
+                            // Now call the handler
+                            handler(data);
+                        }
+                    }
+                    else {
+                        // Trigger onPointerMissed on all elements that have pointer over/out handlers, but not click and weren't hit
+                        if (isClickEvent && internal.initialHits.includes(eventObject)) {
+                            pointerMissed(event, internal.interaction.filter((object) => !internal.initialHits.includes(object)));
+                        }
+                    }
+                }
+            }
+            handleIntersects(hits, event, delta, onIntersect);
+        };
+    }
+    return { handlePointer };
+}
+
+const DOM_EVENTS = {
+    click: false,
+    contextmenu: false,
+    dblclick: false,
+    wheel: false, // passive wheel errors with OrbitControls
+    pointerdown: true,
+    pointerup: true,
+    pointerleave: true,
+    pointermove: true,
+    pointercancel: true,
+    lostpointercapture: true,
+};
+const supportedEvents = [
+    'click',
+    'contextmenu',
+    'dblclick',
+    'pointerup',
+    'pointerdown',
+    'pointerover',
+    'pointerout',
+    'pointerenter',
+    'pointerleave',
+    'pointermove',
+    'pointermissed',
+    'pointercancel',
+    'wheel',
+];
+function createPointerEvents(store) {
+    const { handlePointer } = createEvents(store);
+    return {
+        priority: 1,
+        enabled: true,
+        compute: (event, root) => {
+            const state = root.get();
+            // https://github.com/pmndrs/react-three-fiber/pull/782
+            // Events trigger outside of canvas when moved, use offsetX/Y by default and allow overrides
+            state.pointer.set((event.offsetX / state.size.width) * 2 - 1, -(event.offsetY / state.size.height) * 2 + 1);
+            state.raycaster.setFromCamera(state.pointer, state.camera);
+        },
+        connected: undefined,
+        handlers: Object.keys(DOM_EVENTS).reduce((handlers, supportedEventName) => {
+            handlers[supportedEventName] = handlePointer(supportedEventName);
+            return handlers;
+        }, {}),
+        update: () => {
+            const { events, internal } = store.get();
+            if (internal.lastEvent?.nativeElement && events.handlers)
+                events.handlers.pointermove(internal.lastEvent.nativeElement);
+        },
+        connect: (target) => {
+            const state = store.get();
+            state.events.disconnect?.();
+            state.setEvents({ connected: target });
+            Object.entries(state.events.handlers ?? {}).forEach(([eventName, eventHandler]) => {
+                const passive = DOM_EVENTS[eventName];
+                target.addEventListener(eventName, eventHandler, { passive });
+            });
+        },
+        disconnect: () => {
+            const { events, setEvents } = store.get();
+            if (events.connected) {
+                Object.entries(events.handlers ?? {}).forEach(([eventName, eventHandler]) => {
+                    if (events.connected instanceof HTMLElement) {
+                        events.connected.removeEventListener(eventName, eventHandler);
+                    }
+                });
+                setEvents({ connected: undefined });
+            }
+        },
+    };
+}
+
+// This function prepares a set of changes to be applied to the instance
+function diffProps(instance, props) {
+    const propsEntries = Object.entries(props);
+    const changes = [];
+    for (const [propKey, propValue] of propsEntries) {
+        let key = propKey;
+        if (is.colorSpaceExist(instance)) {
+            if (propKey === 'encoding') {
+                key = 'colorSpace';
+            }
+            else if (propKey === 'outputEncoding') {
+                key = 'outputColorSpace';
+            }
+        }
+        if (is.equ(propValue, instance[key]))
+            continue;
+        changes.push([propKey, propValue]);
+    }
+    return changes;
+}
+// This function applies a set of changes to the instance
+function applyProps(instance, props) {
+    // if props is empty
+    if (!Object.keys(props).length)
+        return instance;
+    // filter equals, and reserved props
+    const localState = getLocalState(instance);
+    const rootState = localState?.store?.snapshot ?? {};
+    const changes = diffProps(instance, props);
+    for (let i = 0; i < changes.length; i++) {
+        let [key, value] = changes[i];
+        // Alias (output)encoding => (output)colorSpace (since r152)
+        // https://github.com/pmndrs/react-three-fiber/pull/2829
+        if (is.colorSpaceExist(instance)) {
+            const sRGBEncoding = 3001;
+            const SRGBColorSpace = 'srgb';
+            const LinearSRGBColorSpace = 'srgb-linear';
+            if (key === 'encoding') {
+                key = 'colorSpace';
+                value = value === sRGBEncoding ? SRGBColorSpace : LinearSRGBColorSpace;
+            }
+            else if (key === 'outputEncoding') {
+                key = 'outputColorSpace';
+                value = value === sRGBEncoding ? SRGBColorSpace : LinearSRGBColorSpace;
+            }
+        }
+        const currentInstance = instance;
+        const targetProp = currentInstance[key];
+        // special treatmen for objects with support for set/copy, and layers
+        if (targetProp && targetProp['set'] && (targetProp['copy'] || targetProp instanceof THREE.Layers)) {
+            const isColor = targetProp instanceof THREE.Color;
+            // if value is an array
+            if (Array.isArray(value)) {
+                if (targetProp['fromArray'])
+                    targetProp['fromArray'](value);
+                else
+                    targetProp['set'](...value);
+            } // test again target.copy
+            else if (targetProp['copy'] &&
+                value &&
+                value.constructor &&
+                targetProp.constructor.name === value.constructor.name) {
+                targetProp['copy'](value);
+                if (!THREE.ColorManagement && !rootState.linear && isColor)
+                    targetProp['convertSRGBToLinear']();
+            } // if nothing else fits, just set the single value, ignore undefined
+            else if (value !== undefined) {
+                const isColor = targetProp instanceof THREE.Color;
+                // allow setting array scalars
+                if (!isColor && targetProp['setScalar'])
+                    targetProp['setScalar'](value);
+                // layers have no copy function, copy the mask
+                else if (targetProp instanceof THREE.Layers && value instanceof THREE.Layers)
+                    targetProp.mask = value.mask;
+                // otherwise just set ...
+                else
+                    targetProp['set'](value);
+                // auto-convert srgb
+                if (!THREE.ColorManagement && !rootState?.linear && isColor)
+                    targetProp.convertSRGBToLinear();
+            }
+        } // else just overwrite the value
+        else {
+            currentInstance[key] = value;
+            // auto-convert srgb textures
+            if (currentInstance[key] instanceof THREE.Texture &&
+                currentInstance[key].format === THREE.RGBAFormat &&
+                currentInstance[key].type === THREE.UnsignedByteType) {
+                const texture = currentInstance[key];
+                if (rootState?.gl) {
+                    if (is.colorSpaceExist(texture) && is.colorSpaceExist(rootState.gl))
+                        texture.colorSpace = rootState.gl.outputColorSpace;
+                    else
+                        texture.encoding = rootState.gl.outputEncoding;
                 }
             }
         }
+        checkUpdate(currentInstance[key]);
+        checkUpdate(targetProp);
+        invalidateInstance(instance);
     }
-    function pointerMissed(event, objects) {
-        for (let i = 0; i < objects.length; i++) {
-            const instance = getLocalState(objects[i]);
-            instance?.handlers.pointermissed?.(event);
-        }
+    const instanceHandlersCount = localState?.eventCount;
+    const parent = localState?.instanceStore?.get('parent');
+    if (parent && rootState.internal && instance['raycast'] && instanceHandlersCount !== localState?.eventCount) {
+        // Pre-emptively remove the instance from the interaction manager
+        const index = rootState.internal.interaction.indexOf(instance);
+        if (index > -1)
+            rootState.internal.interaction.splice(index, 1);
+        // Add the instance to the interaction manager only when it has handlers
+        if (localState?.eventCount)
+            rootState.internal.interaction.push(instance);
     }
-    function handlePointer(name) {
-        // Deal with cancelation
-        switch (name) {
-            case 'pointerleave':
-            case 'pointercancel':
-                return () => cancelPointer([]);
-            case 'lostpointercapture':
-                return (event) => {
-                    const { internal } = store.get();
-                    if ('pointerId' in event && internal.capturedMap.has(event.pointerId)) {
-                        // If the object event interface had onLostPointerCapture, we'd call it here on every
-                        // object that's getting removed.
-                        internal.capturedMap.delete(event.pointerId);
-                        cancelPointer([]);
-                    }
-                };
-        }
-        // Any other pointer goes here ...
-        return function handleEvent(event) {
-            const pointerMissed$ = store['pointerMissed$'];
-            const internal = store.get('internal');
-            // prepareRay(event)
-            internal.lastEvent.nativeElement = event;
-            // Get fresh intersects
-            const isPointerMove = name === 'pointermove';
-            const isClickEvent = name === 'click' || name === 'contextmenu' || name === 'dblclick';
-            const filter = isPointerMove ? filterPointerEvents : undefined;
-            const hits = intersect(event, filter);
-            const delta = isClickEvent ? calculateDistance(event) : 0;
-            // Save initial coordinates on pointer-down
-            if (name === 'pointerdown') {
-                internal.initialClick = [event.offsetX, event.offsetY];
-                internal.initialHits = hits.map((hit) => hit.eventObject);
+    if (parent && localState?.afterUpdate && localState.afterUpdate.observed && changes.length) {
+        localState.afterUpdate.emit(instance);
+    }
+    return instance;
+}
+
+const shallowLoose = { objects: 'shallow', strict: false };
+const roots = new Map();
+function injectCanvasRootInitializer(injector) {
+    return assertInjector(injectCanvasRootInitializer, injector, () => {
+        const injectedStore = injectNgtStore();
+        const loop = injectNgtLoop();
+        return (canvas) => {
+            const exist = roots.has(canvas);
+            let store = roots.get(canvas);
+            if (store) {
+                console.warn('[NGT] Same canvas root is being created twice');
             }
-            // If a click yields no results, pass it back to the user as a miss
-            // Missed events have to come first in order to establish user-land side-effect clean up
-            if (isClickEvent && !hits.length) {
-                if (delta <= 2) {
-                    pointerMissed(event, internal.interaction);
-                    pointerMissed$.next(event);
-                }
+            store ||= injectedStore;
+            if (!store) {
+                throw new Error('[NGT] No store initialized');
             }
-            // Take care of unhover
-            if (isPointerMove)
-                cancelPointer(hits);
-            function onIntersect(data) {
-                const eventObject = data.eventObject;
-                const instance = getLocalState(eventObject);
-                const handlers = instance?.handlers;
-                // Check presence of handlers
-                if (!instance?.eventCount)
-                    return;
-                /*
-        MAYBE TODO, DELETE IF NOT:
-          Check if the object is captured, captured events should not have intersects running in parallel
-          But wouldn't it be better to just replace capturedMap with a single entry?
-          Also, are we OK with straight up making picking up multiple objects impossible?
-
-        const pointerId = (data as ThreeEvent<PointerEvent>).pointerId
-        if (pointerId !== undefined) {
-          const capturedMeshSet = internal.capturedMap.get(pointerId)
-          if (capturedMeshSet) {
-            const captured = capturedMeshSet.get(eventObject)
-            if (captured && captured.localState.stopped) return
-          }
-        }*/
-                if (isPointerMove) {
-                    // Move event ...
-                    if (handlers?.pointerover ||
-                        handlers?.pointerenter ||
-                        handlers?.pointerout ||
-                        handlers?.pointerleave) {
-                        // When enter or out is present take care of hover-state
-                        const id = makeId(data);
-                        const hoveredItem = internal.hovered.get(id);
-                        if (!hoveredItem) {
-                            // If the object wasn't previously hovered, book it and call its handler
-                            internal.hovered.set(id, data);
-                            handlers.pointerover?.(data);
-                            handlers.pointerenter?.(data);
+            if (!exist) {
+                roots.set(canvas, store);
+            }
+            let isConfigured = false;
+            let lastCamera;
+            return {
+                isConfigured,
+                destroy: (timeout = 500) => {
+                    const root = roots.get(canvas);
+                    if (root) {
+                        root.update((state) => ({ internal: { ...state.internal, active: false } }));
+                        setTimeout(() => {
+                            try {
+                                const state = root.get();
+                                state.events.disconnect?.();
+                                state.gl?.renderLists?.dispose?.();
+                                state.gl?.forceContextLoss?.();
+                                if (state.gl?.xr)
+                                    state.xr.disconnect();
+                                dispose(state);
+                                roots.delete(canvas);
+                            }
+                            catch (e) {
+                                console.error('[NGT] Unexpected error while destroying Canvas Root', e);
+                            }
+                        }, timeout);
+                    }
+                },
+                configure: (inputs) => {
+                    const { shadows = false, linear = false, flat = false, legacy = false, orthographic = false, frameloop = 'always', dpr = [1, 2], gl: glOptions, size: sizeOptions, camera: cameraOptions, raycaster: raycasterOptions, scene: sceneOptions, events, lookAt, performance, } = inputs;
+                    const state = store.snapshot;
+                    const stateToUpdate = {};
+                    // setup renderer
+                    let gl = state.gl;
+                    if (!state.gl)
+                        stateToUpdate.gl = gl = makeRendererInstance(glOptions, canvas);
+                    // setup raycaster
+                    let raycaster = state.raycaster;
+                    if (!raycaster)
+                        stateToUpdate.raycaster = raycaster = new THREE.Raycaster();
+                    // set raycaster options
+                    const { params, ...options } = raycasterOptions || {};
+                    if (!is.equ(options, raycaster, shallowLoose))
+                        applyProps(raycaster, options);
+                    if (!is.equ(params, raycaster.params, shallowLoose)) {
+                        applyProps(raycaster, { params: { ...raycaster.params, ...(params || {}) } });
+                    }
+                    // Create default camera, don't overwrite any user-set state
+                    if (!state.camera || (state.camera === lastCamera && !is.equ(lastCamera, cameraOptions, shallowLoose))) {
+                        lastCamera = cameraOptions;
+                        const isCamera = is.camera(cameraOptions);
+                        let camera = isCamera ? cameraOptions : makeCameraInstance(orthographic, state.size);
+                        if (!isCamera) {
+                            camera.position.z = 5;
+                            if (cameraOptions)
+                                applyProps(camera, cameraOptions);
+                            // always look at center or passed-in lookAt by default
+                            if (!state.camera && !cameraOptions?.rotation && !cameraOptions?.quaternion) {
+                                if (Array.isArray(lookAt))
+                                    camera.lookAt(lookAt[0], lookAt[1], lookAt[2]);
+                                else if (lookAt instanceof THREE.Vector3)
+                                    camera.lookAt(lookAt);
+                                else
+                                    camera.lookAt(0, 0, 0);
+                            }
+                            // update projection matrix after applyprops
+                            camera.updateProjectionMatrix?.();
+                        }
+                        if (!is.instance(camera))
+                            camera = prepare(camera, { store });
+                        stateToUpdate.camera = camera;
+                        // Configure raycaster
+                        // https://github.com/pmndrs/react-xr/issues/300
+                        raycaster.camera = camera;
+                    }
+                    // Set up scene (one time only!)
+                    if (!state.scene) {
+                        let scene;
+                        if (sceneOptions instanceof THREE.Scene) {
+                            scene = sceneOptions;
+                        }
+                        else {
+                            scene = new THREE.Scene();
+                            if (sceneOptions)
+                                applyProps(scene, sceneOptions);
+                        }
+                        stateToUpdate.scene = prepare(scene, { store });
+                    }
+                    // Set up XR (one time only!)
+                    if (!state.xr) {
+                        // Handle frame behavior in WebXR
+                        const handleXRFrame = (timestamp, frame) => {
+                            const state = store.snapshot;
+                            if (state.frameloop === 'never')
+                                return;
+                            loop.advance(timestamp, true, store, frame);
+                        };
+                        // Toggle render switching on session
+                        const handleSessionChange = () => {
+                            const state = store.snapshot;
+                            state.gl.xr.enabled = state.gl.xr.isPresenting;
+                            state.gl.xr.setAnimationLoop(state.gl.xr.isPresenting ? handleXRFrame : null);
+                            if (!state.gl.xr.isPresenting)
+                                loop.invalidate(store);
+                        };
+                        // WebXR session manager
+                        const xr = {
+                            connect: () => {
+                                gl.xr.addEventListener('sessionstart', handleSessionChange);
+                                gl.xr.addEventListener('sessionend', handleSessionChange);
+                            },
+                            disconnect: () => {
+                                gl.xr.removeEventListener('sessionstart', handleSessionChange);
+                                gl.xr.removeEventListener('sessionend', handleSessionChange);
+                            },
+                        };
+                        // Subscribe to WebXR session events
+                        if (gl.xr && typeof gl.xr.addEventListener === 'function')
+                            xr.connect();
+                        stateToUpdate.xr = xr;
+                    }
+                    // Set shadowmap
+                    if (gl.shadowMap) {
+                        const oldEnabled = gl.shadowMap.enabled;
+                        const oldType = gl.shadowMap.type;
+                        gl.shadowMap.enabled = !!shadows;
+                        if (typeof shadows === 'boolean') {
+                            gl.shadowMap.type = THREE.PCFSoftShadowMap;
                         }
-                        else if (hoveredItem.stopped) {
-                            // If the object was previously hovered and stopped, we shouldn't allow other items to proceed
-                            data.stopPropagation();
+                        else if (typeof shadows === 'string') {
+                            const types = {
+                                basic: THREE.BasicShadowMap,
+                                percentage: THREE.PCFShadowMap,
+                                soft: THREE.PCFSoftShadowMap,
+                                variance: THREE.VSMShadowMap,
+                            };
+                            gl.shadowMap.type = types[shadows] ?? THREE.PCFSoftShadowMap;
                         }
-                    }
-                    // Call mouse move
-                    handlers?.pointermove?.(data);
-                }
-                else {
-                    // All other events ...
-                    const handler = handlers?.[name];
-                    if (handler) {
-                        // Forward all events back to their respective handlers with the exception of click events,
-                        // which must use the initial target
-                        if (!isClickEvent || internal.initialHits.includes(eventObject)) {
-                            // Missed events have to come first
-                            pointerMissed(event, internal.interaction.filter((object) => !internal.initialHits.includes(object)));
-                            // Now call the handler
-                            handler(data);
+                        else if (is.obj(shadows)) {
+                            Object.assign(gl.shadowMap, shadows);
                         }
+                        if (oldEnabled !== gl.shadowMap.enabled || oldType !== gl.shadowMap.type)
+                            checkNeedsUpdate(gl.shadowMap);
                     }
-                    else {
-                        // Trigger onPointerMissed on all elements that have pointer over/out handlers, but not click and weren't hit
-                        if (isClickEvent && internal.initialHits.includes(eventObject)) {
-                            pointerMissed(event, internal.interaction.filter((object) => !internal.initialHits.includes(object)));
-                        }
+                    // Safely set color management if available.
+                    // Avoid accessing THREE.ColorManagement to play nice with older versions
+                    if (THREE.ColorManagement) {
+                        const ColorManagement = THREE.ColorManagement;
+                        if ('enabled' in ColorManagement)
+                            ColorManagement['enabled'] = !legacy ?? false;
+                        else if ('legacyMode' in ColorManagement)
+                            ColorManagement['legacyMode'] = legacy ?? true;
                     }
-                }
-            }
-            handleIntersects(hits, event, delta, onIntersect);
+                    if (!isConfigured) {
+                        // set color space and tonemapping preferences once
+                        const LinearEncoding = 3000;
+                        const sRGBEncoding = 3001;
+                        applyProps(gl, {
+                            outputEncoding: linear ? LinearEncoding : sRGBEncoding,
+                            toneMapping: flat ? THREE.NoToneMapping : THREE.ACESFilmicToneMapping,
+                        });
+                    }
+                    // Update color management state
+                    if (state.legacy !== legacy)
+                        stateToUpdate.legacy = legacy;
+                    if (state.linear !== linear)
+                        stateToUpdate.linear = linear;
+                    if (state.flat !== flat)
+                        stateToUpdate.flat = flat;
+                    // Set gl props
+                    gl.setClearAlpha(0);
+                    gl.setPixelRatio(makeDpr(state.viewport.dpr));
+                    gl.setSize(state.size.width, state.size.height);
+                    if (is.obj(glOptions) &&
+                        !(typeof glOptions === 'function') &&
+                        !is.renderer(glOptions) &&
+                        !is.equ(glOptions, gl, shallowLoose)) {
+                        applyProps(gl, glOptions);
+                    }
+                    // Store events internally
+                    if (events && !state.events.handlers)
+                        stateToUpdate.events = events(store);
+                    // Check performance
+                    if (performance && !is.equ(performance, state.performance, shallowLoose)) {
+                        stateToUpdate.performance = { ...state.performance, ...performance };
+                    }
+                    store.update(stateToUpdate);
+                    // Check size, allow it to take on container bounds initially
+                    const size = computeInitialSize(canvas, sizeOptions);
+                    if (!is.equ(size, state.size, shallowLoose)) {
+                        state.setSize(size.width, size.height, size.top, size.left);
+                    }
+                    // Check pixelratio
+                    if (dpr && state.viewport.dpr !== makeDpr(dpr))
+                        state.setDpr(dpr);
+                    // Check frameloop
+                    if (state.frameloop !== frameloop)
+                        state.setFrameloop(frameloop);
+                    isConfigured = true;
+                },
+            };
         };
+    });
+}
+function computeInitialSize(canvas, defaultSize) {
+    if (defaultSize) {
+        return defaultSize;
+    }
+    if (typeof HTMLCanvasElement !== 'undefined' && canvas instanceof HTMLCanvasElement && canvas.parentElement) {
+        return canvas.parentElement.getBoundingClientRect();
+    }
+    if (typeof OffscreenCanvas !== 'undefined' && canvas instanceof OffscreenCanvas) {
+        return { width: canvas.width, height: canvas.height, top: 0, left: 0 };
+    }
+    return { width: 0, height: 0, top: 0, left: 0 };
+}
+// Disposes an object and all its properties
+function dispose(obj) {
+    if (obj.dispose && obj.type !== 'Scene')
+        obj.dispose();
+    for (const p in obj) {
+        p.dispose?.();
+        delete obj[p];
     }
-    return { handlePointer };
 }
 
-const DOM_EVENTS = {
-    click: false,
-    contextmenu: false,
-    dblclick: false,
-    wheel: false,
-    pointerdown: true,
-    pointerup: true,
-    pointerleave: true,
-    pointermove: true,
-    pointercancel: true,
-    lostpointercapture: true,
-};
-const supportedEvents = [
-    'click',
-    'contextmenu',
-    'dblclick',
-    'pointerup',
-    'pointerdown',
-    'pointerover',
-    'pointerout',
-    'pointerenter',
-    'pointerleave',
-    'pointermove',
-    'pointermissed',
-    'pointercancel',
-    'wheel',
-];
-function createPointerEvents(store) {
-    const { handlePointer } = createEvents(store);
-    return {
-        priority: 1,
-        enabled: true,
-        compute: (event, root) => {
-            const state = root.get();
-            // https://github.com/pmndrs/react-three-fiber/pull/782
-            // Events trigger outside of canvas when moved, use offsetX/Y by default and allow overrides
-            state.pointer.set((event.offsetX / state.size.width) * 2 - 1, -(event.offsetY / state.size.height) * 2 + 1);
-            state.raycaster.setFromCamera(state.pointer, state.camera);
-        },
-        connected: undefined,
-        handlers: Object.keys(DOM_EVENTS).reduce((handlers, supportedEventName) => {
-            handlers[supportedEventName] = handlePointer(supportedEventName);
-            return handlers;
-        }, {}),
-        update: () => {
-            const { events, internal } = store.get();
-            if (internal.lastEvent?.nativeElement && events.handlers)
-                events.handlers.pointermove(internal.lastEvent.nativeElement);
-        },
-        connect: (target) => {
-            const state = store.get();
-            state.events.disconnect?.();
-            state.setEvents({ connected: target });
-            Object.entries(state.events.handlers ?? {}).forEach(([eventName, eventHandler]) => {
-                const passive = DOM_EVENTS[eventName];
-                target.addEventListener(eventName, eventHandler, { passive });
-            });
-        },
-        disconnect: () => {
-            const { events, setEvents } = store.get();
-            if (events.connected) {
-                Object.entries(events.handlers ?? {}).forEach(([eventName, eventHandler]) => {
-                    if (events.connected instanceof HTMLElement) {
-                        events.connected.removeEventListener(eventName, eventHandler);
-                    }
-                });
-                setEvents({ connected: undefined });
+function createSubs(callback, subs) {
+    const sub = { callback };
+    subs.add(sub);
+    return () => void subs.delete(sub);
+}
+const globalEffects = new Set();
+const globalAfterEffects = new Set();
+const globalTailEffects = new Set();
+/**
+ * Adds a global render callback which is called each frame.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addEffect
+ */
+const addEffect = (callback) => createSubs(callback, globalEffects);
+/**
+ * Adds a global after-render callback which is called each frame.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addAfterEffect
+ */
+const addAfterEffect = (callback) => createSubs(callback, globalAfterEffects);
+/**
+ * Adds a global callback which is called when rendering stops.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addTail
+ */
+const addTail = (callback) => createSubs(callback, globalTailEffects);
+function run(effects, timestamp) {
+    if (!effects.size)
+        return;
+    for (const { callback } of effects.values()) {
+        callback(timestamp);
+    }
+}
+function flushGlobalEffects(type, timestamp) {
+    switch (type) {
+        case 'before':
+            return run(globalEffects, timestamp);
+        case 'after':
+            return run(globalAfterEffects, timestamp);
+        case 'tail':
+            return run(globalTailEffects, timestamp);
+    }
+}
+function render(timestamp, store, frame) {
+    const state = store.snapshot;
+    // Run local effects
+    let delta = state.clock.getDelta();
+    // In frameloop='never' mode, clock times are updated using the provided timestamp
+    if (state.frameloop === 'never' && typeof timestamp === 'number') {
+        delta = timestamp - state.clock.elapsedTime;
+        state.clock.oldTime = state.clock.elapsedTime;
+        state.clock.elapsedTime = timestamp;
+    }
+    // Call subscribers (beforeRender)
+    const subscribers = state.internal.subscribers;
+    for (let i = 0; i < subscribers.length; i++) {
+        const subscription = subscribers[i];
+        subscription.callback({ ...subscription.store.snapshot, delta, frame });
+    }
+    // Render content
+    if (!state.internal.priority && state.gl.render)
+        state.gl.render(state.scene, state.camera);
+    // Decrease frame count
+    state.internal.frames = Math.max(0, state.internal.frames - 1);
+    return state.frameloop === 'always' ? 1 : state.internal.frames;
+}
+function createLoop(roots) {
+    let running = false;
+    let repeat;
+    let frame;
+    function loop(timestamp) {
+        frame = requestAnimationFrame(loop);
+        running = true;
+        repeat = 0;
+        // Run effects
+        flushGlobalEffects('before', timestamp);
+        // Render all roots
+        for (const root of roots.values()) {
+            const state = root.snapshot;
+            // If the frameloop is invalidated, do not run another frame
+            if (state.internal.active &&
+                (state.frameloop === 'always' || state.internal.frames > 0) &&
+                !state.gl.xr?.isPresenting) {
+                repeat += render(timestamp, root);
             }
-        },
+        }
+        // Run after-effects
+        flushGlobalEffects('after', timestamp);
+        // Stop the loop if nothing invalidates it
+        if (repeat === 0) {
+            // Tail call effects, they are called when rendering stops
+            flushGlobalEffects('tail', timestamp);
+            // Flag end of operation
+            running = false;
+            return cancelAnimationFrame(frame);
+        }
+    }
+    function invalidate(store, frames = 1) {
+        const state = store?.snapshot;
+        if (!state)
+            return roots.forEach((root) => invalidate(root, frames));
+        if (state.gl.xr?.isPresenting || !state.internal.active || state.frameloop === 'never')
+            return;
+        // Increase frames, do not go higher than 60
+        state.internal.frames = Math.min(60, state.internal.frames + frames);
+        // If the render-loop isn't active, start it
+        if (!running) {
+            running = true;
+            requestAnimationFrame(loop);
+        }
+    }
+    function advance(timestamp, runGlobalEffects = true, store, frame) {
+        if (runGlobalEffects)
+            flushGlobalEffects('before', timestamp);
+        if (!store)
+            for (const root of roots.values())
+                render(timestamp, root);
+        else
+            render(timestamp, store, frame);
+        if (runGlobalEffects)
+            flushGlobalEffects('after', timestamp);
+    }
+    return {
+        loop,
+        /**
+         * Invalidates the view, requesting a frame to be rendered. Will globally invalidate unless passed a root's state.
+         * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#invalidate
+         */
+        invalidate,
+        /**
+         * Advances the frameloop and runs render effects, useful for when manually rendering via `frameloop="never"`.
+         * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#advance
+         */
+        advance,
     };
 }
+const [injectNgtLoop] = createInjectionToken(() => createLoop(roots));
 
-const cached = new Map();
-function normalizeInputs(input) {
-    if (Array.isArray(input))
-        return input;
-    if (typeof input === 'string')
-        return [input];
-    return Object.values(input);
-}
-function load(loaderConstructorFactory, inputs, { extensions, onProgress, } = {}) {
-    return () => {
-        const urls = normalizeInputs(inputs());
-        const loader = new (loaderConstructorFactory(urls))();
-        if (extensions)
-            extensions(loader);
-        // TODO: reevaluate this
-        return urls.map((url) => {
-            if (!cached.has(url)) {
-                cached.set(url, new Promise((resolve, reject) => {
-                    loader.load(url, (data) => {
-                        if ('scene' in data)
-                            Object.assign(data, makeObjectGraph(data['scene']));
-                        resolve(data);
-                    }, onProgress, (error) => reject(new Error(`[NGT] Could not load ${url}: ${error}`)));
+function storeFactory(previousStore) {
+    const document = inject(DOCUMENT);
+    const window = document.defaultView;
+    if (!window) {
+        // TODO: revisit this when we need to support multiple platforms
+        throw new Error(`[NGT] Window is not available.`);
+    }
+    const loop = injectNgtLoop();
+    // NOTE: using Subject because we do not care about late-subscribers
+    const pointerMissed$ = new Subject();
+    const store = signalStore(({ get, update }) => {
+        const { invalidate, advance } = loop;
+        const position = new THREE.Vector3();
+        const defaultTarget = new THREE.Vector3();
+        const tempTarget = new THREE.Vector3();
+        function getCurrentViewport(camera = get('camera'), target = defaultTarget, size = get('size')) {
+            const { width, height, top, left } = size;
+            const aspect = width / height;
+            if (target instanceof THREE.Vector3)
+                tempTarget.copy(target);
+            else
+                tempTarget.set(...target);
+            const distance = camera.getWorldPosition(position).distanceTo(tempTarget);
+            if (is.orthographicCamera(camera)) {
+                return { width: width / camera.zoom, height: height / camera.zoom, top, left, factor: 1, distance, aspect };
+            }
+            const fov = (camera.fov * Math.PI) / 180; // convert vertical fov to radians
+            const h = 2 * Math.tan(fov / 2) * distance; // visible height
+            const w = h * (width / height);
+            return { width: w, height: h, top, left, factor: width / w, distance, aspect };
+        }
+        let performanceTimeout = undefined;
+        const setPerformanceCurrent = (current) => update((state) => ({ performance: { ...state.performance, current } }));
+        const pointer = new THREE.Vector2();
+        return {
+            pointerMissed$: pointerMissed$.asObservable(),
+            events: { priority: 1, enabled: true, connected: false },
+            invalidate: (frames = 1) => invalidate(store, frames),
+            advance: (timestamp, runGlobalEffects) => advance(timestamp, runGlobalEffects, store),
+            legacy: false,
+            linear: false,
+            flat: false,
+            controls: null,
+            clock: new THREE.Clock(),
+            pointer,
+            frameloop: 'always',
+            performance: {
+                current: 1,
+                min: 0.5,
+                max: 1,
+                debounce: 200,
+                regress: () => {
+                    const state = get();
+                    // Clear timeout
+                    if (performanceTimeout)
+                        clearTimeout(performanceTimeout);
+                    // Set lower bound performance
+                    if (state.performance.current !== state.performance.min)
+                        setPerformanceCurrent(state.performance.min);
+                    // Go back to upper bound performance after a while unless something regresses meanwhile
+                    performanceTimeout = setTimeout(() => {
+                        setPerformanceCurrent(get('performance', 'max'));
+                        // safeDetectChanges(cdr);
+                    }, state.performance.debounce);
+                },
+            },
+            size: { width: 0, height: 0, top: 0, left: 0, updateStyle: false },
+            viewport: {
+                initialDpr: 0,
+                dpr: 0,
+                width: 0,
+                height: 0,
+                top: 0,
+                left: 0,
+                aspect: 0,
+                distance: 0,
+                factor: 0,
+                getCurrentViewport,
+            },
+            setEvents: (events) => update((state) => ({ ...state, events: { ...state.events, ...events } })),
+            setSize: (width, height, top, left) => {
+                const camera = get('camera');
+                const size = { width, height, top: top || 0, left: left || 0 };
+                update((state) => ({
+                    size,
+                    viewport: { ...state.viewport, ...getCurrentViewport(camera, defaultTarget, size) },
                 }));
-            }
-            return cached.get(url);
-        });
-    };
-}
-function injectNgtLoader(loaderConstructorFactory, inputs, { extensions, onProgress, injector, } = {}) {
-    injector = assertInjectionContext(injectNgtLoader, injector);
-    const response = signal(null);
-    return runInInjectionContext(injector, () => {
-        const cdr = inject(ChangeDetectorRef);
-        const effector = load(loaderConstructorFactory, inputs, { extensions, onProgress });
-        effect(() => {
-            const originalUrls = inputs();
-            Promise.all(effector()).then((results) => {
-                response.update(() => {
-                    if (Array.isArray(originalUrls))
-                        return results;
-                    if (typeof originalUrls === 'string')
-                        return results[0];
-                    const keys = Object.keys(originalUrls);
-                    return keys.reduce((result, key) => {
-                        result[key] = results[keys.indexOf(key)];
-                        return result;
-                    }, {});
-                });
-                safeDetectChanges(cdr);
-            });
-        });
-        return response.asReadonly();
+            },
+            setDpr: (dpr) => update((state) => {
+                const resolved = makeDpr(dpr, window);
+                return { viewport: { ...state.viewport, dpr: resolved, initialDpr: state.viewport.initialDpr || resolved } };
+            }),
+            setFrameloop: (frameloop = 'always') => {
+                const clock = get('clock');
+                // if frameloop === "never" clock.elapsedTime is updated using advance(timestamp)
+                clock.stop();
+                clock.elapsedTime = 0;
+                if (frameloop !== 'never') {
+                    clock.start();
+                    clock.elapsedTime = 0;
+                }
+                update(() => ({ frameloop }));
+            },
+            previousRoot: previousStore,
+            internal: {
+                active: false,
+                priority: 0,
+                frames: 0,
+                lastEvent: new ElementRef(null),
+                interaction: [],
+                hovered: new Map(),
+                subscribers: [],
+                initialClick: [0, 0],
+                initialHits: [],
+                capturedMap: new Map(),
+                subscribe: (callback, priority = 0, _store = store) => {
+                    const internal = get('internal');
+                    // If this subscription was given a priority, it takes rendering into its own hands
+                    // For that reason we switch off automatic rendering and increase the manual flag
+                    // As long as this flag is positive there can be no internal rendering at all
+                    // because there could be multiple render subscriptions
+                    internal.priority = internal.priority + (priority > 0 ? 1 : 0);
+                    internal.subscribers.push({ callback, priority, store: _store });
+                    // Register subscriber and sort layers from lowest to highest, meaning,
+                    // highest priority renders last (on top of the other frames)
+                    internal.subscribers = internal.subscribers.sort((a, b) => (a.priority || 0) - (b.priority || 0));
+                    return () => {
+                        const internal = get('internal');
+                        if (internal?.subscribers) {
+                            // Decrease manual flag if this subscription had a priority
+                            internal.priority = internal.priority - (priority > 0 ? 1 : 0);
+                            // Remove subscriber from list
+                            internal.subscribers = internal.subscribers.filter((s) => s.callback !== callback);
+                        }
+                    };
+                },
+            },
+        };
+    });
+    Object.defineProperty(store, 'pointerMissed$', { get: () => pointerMissed$ });
+    let { size: oldSize, viewport: { dpr: oldDpr }, camera: oldCamera, } = store.snapshot;
+    const [camera, size, viewportDpr] = [store.select('camera'), store.select('size'), store.select('viewport', 'dpr')];
+    effect(() => {
+        const [newCamera, newSize, newDpr, gl] = [camera(), size(), viewportDpr(), store.snapshot.gl];
+        // Resize camera and renderer on changes to size and pixel-ratio
+        if (newSize !== oldSize || newDpr !== oldDpr) {
+            oldSize = newSize;
+            oldDpr = newDpr;
+            // Update camera & renderer
+            updateCamera(newCamera, newSize);
+            gl.setPixelRatio(newDpr);
+            const updateStyle = typeof HTMLCanvasElement !== 'undefined' && gl.domElement instanceof HTMLCanvasElement;
+            gl.setSize(newSize.width, newSize.height, updateStyle);
+        }
+        // Update viewport once the camera changes
+        if (newCamera !== oldCamera) {
+            oldCamera = newCamera;
+            updateCamera(newCamera, newSize);
+            // Update viewport
+            store.update((state) => ({ viewport: { ...state.viewport, ...state.viewport.getCurrentViewport(newCamera) } }));
+        }
     });
+    return store;
 }
-injectNgtLoader['preload'] = (loaderConstructorFactory, inputs, extensions) => {
-    Promise.all(load(loaderConstructorFactory, inputs, { extensions })());
-};
-injectNgtLoader['destroy'] = () => {
-    cached.clear();
-};
+const NGT_STORE = new InjectionToken('NgtStore Token');
+const [injectNgtStore, provideNgtStore] = createInjectionToken(storeFactory, {
+    isRoot: false,
+    deps: [[new Optional(), new SkipSelf(), NGT_STORE]],
+    token: NGT_STORE,
+});
 
 const catalogue = {};
 function extend(objects) {
@@ -1577,7 +1429,7 @@ const SPECIAL_PROPERTIES = {
     COMPOUND: 'ngtCompound',
     RENDER_PRIORITY: 'priority',
     ATTACH: 'attach',
-    VALUE: 'rawValue',
+    RAW_VALUE: 'rawValue',
     REF: 'ref',
 };
 const SPECIAL_EVENTS = {
@@ -1586,20 +1438,21 @@ const SPECIAL_EVENTS = {
     AFTER_ATTACH: 'afterAttach',
 };
 
+const [injectNodeType, provideNodeType] = createInjectionToken(() => '', {
+    isRoot: false,
+});
 class NgtCommonDirective {
-    static { this.processComment = true; }
     constructor() {
         this.vcr = inject(ViewContainerRef);
         this.zone = inject(NgZone);
         this.template = inject(TemplateRef);
+        this.nodeType = injectNodeType();
         this.injected = false;
         this.shouldCreateView = true;
-        if (NgtCommonDirective.processComment) {
-            const commentNode = this.vcr.element.nativeElement;
-            if (commentNode[SPECIAL_INTERNAL_ADD_COMMENT]) {
-                commentNode[SPECIAL_INTERNAL_ADD_COMMENT]();
-                delete commentNode[SPECIAL_INTERNAL_ADD_COMMENT];
-            }
+        const commentNode = this.vcr.element.nativeElement;
+        if (commentNode[SPECIAL_INTERNAL_ADD_COMMENT]) {
+            commentNode[SPECIAL_INTERNAL_ADD_COMMENT](this.nodeType);
+            delete commentNode[SPECIAL_INTERNAL_ADD_COMMENT];
         }
         inject(DestroyRef).onDestroy(() => {
             this.view?.destroy();
@@ -1612,16 +1465,16 @@ class NgtCommonDirective {
                     this.view.destroy();
                 }
                 this.view = this.vcr.createEmbeddedView(this.template);
-                safeDetectChanges(this.view);
+                this.view.detectChanges();
             }
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtCommonDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.2", type: NgtCommonDirective, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NgtCommonDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.2.1", type: NgtCommonDirective, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtCommonDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NgtCommonDirective, decorators: [{
             type: Directive
-        }], ctorParameters: function () { return []; } });
+        }], ctorParameters: () => [] });
 
 class NgtArgs extends NgtCommonDirective {
     constructor() {
@@ -1645,12 +1498,12 @@ class NgtArgs extends NgtCommonDirective {
     validate() {
         return !this.injected && !!this.injectedArgs.length;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtArgs, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.2", type: NgtArgs, isStandalone: true, selector: "ng-template[args]", inputs: { args: "args" }, usesInheritance: true, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NgtArgs, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.2.1", type: NgtArgs, isStandalone: true, selector: "ng-template[args]", inputs: { args: "args" }, providers: [provideNodeType('args')], usesInheritance: true, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtArgs, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NgtArgs, decorators: [{
             type: Directive,
-            args: [{ selector: 'ng-template[args]', standalone: true }]
+            args: [{ selector: 'ng-template[args]', standalone: true, providers: [provideNodeType('args')] }]
         }], propDecorators: { args: [{
                 type: Input
             }] } });
@@ -1677,12 +1530,12 @@ class NgtParent extends NgtCommonDirective {
     validate() {
         return !this.injected && !!this.injectedParent;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtParent, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.2", type: NgtParent, isStandalone: true, selector: "ng-template[parent]", inputs: { parent: "parent" }, usesInheritance: true, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NgtParent, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.2.1", type: NgtParent, isStandalone: true, selector: "ng-template[parent]", inputs: { parent: "parent" }, providers: [provideNodeType('parent')], usesInheritance: true, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtParent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NgtParent, decorators: [{
             type: Directive,
-            args: [{ selector: 'ng-template[parent]', standalone: true }]
+            args: [{ selector: 'ng-template[parent]', standalone: true, providers: [provideNodeType('parent')] }]
         }], propDecorators: { parent: [{
                 type: Input
             }] } });
@@ -1701,11 +1554,11 @@ function attach(object, value, paths = []) {
 }
 function detach(parent, child, attachProp) {
     const childLocalState = getLocalState(child);
-    if (Array.isArray(attachProp)) {
-        attach(parent, childLocalState.previousAttach, attachProp);
-    }
-    else {
-        childLocalState.previousAttach();
+    if (childLocalState) {
+        if (Array.isArray(attachProp))
+            attach(parent, childLocalState.previousAttach, attachProp);
+        else
+            childLocalState.previousAttach();
     }
 }
 function assignEmpty(obj, base) {
@@ -1749,6 +1602,14 @@ var NgtQueueOpClassId;
     NgtQueueOpClassId[NgtQueueOpClassId["op"] = 1] = "op";
     NgtQueueOpClassId[NgtQueueOpClassId["done"] = 2] = "done";
 })(NgtQueueOpClassId || (NgtQueueOpClassId = {}));
+function kebabToPascal(str) {
+    // split the string at each hyphen
+    const parts = str.split('-');
+    // map over the parts, capitalizing the first letter of each part
+    const pascalParts = parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1));
+    // join the parts together to create the final PascalCase string
+    return pascalParts.join('');
+}
 function attachThreeChild(parent, child) {
     const pLS = getLocalState(parent);
     const cLS = getLocalState(child);
@@ -1785,10 +1646,8 @@ function attachThreeChild(parent, child) {
             }
             // attach
             if (cLS.isRaw) {
-                if (cLS.parent && cLS.parent() !== parent) {
-                    untracked(() => {
-                        cLS.parent.set(parent);
-                    });
+                if (cLS.instanceStore.get('parent') !== parent) {
+                    cLS.setParent(parent);
                 }
                 // at this point we don't have rawValue yet, so we bail and wait until the Renderer recalls attach
                 if (child.__ngt_renderer__[NgtRendererClassId.rawValue] === undefined)
@@ -1807,10 +1666,8 @@ function attachThreeChild(parent, child) {
         added = true;
     }
     pLS.add(child, added ? 'objects' : 'nonObjects');
-    if (cLS.parent && cLS.parent() !== parent) {
-        untracked(() => {
-            cLS.parent.set(parent);
-        });
+    if (cLS.instanceStore.get('parent') !== parent) {
+        cLS.setParent(parent);
     }
     if (cLS.afterAttach)
         cLS.afterAttach.emit({ parent, node: child });
@@ -1821,24 +1678,22 @@ function removeThreeChild(parent, child, dispose) {
     const pLS = getLocalState(parent);
     const cLS = getLocalState(child);
     // clear parent ref
-    untracked(() => {
-        cLS.parent?.set(null);
-    });
+    cLS?.setParent(null);
     // remove child from parent
-    if (pLS.objects && untracked(pLS.objects))
-        pLS.remove(child, 'objects');
-    if (pLS.nonObjects && untracked(pLS.nonObjects))
-        pLS.remove(child, 'nonObjects');
-    if (cLS.attach) {
+    pLS?.remove(child, 'objects');
+    pLS?.remove(child, 'nonObjects');
+    if (cLS?.attach) {
         detach(parent, child, cLS.attach);
     }
     else if (is.object3D(parent) && is.object3D(child)) {
         parent.remove(child);
-        removeInteractivity(cLS.store || pLS.store, child);
+        const store = cLS?.store || pLS?.store;
+        if (store)
+            removeInteractivity(store, child);
     }
-    const isPrimitive = cLS.primitive;
+    const isPrimitive = cLS?.primitive;
     if (!isPrimitive) {
-        removeThreeRecursive(cLS.objects ? untracked(cLS.objects) : [], child, !!dispose);
+        removeThreeRecursive(cLS?.instanceStore.get('objects') || [], child, !!dispose);
         removeThreeRecursive(child.children, child, !!dispose);
     }
     // dispose
@@ -1851,16 +1706,12 @@ function removeThreeRecursive(array, parent, dispose) {
     if (array)
         [...array].forEach((child) => removeThreeChild(parent, child, dispose));
 }
-function kebabToPascal(str) {
-    // split the string at each hyphen
-    const parts = str.split('-');
-    // map over the parts, capitalizing the first letter of each part
-    const pascalParts = parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1));
-    // join the parts together to create the final PascalCase string
-    return pascalParts.join('');
-}
-function processThreeEvent(instance, priority, eventName, callback, zone, rootCdr, targetCdr) {
+function processThreeEvent(instance, priority, eventName, callback) {
     const lS = getLocalState(instance);
+    if (!lS) {
+        console.warn('[NGT] instance has not been prepared yet.');
+        return () => { };
+    }
     if (eventName === SPECIAL_EVENTS.BEFORE_RENDER) {
         return lS.store
             .get('internal')
@@ -1881,10 +1732,7 @@ function processThreeEvent(instance, priority, eventName, callback, zone, rootCd
     const updatedCallback = (event) => {
         if (previousHandler)
             previousHandler(event);
-        zone.run(() => {
-            callback(event);
-            safeDetectChanges(targetCdr, rootCdr);
-        });
+        callback(event);
     };
     Object.assign(lS.handlers, { [eventName]: updatedCallback });
     // increment the count everytime
@@ -1895,23 +1743,24 @@ function processThreeEvent(instance, priority, eventName, callback, zone, rootCd
         lS.store.get('internal', 'interaction').push(instance);
     // clean up the event listener by removing the target from the interaction array
     return () => {
-        const localState = getLocalState(instance);
-        if (localState && localState.eventCount) {
-            localState.eventCount -= 1;
-            const index = localState.store
-                .get('internal', 'interaction')
-                .findIndex((obj) => obj.uuid === instance.uuid);
+        const lS = getLocalState(instance);
+        if (lS) {
+            lS.eventCount -= 1;
+            const interactions = lS.store.get('internal', 'interaction') || [];
+            const index = interactions.findIndex((obj) => obj.uuid === instance.uuid);
             if (index >= 0)
-                localState.store.get('internal', 'interaction').splice(index, 1);
+                interactions.splice(index, 1);
         }
     };
 }
 
 const NGT_COMPOUND_PREFIXES = new InjectionToken('NgtCompoundPrefixes');
 class NgtRendererStore {
-    constructor(root) {
-        this.root = root;
-        this.comments = [];
+    constructor(rootState) {
+        this.rootState = rootState;
+        this.argsCommentNodes = [];
+        this.parentCommentNodes = [];
+        this.portalCommentsNodes = [];
     }
     createNode(type, node) {
         const state = [
@@ -1934,34 +1783,100 @@ class NgtRendererStore {
         const rendererNode = Object.assign(node, { __ngt_renderer__: state });
         // NOTE: assign ownerDocument to node so we can use HostListener in Component
         if (!rendererNode['ownerDocument'])
-            rendererNode['ownerDocument'] = this.root.document;
+            rendererNode['ownerDocument'] = this.rootState.document;
         // NOTE: assign injectorFactory on non-three type since
         // rendererNode is an instance of DOM Node
         if (state[NgtRendererClassId.type] !== 'three') {
-            state[NgtRendererClassId.injectorFactory] = () => getDebugNode(rendererNode).injector;
+            state[NgtRendererClassId.injectorFactory] = () => getDebugNode(rendererNode)?.injector;
         }
         if (state[NgtRendererClassId.type] === 'comment') {
             // NOTE: we attach an arrow function to the Comment node
             // In our directives, we can call this function to then start tracking the RendererNode
             // this is done to limit the amount of Nodes we need to process for getCreationState
             rendererNode[SPECIAL_INTERNAL_ADD_COMMENT] = (node) => {
-                if (node && node.__ngt_renderer__[NgtRendererClassId.type] === 'portal') {
-                    this.portals.push(node);
+                if (node === 'args') {
+                    this.argsCommentNodes.push(rendererNode);
                 }
-                else {
-                    this.comments.push(rendererNode);
+                else if (node === 'parent') {
+                    this.parentCommentNodes.push(rendererNode);
+                }
+                else if (typeof node === 'object') {
+                    this.portalCommentsNodes.push(node);
                 }
             };
             return rendererNode;
         }
         if (state[NgtRendererClassId.type] === 'compound') {
             state[NgtRendererClassId.queueOps] = new Set();
-            state[NgtRendererClassId.attributes] = {};
-            state[NgtRendererClassId.properties] = {};
+            state[NgtRendererClassId.attributes] = state[NgtRendererClassId.properties] = {};
             return rendererNode;
         }
         return rendererNode;
     }
+    isCompound(name) {
+        return this.rootState.compoundPrefixes.some((prefix) => name.startsWith(prefix));
+    }
+    isDOM(node) {
+        const rS = node['__ngt_renderer__'];
+        return (!rS ||
+            (rS[NgtRendererClassId.type] !== 'compound' &&
+                (node instanceof Element || node instanceof Document || node instanceof Window)));
+    }
+    getClosestParentWithInstance(node) {
+        let parent = node.__ngt_renderer__[NgtRendererClassId.parent];
+        while (parent && parent.__ngt_renderer__[NgtRendererClassId.type] !== 'three') {
+            parent = parent.__ngt_renderer__[NgtRendererClassId.portalContainer]
+                ? parent.__ngt_renderer__[NgtRendererClassId.portalContainer]
+                : parent.__ngt_renderer__[NgtRendererClassId.parent];
+        }
+        return parent;
+    }
+    getClosestParentWithCompound(node) {
+        if (node.__ngt_renderer__[NgtRendererClassId.compoundParent]) {
+            return node.__ngt_renderer__[NgtRendererClassId.compoundParent];
+        }
+        let parent = node.__ngt_renderer__[NgtRendererClassId.parent];
+        if (parent &&
+            parent.__ngt_renderer__[NgtRendererClassId.type] === 'compound' &&
+            !parent.__ngt_renderer__[NgtRendererClassId.compounded]) {
+            return parent;
+        }
+        while (parent &&
+            (parent.__ngt_renderer__[NgtRendererClassId.type] === 'three' ||
+                !parent.__ngt_renderer__[NgtRendererClassId.compoundParent] ||
+                parent.__ngt_renderer__[NgtRendererClassId.type] !== 'compound')) {
+            parent = parent.__ngt_renderer__[NgtRendererClassId.parent];
+        }
+        if (!parent)
+            return null;
+        if (parent.__ngt_renderer__[NgtRendererClassId.type] === 'three' &&
+            parent.__ngt_renderer__[NgtRendererClassId.compoundParent]) {
+            return parent.__ngt_renderer__[NgtRendererClassId.compoundParent];
+        }
+        if (!parent.__ngt_renderer__[NgtRendererClassId.compounded]) {
+            return parent;
+        }
+        return null;
+    }
+    processPortalContainer(portal) {
+        const injector = portal.__ngt_renderer__[NgtRendererClassId.injectorFactory]?.();
+        if (!injector)
+            return;
+        const portalStore = injector.get(NGT_STORE, null);
+        if (!portalStore)
+            return;
+        const portalContainer = portalStore.get('scene');
+        if (!portalContainer)
+            return;
+        portal.__ngt_renderer__[NgtRendererClassId.portalContainer] = this.createNode('three', portalContainer);
+    }
+    getCreationState() {
+        return [
+            this.firstNonInjectedDirective('argsCommentNodes', NgtArgs)?.args || [],
+            this.firstNonInjectedDirective('parentCommentNodes', NgtParent)?.parent || null,
+            this.tryGetPortalStore(),
+        ];
+    }
     setParent(node, parent) {
         if (!node.__ngt_renderer__[NgtRendererClassId.parent]) {
             node.__ngt_renderer__[NgtRendererClassId.parent] = parent;
@@ -1983,19 +1898,16 @@ class NgtRendererStore {
         if (instanceRS && instanceRS[NgtRendererClassId.parent]) {
             const parentRS = instanceRS[NgtRendererClassId.parent].__ngt_renderer__;
             // NOTE: if instance is already compounded by its parent. skip
-            if (parentRS[NgtRendererClassId.type] === 'compound' &&
-                parentRS[NgtRendererClassId.compounded] === instance) {
+            if (parentRS[NgtRendererClassId.type] === 'compound' && parentRS[NgtRendererClassId.compounded] === instance) {
                 return;
             }
         }
         const rS = compound.__ngt_renderer__;
         rS[NgtRendererClassId.compounded] = instance;
-        const attributes = Object.keys(rS[NgtRendererClassId.attributes]);
-        const properties = Object.keys(rS[NgtRendererClassId.properties]);
-        for (const key of attributes) {
+        for (const key of Object.keys(rS[NgtRendererClassId.attributes])) {
             this.applyAttribute(instance, key, rS[NgtRendererClassId.attributes][key]);
         }
-        for (const key of properties) {
+        for (const key of Object.keys(rS[NgtRendererClassId.properties])) {
             this.applyProperty(instance, key, rS[NgtRendererClassId.properties][key]);
         }
         this.executeOperation(compound);
@@ -2005,6 +1917,7 @@ class NgtRendererStore {
     }
     executeOperation(node, type = 'op') {
         const rS = node.__ngt_renderer__;
+        // TODO: maybe an array with pop() would work better
         if (rS[NgtRendererClassId.queueOps]?.size) {
             rS[NgtRendererClassId.queueOps].forEach((op) => {
                 if (op[NgtQueueOpClassId.type] === type) {
@@ -2014,19 +1927,6 @@ class NgtRendererStore {
             });
         }
     }
-    processPortalContainer(portal) {
-        const injectorFactory = portal.__ngt_renderer__[NgtRendererClassId.injectorFactory];
-        const injector = injectorFactory?.();
-        if (!injector)
-            return;
-        const portalStore = injector.get(NGT_STORE, null);
-        if (!portalStore)
-            return;
-        const portalContainer = portalStore.get('scene');
-        if (!portalContainer)
-            return;
-        portal.__ngt_renderer__[NgtRendererClassId.portalContainer] = this.createNode('three', portalContainer);
-    }
     applyAttribute(node, name, value) {
         const rS = node.__ngt_renderer__;
         if (rS[NgtRendererClassId.destroyed])
@@ -2039,7 +1939,10 @@ class NgtRendererStore {
                 priority = 0;
                 console.warn(`[NGT] "priority" is an invalid number, default to 0`);
             }
-            getLocalState(node).priority = priority;
+            const localState = getLocalState(node);
+            if (localState) {
+                localState.priority = priority;
+            }
         }
         if (name === SPECIAL_PROPERTIES.COMPOUND) {
             // NOTE: we set the compound property on instance node now so we know that this instance is being compounded
@@ -2049,11 +1952,15 @@ class NgtRendererStore {
         if (name === SPECIAL_PROPERTIES.ATTACH) {
             // NOTE: handle attach as tring
             const paths = value.split('.');
-            if (paths.length)
-                getLocalState(node).attach = paths;
+            if (paths.length) {
+                const localState = getLocalState(node);
+                if (localState) {
+                    localState.attach = paths;
+                }
+            }
             return;
         }
-        if (name === SPECIAL_PROPERTIES.VALUE) {
+        if (name === SPECIAL_PROPERTIES.RAW_VALUE) {
             // NOTE: coercion
             let maybeCoerced = value;
             if (maybeCoerced === '' || maybeCoerced === 'true' || maybeCoerced === 'false') {
@@ -2078,9 +1985,10 @@ class NgtRendererStore {
             value.nativeElement = node;
             return;
         }
-        const parent = getLocalState(node).parent() || rS[NgtRendererClassId.parent];
+        const localState = getLocalState(node);
+        const parent = localState?.instanceStore.get('parent') || rS[NgtRendererClassId.parent];
         // [rawValue]
-        if (getLocalState(node).isRaw && name === SPECIAL_PROPERTIES.VALUE) {
+        if (localState?.isRaw && name === SPECIAL_PROPERTIES.RAW_VALUE) {
             rS[NgtRendererClassId.rawValue] = value;
             if (parent)
                 attachThreeChild(parent, node);
@@ -2088,7 +1996,8 @@ class NgtRendererStore {
         }
         // [attach]
         if (name === SPECIAL_PROPERTIES.ATTACH) {
-            getLocalState(node).attach = Array.isArray(value) ? value.map((v) => v.toString()) : value;
+            if (localState)
+                localState.attach = Array.isArray(value) ? value.map((v) => v.toString()) : value;
             if (parent)
                 attachThreeChild(parent, node);
             return;
@@ -2102,62 +2011,8 @@ class NgtRendererStore {
         applyProps(node, { [name]: value });
         this.updateNativeProps(node, name, value);
     }
-    isCompound(name) {
-        return this.root.compoundPrefixes.some((prefix) => name.startsWith(prefix));
-    }
-    isDOM(node) {
-        const rS = node['__ngt_renderer__'];
-        return (!rS ||
-            (rS[NgtRendererClassId.type] !== 'compound' &&
-                (node instanceof Element || node instanceof Document || node instanceof Window)));
-    }
     get rootScene() {
-        return this.root.store.get('scene');
-    }
-    get portals() {
-        return this.root.portals;
-    }
-    getClosestParentWithInstance(node) {
-        let parent = node.__ngt_renderer__[NgtRendererClassId.parent];
-        while (parent && parent.__ngt_renderer__[NgtRendererClassId.type] !== 'three') {
-            parent = parent.__ngt_renderer__[NgtRendererClassId.portalContainer]
-                ? parent.__ngt_renderer__[NgtRendererClassId.portalContainer]
-                : parent.__ngt_renderer__[NgtRendererClassId.parent];
-        }
-        return parent;
-    }
-    getClosestParentWithCompound(node) {
-        if (node.__ngt_renderer__[NgtRendererClassId.compoundParent]) {
-            return node.__ngt_renderer__[NgtRendererClassId.compoundParent];
-        }
-        let parent = node.__ngt_renderer__[NgtRendererClassId.parent];
-        if (parent &&
-            parent.__ngt_renderer__[NgtRendererClassId.type] === 'compound' &&
-            !parent.__ngt_renderer__[NgtRendererClassId.compounded]) {
-            return parent;
-        }
-        while (parent &&
-            (parent.__ngt_renderer__[NgtRendererClassId.type] === 'three' ||
-                !parent.__ngt_renderer__[NgtRendererClassId.compoundParent] ||
-                parent.__ngt_renderer__[NgtRendererClassId.type] !== 'compound')) {
-            parent = parent.__ngt_renderer__[NgtRendererClassId.parent];
-        }
-        if (!parent)
-            return;
-        if (parent.__ngt_renderer__[NgtRendererClassId.type] === 'three' &&
-            parent.__ngt_renderer__[NgtRendererClassId.compoundParent]) {
-            return parent.__ngt_renderer__[NgtRendererClassId.compoundParent];
-        }
-        if (!parent.__ngt_renderer__[NgtRendererClassId.compounded]) {
-            return parent;
-        }
-        return null;
-    }
-    getCreationState() {
-        const injectedArgs = this.firstNonInjectedDirective(NgtArgs)?.args || [];
-        const injectedParent = this.firstNonInjectedDirective(NgtParent)?.parent || null;
-        const store = this.tryGetPortalStore();
-        return { injectedArgs, injectedParent, store };
+        return this.rootState.store.get('scene');
     }
     destroy(node, parent) {
         const rS = node.__ngt_renderer__;
@@ -2167,18 +2022,17 @@ class NgtRendererStore {
             rS[NgtRendererClassId.compound] = undefined;
             rS[NgtRendererClassId.compoundParent] = undefined;
             const localState = getLocalState(node);
-            if (localState.objects) {
-                untracked(localState.objects).forEach((obj) => this.destroy(obj, parent));
-            }
-            if (localState.nonObjects) {
-                untracked(localState.nonObjects).forEach((obj) => this.destroy(obj, parent));
+            if (localState?.instanceStore) {
+                localState.instanceStore.get('objects').forEach((obj) => this.destroy(obj, parent));
+                localState.instanceStore.get('nonObjects').forEach((obj) => this.destroy(obj, parent));
             }
-            if (localState.afterUpdate)
+            if (localState?.afterUpdate)
                 localState.afterUpdate.complete();
-            if (localState.afterAttach)
+            if (localState?.afterAttach)
                 localState.afterAttach.complete();
             delete localState['objects'];
             delete localState['nonObjects'];
+            delete localState['parent'];
             delete localState['nativeProps'];
             delete localState['add'];
             delete localState['remove'];
@@ -2186,24 +2040,20 @@ class NgtRendererStore {
             delete localState['afterAttach'];
             delete localState['store'];
             delete localState['handlers'];
-            if (!localState.primitive) {
+            if (!localState?.primitive) {
                 delete node['__ngt__'];
             }
         }
         if (rS[NgtRendererClassId.type] === 'comment') {
             rS[NgtRendererClassId.injectorFactory] = null;
             delete node[SPECIAL_INTERNAL_ADD_COMMENT];
-            const index = this.comments.findIndex((comment) => comment === node);
-            if (index > -1) {
-                this.comments.splice(index, 1);
+            if (!this.removeCommentNode(node, this.argsCommentNodes)) {
+                this.removeCommentNode(node, this.parentCommentNodes);
             }
         }
         if (rS[NgtRendererClassId.type] === 'portal') {
             rS[NgtRendererClassId.injectorFactory] = null;
-            const index = this.portals.findIndex((portal) => portal === node);
-            if (index > -1) {
-                this.portals.splice(index, 1);
-            }
+            this.removeCommentNode(node, this.portalCommentsNodes);
         }
         if (rS[NgtRendererClassId.type] === 'compound') {
             rS[NgtRendererClassId.compounded] = undefined;
@@ -2239,18 +2089,24 @@ class NgtRendererStore {
             this.removeChild(parent, node);
         }
     }
+    removeCommentNode(node, nodes) {
+        const index = nodes.findIndex((comment) => comment === node);
+        if (index > -1) {
+            nodes.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
     updateNativeProps(node, key, value) {
         const localState = getLocalState(node);
-        if (!localState || !localState.nativeProps)
-            return;
-        localState.nativeProps.set({ [key]: value });
+        localState?.setNativeProps(key, value);
     }
-    firstNonInjectedDirective(dir) {
+    firstNonInjectedDirective(listProperty, dir) {
         let directive;
         const destroyed = [];
-        let i = this.comments.length - 1;
+        let i = this[listProperty].length - 1;
         while (i >= 0) {
-            const comment = this.comments[i];
+            const comment = this[listProperty][i];
             if (comment.__ngt_renderer__[NgtRendererClassId.destroyed]) {
                 destroyed.push(i);
                 i--;
@@ -2269,7 +2125,7 @@ class NgtRendererStore {
             i--;
         }
         destroyed.forEach((index) => {
-            this.comments.splice(index, 1);
+            this[listProperty].splice(index, 1);
         });
         return directive;
     }
@@ -2277,10 +2133,10 @@ class NgtRendererStore {
         let store;
         const destroyed = [];
         // we only care about the portal states because NgtStore only differs per Portal
-        let i = this.portals.length - 1;
+        let i = this.portalCommentsNodes.length - 1;
         while (i >= 0) {
             // loop through the portal state backwards to find the closest NgtStore
-            const portal = this.portals[i];
+            const portal = this.portalCommentsNodes[i];
             if (portal.__ngt_renderer__[NgtRendererClassId.destroyed]) {
                 destroyed.push(i);
                 i--;
@@ -2300,72 +2156,62 @@ class NgtRendererStore {
             i--;
         }
         destroyed.forEach((index) => {
-            this.portals.splice(index, 1);
+            this.portalCommentsNodes.splice(index, 1);
         });
-        return store || this.root.store;
+        return store || this.rootState.store;
     }
 }
 
 class NgtRendererFactory {
     constructor() {
         this.delegateRendererFactory = inject(RendererFactory2, { skipSelf: true });
-        this.zone = inject(NgZone);
         this.catalogue = injectNgtCatalogue();
-        this.cdr = inject(ChangeDetectorRef);
         this.rendererMap = new Map();
         this.routedSet = new Set();
-        // all Renderer instances share the same Store
+        // NOTE: all Renderer instances under the same NgtCanvas share the same Store
         this.rendererStore = new NgtRendererStore({
-            portals: [],
             store: injectNgtStore(),
             compoundPrefixes: inject(NGT_COMPOUND_PREFIXES),
             document: inject(DOCUMENT),
         });
     }
     createRenderer(hostElement, type) {
-        const delegate = this.delegateRendererFactory.createRenderer(hostElement, type);
+        const delegateRenderer = this.delegateRendererFactory.createRenderer(hostElement, type);
         if (!type)
-            return delegate;
-        // TODO: handle html in canvas
+            return delegateRenderer;
+        // NOTE: might need to revisit this
         if (type['type'][HTML]) {
-            this.rendererMap.set(type.id, delegate);
-            return delegate;
+            this.rendererMap.set(type.id, delegateRenderer);
+            return delegateRenderer;
         }
         if (type['type'][ROUTED_SCENE]) {
             this.routedSet.add(type.id);
         }
         let renderer = this.rendererMap.get(type.id);
         if (!renderer) {
-            renderer = new NgtRenderer(delegate, this.rendererStore, this.catalogue, this.zone, this.cdr, 
+            this.rendererMap.set(type.id, (renderer = new NgtRenderer(delegateRenderer, this.rendererStore, this.catalogue, 
             // setting root scene if there's no routed scene OR this component is the routed Scene
-            !hostElement && (this.routedSet.size === 0 || this.routedSet.has(type.id)));
-            this.rendererMap.set(type.id, renderer);
+            !hostElement && (this.routedSet.size === 0 || this.routedSet.has(type.id)))));
         }
         return renderer;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtRendererFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtRendererFactory }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NgtRendererFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NgtRendererFactory }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtRendererFactory, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NgtRendererFactory, decorators: [{
             type: Injectable
         }] });
-/**
- * Anything abbreviated with rS/RS stands for RendererState
- */
 class NgtRenderer {
-    constructor(delegate, store, catalogue, zone, cdr, root = true) {
+    constructor(delegate, store, catalogue, isRoot = true) {
         this.delegate = delegate;
         this.store = store;
         this.catalogue = catalogue;
-        this.zone = zone;
-        this.cdr = cdr;
-        this.root = root;
+        this.isRoot = isRoot;
         this.createText = this.delegate.createText.bind(this.delegate);
         this.destroy = this.delegate.destroy.bind(this.delegate);
         this.destroyNode = null;
         this.selectRootElement = this.delegate.selectRootElement.bind(this.delegate);
         this.nextSibling = this.delegate.nextSibling.bind(this.delegate);
-        this.removeAttribute = this.delegate.removeAttribute.bind(this.delegate);
         this.addClass = this.delegate.addClass.bind(this.delegate);
         this.removeClass = this.delegate.removeClass.bind(this.delegate);
         this.setStyle = this.delegate.setStyle.bind(this.delegate);
@@ -2375,41 +2221,37 @@ class NgtRenderer {
     createElement(name, namespace) {
         const element = this.delegate.createElement(name, namespace);
         // on first pass, we return the Root Scene as the root node
-        if (this.root) {
-            this.root = false;
+        if (this.isRoot) {
+            this.isRoot = false;
             const node = this.store.createNode('three', this.store.rootScene);
-            node.__ngt_renderer__[NgtRendererClassId.injectorFactory] = () => getDebugNode(element).injector;
+            node.__ngt_renderer__[NgtRendererClassId.injectorFactory] = () => getDebugNode(element)?.injector;
             return node;
         }
-        // handle compound
         if (this.store.isCompound(name)) {
             return this.store.createNode('compound', element);
         }
-        // handle portal
         if (name === SPECIAL_DOM_TAG.NGT_PORTAL) {
             return this.store.createNode('portal', element);
         }
-        // handle raw value
         if (name === SPECIAL_DOM_TAG.NGT_VALUE) {
             return this.store.createNode('three', Object.assign({ __ngt_renderer__: { rawValue: undefined } }, 
             // NOTE: we assign this manually to a raw value node
             // because we say it is a 'three' node but we're not using prepare()
-            { __ngt__: { isRaw: true, parent: signal(null) } }));
+            { __ngt__: { isRaw: true, parent: () => null } }));
         }
-        const { injectedArgs, injectedParent, store } = this.store.getCreationState();
+        const [injectedArgs, injectedParent, store] = this.store.getCreationState();
         let parent = injectedParent;
         if (typeof injectedParent === 'string') {
             parent = store
                 .get('scene')
                 .getObjectByName(injectedParent);
         }
-        // handle primitive
         if (name === SPECIAL_DOM_TAG.NGT_PRIMITIVE) {
             if (!injectedArgs[0])
                 throw new Error(`[NGT] ngt-primitive without args is invalid`);
             const object = injectedArgs[0];
             let localState = getLocalState(object);
-            if (!Object.keys(localState).length) {
+            if (!localState) {
                 // NOTE: if an object isn't already "prepared", we prepare it
                 localState = getLocalState(prepare(object, { store, args: injectedArgs, primitive: true }));
             }
@@ -2421,8 +2263,7 @@ class NgtRenderer {
             }
             return node;
         }
-        const threeTag = name.startsWith('ngt') ? name.slice(4) : name;
-        const threeName = kebabToPascal(threeTag);
+        const threeName = kebabToPascal(name.startsWith('ngt') ? name.slice(4) : name);
         const threeTarget = this.catalogue[threeName];
         // we have the THREE constructor here, handle it
         if (threeTarget) {
@@ -2470,13 +2311,14 @@ class NgtRenderer {
         }
         if (cRS?.[NgtRendererClassId.injectedParent]) {
             if (is.ref(cRS[NgtRendererClassId.injectedParent])) {
-                const injector = cRS[NgtRendererClassId.injectorFactory]().get(Injector, null);
+                const injector = cRS[NgtRendererClassId.injectorFactory]()?.get(Injector, null);
                 if (!injector) {
                     console.warn(`[NGT] NgtRenderer is attempting to start an effect for injectedParent but no Injector is found.`);
                     return;
                 }
                 const watcher = effect(() => {
-                    const injectedParent = cRS[NgtRendererClassId.injectedParent].nativeElement;
+                    const injectedParent = cRS[NgtRendererClassId.injectedParent]
+                        .nativeElement;
                     if (injectedParent && injectedParent !== parent) {
                         this.appendChild(injectedParent, newChild);
                         // only run this effect once
@@ -2511,8 +2353,9 @@ class NgtRenderer {
         }
         // if both are three instances, straightforward case
         if (pRS[NgtRendererClassId.type] === 'three' && cRS?.[NgtRendererClassId.type] === 'three') {
+            const cLS = getLocalState(newChild);
             // if child already attached to a parent, skip
-            if (getLocalState(newChild).parent && untracked(getLocalState(newChild).parent))
+            if (cLS?.instanceStore?.get('parent'))
                 return;
             // attach THREE child
             attachThreeChild(parent, newChild);
@@ -2527,7 +2370,7 @@ class NgtRenderer {
         }
         // if only the parent is the THREE instance
         if (pRS[NgtRendererClassId.type] === 'three') {
-            for (const renderChild of cRS?.[NgtRendererClassId.children]) {
+            for (const renderChild of cRS?.[NgtRendererClassId.children] || []) {
                 this.appendChild(parent, renderChild);
             }
         }
@@ -2602,23 +2445,34 @@ class NgtRenderer {
             return rS[NgtRendererClassId.parent];
         return this.delegate.parentNode(node);
     }
-    setAttribute(el, name, value, namespace) {
+    setAttributeInternal(el, name, value, namespace) {
         const rS = el.__ngt_renderer__;
         if (rS[NgtRendererClassId.type] === 'compound') {
             // we don't have the compound instance yet
             rS[NgtRendererClassId.attributes][name] = value;
             if (!rS[NgtRendererClassId.compounded]) {
                 this.store.queueOperation(el, ['op', () => this.setAttribute(el, name, value, namespace)]);
-                return;
+                return false;
             }
-            this.setAttribute(rS[NgtRendererClassId.compounded], name, value, namespace);
-            return;
+            return this.setAttributeInternal(rS[NgtRendererClassId.compounded], name, value, namespace);
         }
         if (rS[NgtRendererClassId.type] === 'three') {
             this.store.applyAttribute(el, name, value);
-            return;
+            return false;
+        }
+        return true;
+    }
+    setAttribute(el, name, value, namespace) {
+        const useDelegate = this.setAttributeInternal(el, name, value, namespace);
+        if (useDelegate) {
+            this.delegate.setAttribute(el, name, value);
+        }
+    }
+    removeAttribute(el, name, namespace) {
+        const useDelegate = this.setAttributeInternal(el, name, undefined, namespace);
+        if (useDelegate) {
+            this.delegate.removeAttribute(el, name, namespace);
         }
-        return this.delegate.setAttribute(el, name, value);
     }
     setProperty(el, name, value) {
         // TODO: should we support ref value
@@ -2645,17 +2499,16 @@ class NgtRenderer {
     listen(target, eventName, callback) {
         const rS = target.__ngt_renderer__;
         // if the target doesn't have __ngt_renderer__, we delegate
-        // if target is DOM node, then we pass that to delegate Renderer
+        // if target is DOM node, we delegate
         if (!rS || this.store.isDOM(target)) {
             return this.delegate.listen(target, eventName, callback);
         }
         if (rS[NgtRendererClassId.type] === 'three' ||
             (rS[NgtRendererClassId.type] === 'compound' && rS[NgtRendererClassId.compounded])) {
             const instance = rS[NgtRendererClassId.compounded] || target;
-            const priority = getLocalState(target).priority;
-            const targetCdr = rS[NgtRendererClassId.injectorFactory]?.().get(ChangeDetectorRef, null) ||
-                rS[NgtRendererClassId.parent]?.__ngt_renderer__?.[NgtRendererClassId.injectorFactory]?.().get(ChangeDetectorRef, null);
-            return processThreeEvent(instance, priority || 0, eventName, callback, this.zone, this.cdr, targetCdr);
+            const localState = getLocalState(instance);
+            const priority = localState?.priority ?? 0;
+            return processThreeEvent(instance, priority || 0, eventName, callback);
         }
         if (rS[NgtRendererClassId.type] === 'compound' && !rS[NgtRendererClassId.compounded]) {
             this.store.queueOperation(target, [
@@ -2683,48 +2536,54 @@ class NgtRenderer {
         const cType = cRS[NgtRendererClassId.type];
         const isParentCompounded = pRS[NgtRendererClassId.compounded];
         const isChildCompounded = cRS[NgtRendererClassId.compounded];
+        const cLS = getLocalState(child);
         // if child is three but haven't been attached to a parent yet
-        const isDanglingThreeChild = cType === 'three' && !untracked(getLocalState(child).parent);
+        const isDanglingThreeChild = cType === 'three' && !cLS?.instanceStore?.get('parent');
         // or both parent and child are DOM elements
         // or they are compound AND haven't had a THREE instance yet
         const isParentStillDOM = pType === 'dom' || (pType === 'compound' && !isParentCompounded);
         const isChildStillDOM = cType === 'dom' || (cType === 'compound' && !isChildCompounded);
         // and the child is a compounded compound
         const isCompoundChildCompounded = cType === 'compound' && !!isChildCompounded;
-        return (isDanglingThreeChild ||
-            (isParentStillDOM && isChildStillDOM) ||
-            (isParentStillDOM && isCompoundChildCompounded));
+        return (isDanglingThreeChild || (isParentStillDOM && isChildStillDOM) || (isParentStillDOM && isCompoundChildCompounded));
     }
     get data() {
         return this.delegate.data;
     }
 }
-function provideNgtRenderer(store, compoundPrefixes, cdr) {
+function provideNgtRenderer(store, compoundPrefixes) {
     if (!compoundPrefixes.includes('ngts'))
         compoundPrefixes.push('ngts');
     if (!compoundPrefixes.includes('ngtp'))
         compoundPrefixes.push('ngtp');
     return makeEnvironmentProviders([
-        { provide: RendererFactory2, useClass: NgtRendererFactory },
+        NgtRendererFactory,
+        { provide: RendererFactory2, useExisting: NgtRendererFactory },
         { provide: NGT_COMPOUND_PREFIXES, useValue: compoundPrefixes },
-        { provide: ChangeDetectorRef, useValue: cdr },
         provideNgtStore(store),
         provideZoneChangeDetection({ runCoalescing: true, eventCoalescing: true }),
     ]);
 }
 
 class NgtCanvas {
+    set _sceneGraphInputs(value) {
+        this.sceneGraphInputs.set(value);
+    }
+    set _canvasInputs(value) {
+        this.canvasInputs.update(value);
+    }
     constructor() {
         this.store = injectNgtStore();
         this.initRoot = injectCanvasRootInitializer();
+        this.autoEffect = injectAutoEffect();
         this.host = inject(ElementRef);
         this.viewContainerRef = inject(ViewContainerRef);
-        this.injector = inject(Injector);
-        this.environmentInjector = inject(EnvironmentInjector);
         this.zone = inject(NgZone);
-        this.destroyRef = inject(DestroyRef);
-        this.cdr = inject(ChangeDetectorRef);
-        this.inputs = signalStore({
+        this.environmentInjector = inject(EnvironmentInjector);
+        this.injector = inject(Injector);
+        this.compoundPrefixes = [];
+        this.sceneGraphInputs = signal({}, { equal: Object.is });
+        this.canvasInputs = signalStore({
             shadows: false,
             linear: false,
             flat: false,
@@ -2734,102 +2593,49 @@ class NgtCanvas {
             dpr: [1, 2],
             events: createPointerEvents,
         });
-        this.sceneGraphInputs = {};
-        this.compoundPrefixes = [];
         this.created = new EventEmitter();
-        this.inputsEventSource = this.inputs.select('eventSource');
-        this.hbPointerEvents = computed(() => (!!this.inputsEventSource() ? 'none' : 'auto'));
-    }
-    set linear(linear) {
-        this.inputs.set({ linear });
-    }
-    set legacy(legacy) {
-        this.inputs.set({ legacy });
-    }
-    set flat(flat) {
-        this.inputs.set({ flat });
-    }
-    set orthographic(orthographic) {
-        this.inputs.set({ orthographic });
-    }
-    set frameloop(frameloop) {
-        this.inputs.set({ frameloop });
-    }
-    set dpr(dpr) {
-        this.inputs.set({ dpr });
-    }
-    set raycaster(raycaster) {
-        this.inputs.set({ raycaster });
-    }
-    set shadows(shadows) {
-        this.inputs.set({ shadows });
-    }
-    set camera(camera) {
-        this.inputs.set({ camera });
-    }
-    set scene(scene) {
-        this.inputs.set({ scene });
-    }
-    set gl(gl) {
-        this.inputs.set({ gl });
-    }
-    set eventSource(eventSource) {
-        this.inputs.set({ eventSource });
-    }
-    set eventPrefix(eventPrefix) {
-        this.inputs.set({ eventPrefix });
-    }
-    set lookAt(lookAt) {
-        this.inputs.set({ lookAt });
-    }
-    set performance(performance) {
-        this.inputs.set({ performance });
-    }
-    ngOnChanges(changes) {
-        if (changes['sceneGraphInputs'] && !changes['sceneGraphInputs'].firstChange && this.glRef) {
-            this.setSceneGraphInputs();
-        }
-    }
-    ngOnInit() {
-        // NOTE: we resolve glCanvas at this point, setup the configurator
-        this.configurator = this.initRoot(this.glCanvas.nativeElement);
-        this.destroyRef.onDestroy(() => {
-            this.glEnvironmentInjector?.destroy();
+        // NOTE: this signal is updated outside of Zone
+        this.resizeResult = signal({}, { equal: Object.is });
+        this.eventSource = this.canvasInputs.select('eventSource');
+        this.hbPointerEvents = computed(() => (this.eventSource() ? 'none' : 'auto'));
+        afterNextRender(() => {
+            this.zone.runOutsideAngular(() => {
+                this.configurator = this.initRoot(this.glCanvas.nativeElement);
+                this.noZoneResizeEffect();
+                this.noZoneSceneGraphInputsEffect();
+            });
+        });
+        inject(DestroyRef).onDestroy(() => {
             this.glRef?.destroy();
-            this.resizeEffectRef?.destroy();
-            injectNgtLoader.destroy();
+            this.glEnvironmentInjector?.destroy();
             this.configurator?.destroy();
         });
     }
-    // NOTE: runs outside of Zone due to emitInZone: false
-    onResize(result) {
-        if (result.width > 0 && result.height > 0) {
-            this.resizeEffectRef?.destroy();
-            const inputs = this.inputs.select();
-            // NOTE: go back into zone so that effect runs
-            // TODO: Double-check when effect is made not depended on zone
-            this.resizeEffectRef = this.zone.run(() => effect(() => {
-                this.zone.runOutsideAngular(() => {
-                    if (!this.configurator)
-                        this.configurator = this.initRoot(this.glCanvas.nativeElement);
-                    this.configurator.configure({ ...inputs(), size: result });
+    noZoneResizeEffect() {
+        this.autoEffect(() => {
+            const resizeResult = this.resizeResult();
+            if (resizeResult.width > 0 && resizeResult.height > 0) {
+                if (!this.configurator)
+                    this.configurator = this.initRoot(this.glCanvas.nativeElement);
+                this.configurator.configure({ ...this.canvasInputs.state(), size: resizeResult });
+                untracked(() => {
                     if (this.glRef) {
-                        this.cdr.detectChanges();
+                        this.glRef.changeDetectorRef.detectChanges();
                     }
                     else {
-                        this.render();
+                        this.noZoneRender();
                     }
                 });
-            }, { manualCleanup: true, injector: this.injector }));
-        }
+            }
+        });
     }
-    render() {
+    noZoneRender() {
+        // NOTE: destroy previous instances if existed
         this.glEnvironmentInjector?.destroy();
         this.glRef?.destroy();
-        // Flag the canvas active, rendering will now begin
-        this.store.set((state) => ({ internal: { ...state.internal, active: true } }));
-        const inputs = this.inputs.get();
-        const state = this.store.get();
+        // NOTE: Flag the canvas active, rendering will now begin
+        this.store.update((state) => ({ internal: { ...state.internal, active: true } }));
+        const [inputs, state] = [this.canvasInputs.snapshot, this.store.snapshot];
         // connect to event source
         state.events.connect?.(inputs.eventSource
             ? is.ref(inputs.eventSource)
@@ -2840,111 +2646,83 @@ class NgtCanvas {
         if (inputs.eventPrefix) {
             state.setEvents({
                 compute: (event, store) => {
-                    const innerState = store.get();
+                    const { pointer, raycaster, camera, size } = store.snapshot;
                     const x = event[(inputs.eventPrefix + 'X')];
                     const y = event[(inputs.eventPrefix + 'Y')];
-                    innerState.pointer.set((x / innerState.size.width) * 2 - 1, -(y / innerState.size.height) * 2 + 1);
-                    innerState.raycaster.setFromCamera(innerState.pointer, innerState.camera);
+                    pointer.set((x / size.width) * 2 - 1, -(y / size.height) * 2 + 1);
+                    raycaster.setFromCamera(pointer, camera);
                 },
             });
         }
         // emit created event if observed
         if (this.created.observed) {
-            // but go back into zone to do so
-            this.zone.run(() => {
-                this.created.emit(this.store.get());
-            });
+            this.created.emit(this.store.snapshot);
         }
         if (!this.store.get('events', 'connected')) {
             this.store.get('events').connect?.(this.glCanvas.nativeElement);
         }
-        this.glEnvironmentInjector = createEnvironmentInjector([provideNgtRenderer(this.store, this.compoundPrefixes, this.cdr)], this.environmentInjector);
+        this.glEnvironmentInjector = createEnvironmentInjector([provideNgtRenderer(this.store, this.compoundPrefixes)], this.environmentInjector);
         this.glRef = this.viewContainerRef.createComponent(this.sceneGraph, {
             environmentInjector: this.glEnvironmentInjector,
             injector: this.injector,
         });
-        this.overrideChangeDetectorRef();
-        this.setSceneGraphInputs();
-    }
-    overrideChangeDetectorRef() {
-        const originalDetectChanges = this.cdr.detectChanges.bind(this.cdr);
-        this.cdr.detectChanges = () => {
-            originalDetectChanges();
-            safeDetectChanges(this.glRef?.changeDetectorRef);
-        };
+        this.glRef.changeDetectorRef.detectChanges();
+        this.setSceneGraphInputs(untracked(this.sceneGraphInputs));
     }
-    setSceneGraphInputs() {
-        this.zone.run(() => {
-            if (this.glRef) {
-                for (const [key, value] of Object.entries(this.sceneGraphInputs)) {
-                    this.glRef.setInput(key, value);
-                }
-                this.glRef.changeDetectorRef.detectChanges();
-            }
+    noZoneSceneGraphInputsEffect() {
+        this.autoEffect(() => {
+            this.setSceneGraphInputs(this.sceneGraphInputs());
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtCanvas, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtCanvas, isStandalone: true, selector: "ngt-canvas", inputs: { sceneGraph: "sceneGraph", sceneGraphInputs: "sceneGraphInputs", compoundPrefixes: "compoundPrefixes", linear: "linear", legacy: "legacy", flat: "flat", orthographic: "orthographic", frameloop: "frameloop", dpr: "dpr", raycaster: "raycaster", shadows: "shadows", camera: "camera", scene: "scene", gl: "gl", eventSource: "eventSource", eventPrefix: "eventPrefix", lookAt: "lookAt", performance: "performance" }, outputs: { created: "created" }, host: { properties: { "style.pointerEvents": "hbPointerEvents()" }, styleAttribute: "display: block;position: relative;width: 100%;height: 100%;overflow: hidden;" }, providers: [provideNgxResizeOptions({ emitInZone: false, emitInitialResult: true }), provideNgtStore()], viewQueries: [{ propertyName: "glCanvas", first: true, predicate: ["glCanvas"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: `
-		<div (ngxResize)="onResize($event)" style="height: 100%; width: 100%;">
+    setSceneGraphInputs(sceneGraphInputs) {
+        if (this.glRef) {
+            for (const [key, value] of Object.entries(sceneGraphInputs)) {
+                this.glRef.setInput(key, value);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NgtCanvas, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.1", type: NgtCanvas, isStandalone: true, selector: "ngt-canvas", inputs: { sceneGraph: "sceneGraph", compoundPrefixes: "compoundPrefixes", _sceneGraphInputs: ["sceneGraphInputs", "_sceneGraphInputs"], _canvasInputs: ["options", "_canvasInputs"] }, outputs: { created: "created" }, host: { properties: { "style.pointerEvents": "hbPointerEvents()" }, styleAttribute: "display: block;position: relative;width: 100%;height: 100%;overflow: hidden;" }, providers: [
+            provideResizeOptions({ emitInZone: false, emitInitialResult: true, debounce: 250 }),
+            provideNgtStore(),
+        ], viewQueries: [{ propertyName: "glCanvas", first: true, predicate: ["glCanvas"], descendants: true, static: true }], ngImport: i0, template: `
+		<div (ngxResize)="resizeResult.set($event)" style="height: 100%; width: 100%;">
 			<canvas #glCanvas style="display: block;"></canvas>
 		</div>
 	`, isInline: true, dependencies: [{ kind: "directive", type: NgxResize, selector: "[ngxResize]", inputs: ["ngxResizeOptions"], outputs: ["ngxResize"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtCanvas, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NgtCanvas, decorators: [{
             type: Component,
             args: [{
                     selector: 'ngt-canvas',
                     standalone: true,
                     template: `
-		<div (ngxResize)="onResize($event)" style="height: 100%; width: 100%;">
+		<div (ngxResize)="resizeResult.set($event)" style="height: 100%; width: 100%;">
 			<canvas #glCanvas style="display: block;"></canvas>
 		</div>
 	`,
                     imports: [NgxResize],
-                    providers: [provideNgxResizeOptions({ emitInZone: false, emitInitialResult: true }), provideNgtStore()],
+                    providers: [
+                        provideResizeOptions({ emitInZone: false, emitInitialResult: true, debounce: 250 }),
+                        provideNgtStore(),
+                    ],
                     host: {
                         style: 'display: block;position: relative;width: 100%;height: 100%;overflow: hidden;',
                         '[style.pointerEvents]': 'hbPointerEvents()',
                     },
                     changeDetection: ChangeDetectionStrategy.OnPush,
                 }]
-        }], propDecorators: { sceneGraph: [{
+        }], ctorParameters: () => [], propDecorators: { sceneGraph: [{
                 type: Input,
                 args: [{ required: true }]
-            }], sceneGraphInputs: [{
-                type: Input
             }], compoundPrefixes: [{
                 type: Input
-            }], linear: [{
-                type: Input
-            }], legacy: [{
-                type: Input
-            }], flat: [{
-                type: Input
-            }], orthographic: [{
-                type: Input
-            }], frameloop: [{
-                type: Input
-            }], dpr: [{
-                type: Input
-            }], raycaster: [{
-                type: Input
-            }], shadows: [{
-                type: Input
-            }], camera: [{
-                type: Input
-            }], scene: [{
-                type: Input
-            }], gl: [{
-                type: Input
-            }], eventSource: [{
-                type: Input
-            }], eventPrefix: [{
-                type: Input
-            }], lookAt: [{
-                type: Input
-            }], performance: [{
-                type: Input
+            }], _sceneGraphInputs: [{
+                type: Input,
+                args: [{ alias: 'sceneGraphInputs' }]
+            }], _canvasInputs: [{
+                type: Input,
+                args: [{ alias: 'options' }]
             }], created: [{
                 type: Output
             }], glCanvas: [{
@@ -2952,62 +2730,82 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImpor
                 args: ['glCanvas', { static: true }]
             }] } });
 
-class NgtKey extends NgtCommonDirective {
-    constructor() {
-        super(...arguments);
-        this.lastKey = '';
-    }
-    static { this.processComment = false; }
-    validate() {
-        return false;
-    }
-    set key(key) {
-        const normalizedKey = JSON.stringify(key);
-        if (this.lastKey !== normalizedKey) {
-            this.lastKey = normalizedKey;
-            this.createView();
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtKey, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.2", type: NgtKey, isStandalone: true, selector: "ng-template[key]", inputs: { key: "key" }, usesInheritance: true, ngImport: i0 }); }
+const cached = new Map();
+function normalizeInputs(input) {
+    if (Array.isArray(input))
+        return input;
+    if (typeof input === 'string')
+        return [input];
+    return Object.values(input);
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtKey, decorators: [{
-            type: Directive,
-            args: [{ selector: 'ng-template[key]', standalone: true }]
-        }], propDecorators: { key: [{
-                type: Input
-            }] } });
-
-class NgtRepeat extends NgForOf {
-    set ngForRepeat(count) {
-        this.ngForOf = Number.isInteger(count) ? Array.from({ length: count }, (_, i) => i) : [];
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtRepeat, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.2", type: NgtRepeat, isStandalone: true, selector: "[ngFor][ngForRepeat]", inputs: { ngForRepeat: "ngForRepeat" }, usesInheritance: true, ngImport: i0 }); }
+function load(loaderConstructorFactory, inputs, { extensions, onProgress, } = {}) {
+    return () => {
+        const urls = normalizeInputs(inputs());
+        const loader = new (loaderConstructorFactory(urls))();
+        if (extensions)
+            extensions(loader);
+        // TODO: reevaluate this
+        return urls.map((url) => {
+            if (!cached.has(url)) {
+                cached.set(url, new Promise((resolve, reject) => {
+                    loader.load(url, (data) => {
+                        if ('scene' in data) {
+                            Object.assign(data, makeObjectGraph(data['scene']));
+                        }
+                        resolve(data);
+                    }, onProgress, (error) => reject(new Error(`[NGT] Could not load ${url}: ${error}`)));
+                }));
+            }
+            return cached.get(url);
+        });
+    };
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtRepeat, decorators: [{
-            type: Directive,
-            args: [{ selector: '[ngFor][ngForRepeat]', standalone: true }]
-        }], propDecorators: { ngForRepeat: [{
-                type: Input
-            }] } });
+function _injectNgtLoader(loaderConstructorFactory, inputs, { extensions, onProgress, injector, } = {}) {
+    return assertInjector(_injectNgtLoader, injector, () => {
+        const response = signal(null);
+        const effector = load(loaderConstructorFactory, inputs, { extensions, onProgress });
+        effect(() => {
+            const originalUrls = inputs();
+            Promise.all(effector()).then((results) => {
+                response.update(() => {
+                    if (Array.isArray(originalUrls))
+                        return results;
+                    if (typeof originalUrls === 'string')
+                        return results[0];
+                    const keys = Object.keys(originalUrls);
+                    return keys.reduce((result, key) => {
+                        result[key] = results[keys.indexOf(key)];
+                        return result;
+                    }, {});
+                });
+            });
+        });
+        return response.asReadonly();
+    });
+}
+_injectNgtLoader.preload = (loaderConstructorFactory, inputs, extensions) => {
+    void Promise.all(load(loaderConstructorFactory, inputs, { extensions })());
+};
+_injectNgtLoader.destroy = () => {
+    cached.clear();
+};
+const injectNgtLoader = _injectNgtLoader;
 
 function injectNgtRef(initial = null, injector) {
-    injector = assertInjectionContext(injectNgtRef);
-    const ref = is.ref(initial) ? initial : new ElementRef(initial);
-    const signalRef = signal(ref.nativeElement);
-    const readonlySignal = signalRef.asReadonly();
-    const cached = new Map();
-    return runInInjectionContext(injector, () => {
-        inject(DestroyRef).onDestroy(() => void cached.clear());
+    return assertInjector(injectNgtRef, injector, () => {
+        const ref = is.ref(initial) ? initial : new ElementRef(initial);
+        const refSignal = signal(ref.nativeElement, { equal: Object.is });
+        const readonlyRef = refSignal.asReadonly();
+        const computedCached = new Map();
+        inject(DestroyRef).onDestroy(() => void computedCached.clear());
         const children = (type = 'objects') => {
-            if (!cached.has(type)) {
-                cached.set(type, computed(() => {
-                    const instance = readonlySignal();
+            if (!computedCached.has(type)) {
+                computedCached.set(type, computed(() => {
+                    const instance = readonlyRef();
                     if (!instance)
                         return [];
                     const localState = getLocalState(instance);
-                    if (!localState.objects || !localState.nonObjects)
+                    if (!localState?.instanceStore)
                         return [];
                     if (type === 'objects')
                         return localState.objects();
@@ -3016,26 +2814,34 @@ function injectNgtRef(initial = null, injector) {
                     return [...localState.objects(), ...localState.nonObjects()];
                 }));
             }
-            return cached.get(type);
+            return computedCached.get(type);
         };
         Object.defineProperties(ref, {
             nativeElement: {
                 set: (newElement) => {
                     untracked(() => {
-                        if (newElement !== signalRef()) {
-                            signalRef.set(newElement);
+                        if (newElement !== readonlyRef()) {
+                            refSignal.set(newElement);
                         }
                     });
                 },
-                get: readonlySignal,
+                get: readonlyRef,
             },
-            untracked: { get: () => untracked(readonlySignal) },
-            children: { get: () => children },
+            children: { value: children },
         });
         return ref;
     });
 }
 
+function injectBeforeRender(cb, { priority = 0, injector } = {}) {
+    return assertInjector(injectBeforeRender, injector, () => {
+        const store = injectNgtStore();
+        const sub = store.get('internal').subscribe(cb, priority, store);
+        inject(DestroyRef).onDestroy(() => void sub());
+        return sub;
+    });
+}
+
 const privateKeys = [
     'get',
     'set',
@@ -3049,39 +2855,66 @@ const privateKeys = [
     'size',
     'viewport',
 ];
+const [, providePortalStore] = createInjectionToken((parentStore) => {
+    const parentState = parentStore.snapshot;
+    const pointer = new THREE.Vector2();
+    const raycaster = new THREE.Raycaster();
+    return signalStore(({ update }) => {
+        return {
+            ...parentState,
+            pointer,
+            raycaster,
+            previousRoot: parentStore,
+            // Layers are allowed to override events
+            setEvents: (events) => update((state) => ({ ...state, events: { ...state.events, ...events } })),
+        };
+    });
+}, { isRoot: false, token: NGT_STORE, deps: [[new SkipSelf(), NGT_STORE]] });
 class NgtPortalBeforeRender {
     constructor() {
         this.portalStore = injectNgtStore();
         this.injector = inject(Injector);
         this.renderPriority = 1;
-        this.beforeRender = new EventEmitter();
-    }
-    ngOnInit() {
-        let oldClear;
-        injectBeforeRender(({ delta, frame }) => {
-            this.beforeRender.emit({ ...this.portalStore.get(), delta, frame });
-            const { gl, scene, camera } = this.portalStore.get();
-            oldClear = gl.autoClear;
-            if (this.renderPriority === 1) {
-                // clear scene and render with default
-                gl.autoClear = true;
-                gl.render(this.parentScene, this.parentCamera);
-            }
-            // disable cleaning
-            gl.autoClear = false;
-            gl.clearDepth();
-            gl.render(scene, camera);
-            // restore
-            gl.autoClear = oldClear;
-        }, { priority: this.renderPriority, injector: this.injector });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtPortalBeforeRender, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.2", type: NgtPortalBeforeRender, isStandalone: true, selector: "[ngtPortalBeforeRender]", inputs: { renderPriority: "renderPriority", parentScene: "parentScene", parentCamera: "parentCamera" }, outputs: { beforeRender: "beforeRender" }, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtPortalBeforeRender, decorators: [{
-            type: Directive,
-            args: [{ selector: '[ngtPortalBeforeRender]', standalone: true }]
-        }], propDecorators: { renderPriority: [{
+        afterNextRender(() => {
+            let oldClear;
+            injectBeforeRender(() => {
+                const { gl, scene, camera } = this.portalStore.get();
+                oldClear = gl.autoClear;
+                if (this.renderPriority === 1) {
+                    // clear scene and render with default
+                    gl.autoClear = true;
+                    gl.render(this.parentScene, this.parentCamera);
+                }
+                // disable cleaning
+                gl.autoClear = false;
+                gl.clearDepth();
+                gl.render(scene, camera);
+                // restore
+                gl.autoClear = oldClear;
+            }, { priority: this.renderPriority, injector: this.injector });
+        });
+    }
+    onPointerOver() {
+        /* noop */
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NgtPortalBeforeRender, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.1", type: NgtPortalBeforeRender, isStandalone: true, selector: "ngt-portal-before-render", inputs: { renderPriority: "renderPriority", parentScene: "parentScene", parentCamera: "parentCamera" }, ngImport: i0, template: `
+		<!-- Without an element that receives pointer events state.pointer will always be 0/0 -->
+		<ngt-group (pointerover)="onPointerOver()" attach="none" />
+	`, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NgtPortalBeforeRender, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngt-portal-before-render',
+                    standalone: true,
+                    template: `
+		<!-- Without an element that receives pointer events state.pointer will always be 0/0 -->
+		<ngt-group (pointerover)="onPointerOver()" attach="none" />
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: () => [], propDecorators: { renderPriority: [{
                 type: Input
             }], parentScene: [{
                 type: Input,
@@ -3089,8 +2922,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImpor
             }], parentCamera: [{
                 type: Input,
                 args: [{ required: true }]
-            }], beforeRender: [{
-                type: Output
             }] } });
 class NgtPortalContent {
     constructor(vcr, parentVcr) {
@@ -3100,87 +2931,55 @@ class NgtPortalContent {
             delete commentNode[SPECIAL_INTERNAL_ADD_COMMENT];
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtPortalContent, deps: [{ token: i0.ViewContainerRef }, { token: i0.ViewContainerRef, skipSelf: true }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.2", type: NgtPortalContent, isStandalone: true, selector: "ng-template[ngtPortalContent]", ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NgtPortalContent, deps: [{ token: i0.ViewContainerRef }, { token: i0.ViewContainerRef, skipSelf: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.2.1", type: NgtPortalContent, isStandalone: true, selector: "ng-template[ngtPortalContent]", ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtPortalContent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NgtPortalContent, decorators: [{
             type: Directive,
             args: [{ selector: 'ng-template[ngtPortalContent]', standalone: true }]
-        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.ViewContainerRef, decorators: [{
+        }], ctorParameters: () => [{ type: i0.ViewContainerRef }, { type: i0.ViewContainerRef, decorators: [{
                     type: SkipSelf
-                }] }]; } });
+                }] }] });
 class NgtPortal {
-    set container(container) {
-        this.inputs.set({ container });
+    set _portalInputs(value) {
+        this.portalInputs.update(value);
     }
-    set portalState(state) {
-        this.inputs.set({ state });
+    set _autoRender(value) {
+        this.autoRender.set(value);
     }
     constructor() {
-        this.inputs = signalStore({ container: injectNgtRef(prepare(new THREE.Scene())) });
-        this.autoRender = true;
+        this.portalInputs = signalStore({
+            container: injectNgtRef(prepare(new THREE.Scene())),
+        });
+        this.autoRender = signal(false);
         this.autoRenderPriority = 1;
-        this.beforeRender = new EventEmitter();
+        this.destroyRef = inject(DestroyRef);
+        this.autoEffect = injectAutoEffect();
         this.parentStore = injectNgtStore({ skipSelf: true });
+        this.portalStore = injectNgtStore({ self: true });
+        this.portalRendered = signal(false);
+        this.renderAutoBeforeRender = computed(() => this.portalRendered() && this.autoRender());
         this.parentScene = this.parentStore.get('scene');
         this.parentCamera = this.parentStore.get('camera');
-        this.portalStore = injectNgtStore({ self: true });
-        this.injector = inject(Injector);
-        this.zone = inject(NgZone);
-        this.raycaster = new THREE.Raycaster();
-        this.pointer = new THREE.Vector2();
-        this.portalContentRendered = false;
-        inject(DestroyRef).onDestroy(() => {
-            if (this.portalContentView && !this.portalContentView.destroyed) {
-                this.portalContentView.destroy();
-            }
-        });
-    }
-    ngOnInit() {
-        const previousState = this.parentStore.get();
-        const inputsState = this.inputs.get();
-        if (!inputsState.state && this.autoRender) {
-            inputsState.state = { events: { priority: this.autoRenderPriority + 1 } };
-        }
-        const { events, size, ...restInputsState } = inputsState.state || {};
-        const containerState = inputsState.container;
-        let container = is.ref(containerState) ? containerState.nativeElement : containerState;
-        if (!is.instance(container)) {
-            container = prepare(container);
-        }
-        const localState = getLocalState(container);
-        if (!localState.store) {
-            localState.store = this.portalStore;
-        }
-        this.portalStore.set({
-            ...previousState,
-            scene: container,
-            raycaster: this.raycaster,
-            pointer: this.pointer,
-            previousRoot: this.parentStore,
-            events: { ...previousState.events, ...(events || {}) },
-            size: { ...previousState.size, ...(size || {}) },
-            ...restInputsState,
-            setEvents: (events) => this.portalStore.set((state) => ({ ...state, events: { ...state.events, ...events } })),
-        });
-        const parentState = this.parentStore.select();
-        effect(() => {
-            const previous = parentState();
-            this.zone.runOutsideAngular(() => {
-                this.portalStore.set((state) => this.inject(previous, state));
+        afterNextRender(() => {
+            const parentState = this.parentStore.snapshot;
+            const { container, state: { events = {}, size = {}, ...rest }, } = this.portalInputs.snapshot;
+            this.portalStore.update({
+                scene: (is.ref(container) ? container.nativeElement : container),
+                events: { ...parentState.events, ...events },
+                size: { ...parentState.size, ...size },
+                ...rest,
             });
-        }, { injector: this.injector });
-        requestAnimationFrame(() => {
-            this.portalStore.set((injectState) => this.inject(this.parentStore.get(), injectState));
-        });
-        this.portalContentView = this.portalContentAnchor.createEmbeddedView(this.portalContentTemplate);
-        safeDetectChanges(this.portalContentView);
-        this.portalContentRendered = true;
-    }
-    onBeforeRender(portal) {
-        this.beforeRender.emit({
-            root: { ...this.parentStore.get(), delta: portal.delta, frame: portal.frame },
-            portal,
+            this.autoEffect(() => {
+                const previous = this.parentStore.state();
+                this.portalStore.update((state) => this.inject(previous, state));
+            });
+            untracked(() => {
+                const portalView = this.portalContentAnchor.createEmbeddedView(this.portalContentTemplate);
+                portalView.detectChanges();
+                this.destroyRef.onDestroy(portalView.destroy.bind(portalView));
+            });
+            this.portalRendered.set(true);
         });
     }
     inject(rootState, injectState) {
@@ -3191,7 +2990,7 @@ class NgtPortal {
                 delete intersect[key];
             }
         });
-        const inputs = this.inputs.get();
+        const inputs = this.portalInputs.snapshot;
         const { size, events, ...restInputsState } = inputs.state || {};
         let viewport = undefined;
         if (injectState && size) {
@@ -3203,8 +3002,6 @@ class NgtPortal {
         return {
             ...intersect,
             scene: is.ref(inputs.container) ? inputs.container.nativeElement : inputs.container,
-            raycaster: this.raycaster,
-            pointer: this.pointer,
             previousRoot: this.parentStore,
             events: { ...rootState.events, ...(injectState?.events || {}), ...events },
             size: { ...rootState.size, ...size },
@@ -3212,51 +3009,47 @@ class NgtPortal {
             ...restInputsState,
         };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtPortal, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtPortal, isStandalone: true, selector: "ngt-portal", inputs: { container: "container", portalState: ["state", "portalState"], autoRender: "autoRender", autoRenderPriority: "autoRenderPriority" }, outputs: { beforeRender: "beforeRender" }, providers: [{ provide: NGT_STORE, useFactory: () => signalStore({}) }], queries: [{ propertyName: "portalContentTemplate", first: true, predicate: NgtPortalContent, descendants: true, read: TemplateRef, static: true }], viewQueries: [{ propertyName: "portalContentAnchor", first: true, predicate: ["portalContentAnchor"], descendants: true, read: ViewContainerRef, static: true }], ngImport: i0, template: `
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NgtPortal, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.2.1", type: NgtPortal, isStandalone: true, selector: "ngt-portal", inputs: { _portalInputs: ["options", "_portalInputs"], _autoRender: ["autoRender", "_autoRender"], autoRenderPriority: "autoRenderPriority" }, providers: [providePortalStore()], queries: [{ propertyName: "portalContentTemplate", first: true, predicate: NgtPortalContent, descendants: true, read: TemplateRef, static: true }], viewQueries: [{ propertyName: "portalContentAnchor", first: true, predicate: ["portalContentAnchor"], descendants: true, read: ViewContainerRef, static: true }], ngImport: i0, template: `
 		<ng-container #portalContentAnchor>
-			<ng-container
-				*ngIf="autoRender && portalContentRendered"
-				ngtPortalBeforeRender
-				[renderPriority]="autoRenderPriority"
-				[parentScene]="parentScene"
-				[parentCamera]="parentCamera"
-				(beforeRender)="onBeforeRender($event)"
-			/>
+			@if (renderAutoBeforeRender()) {
+				<ngt-portal-before-render
+					[renderPriority]="autoRenderPriority"
+					[parentScene]="parentScene"
+					[parentCamera]="parentCamera"
+				/>
+			}
 		</ng-container>
-	`, isInline: true, dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgtPortalBeforeRender, selector: "[ngtPortalBeforeRender]", inputs: ["renderPriority", "parentScene", "parentCamera"], outputs: ["beforeRender"] }] }); }
+	`, isInline: true, dependencies: [{ kind: "component", type: NgtPortalBeforeRender, selector: "ngt-portal-before-render", inputs: ["renderPriority", "parentScene", "parentCamera"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtPortal, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NgtPortal, decorators: [{
             type: Component,
             args: [{
                     selector: 'ngt-portal',
                     standalone: true,
                     template: `
 		<ng-container #portalContentAnchor>
-			<ng-container
-				*ngIf="autoRender && portalContentRendered"
-				ngtPortalBeforeRender
-				[renderPriority]="autoRenderPriority"
-				[parentScene]="parentScene"
-				[parentCamera]="parentCamera"
-				(beforeRender)="onBeforeRender($event)"
-			/>
+			@if (renderAutoBeforeRender()) {
+				<ngt-portal-before-render
+					[renderPriority]="autoRenderPriority"
+					[parentScene]="parentScene"
+					[parentCamera]="parentCamera"
+				/>
+			}
 		</ng-container>
 	`,
-                    imports: [NgIf, NgtPortalBeforeRender],
-                    providers: [{ provide: NGT_STORE, useFactory: () => signalStore({}) }],
+                    imports: [NgtPortalBeforeRender],
+                    providers: [providePortalStore()],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
                 }]
-        }], ctorParameters: function () { return []; }, propDecorators: { container: [{
-                type: Input
-            }], portalState: [{
+        }], ctorParameters: () => [], propDecorators: { _portalInputs: [{
                 type: Input,
-                args: ['state']
-            }], autoRender: [{
-                type: Input
+                args: [{ alias: 'options' }]
+            }], _autoRender: [{
+                type: Input,
+                args: [{ alias: 'autoRender' }]
             }], autoRenderPriority: [{
                 type: Input
-            }], beforeRender: [{
-                type: Output
             }], portalContentTemplate: [{
                 type: ContentChild,
                 args: [NgtPortalContent, { read: TemplateRef, static: true }]
@@ -3272,14 +3065,14 @@ class NgtRoutedScene {
     constructor(router, cdr) {
         router.events
             .pipe(filter((event) => event instanceof ActivationEnd), takeUntilDestroyed())
-            .subscribe(() => safeDetectChanges(cdr));
+            .subscribe(cdr.detectChanges.bind(cdr));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtRoutedScene, deps: [{ token: i1.Router }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtRoutedScene, isStandalone: true, selector: "ngt-routed-scene", ngImport: i0, template: `
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NgtRoutedScene, deps: [{ token: i1.Router }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.1", type: NgtRoutedScene, isStandalone: true, selector: "ngt-routed-scene", ngImport: i0, template: `
 		<router-outlet />
 	`, isInline: true, dependencies: [{ kind: "directive", type: RouterOutlet, selector: "router-outlet", inputs: ["name"], outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtRoutedScene, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NgtRoutedScene, decorators: [{
             type: Component,
             args: [{
                     standalone: true,
@@ -3289,11 +3082,44 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImpor
 	`,
                     imports: [RouterOutlet],
                 }]
-        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i0.ChangeDetectorRef }]; } });
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i0.ChangeDetectorRef }] });
+
+// TODO: use scheduler instead of force CD
+function cdAwareSignal(initialValue, { injector, ...options } = {}) {
+    return assertInjector(cdAwareSignal, injector, () => {
+        if (!options.equal) {
+            options.equal = Object.is;
+        }
+        const cdr = inject(ChangeDetectorRef);
+        const source = signal(initialValue, options);
+        const originalSet = source.set.bind(source);
+        const originalUpdate = source.update.bind(source);
+        source.set = (...args) => {
+            originalSet(...args);
+            cdr.detectChanges();
+        };
+        source.update = (...args) => {
+            originalUpdate(...args);
+            cdr.detectChanges();
+        };
+        return source;
+    });
+}
+
+function apiFactory(obj) {
+    return obj.api;
+}
+function createApiToken(forwardedObject) {
+    const [injectFn, provideFn] = createInjectionToken((apiFactory), {
+        isRoot: false,
+        deps: [forwardRef(forwardedObject)],
+    });
+    return [injectFn, () => provideFn()];
+}
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { HTML, NGT_STORE, NgtArgs, NgtCanvas, NgtKey, NgtParent, NgtPortal, NgtPortalContent, NgtRepeat, NgtRoutedScene, addAfterEffect, addEffect, addTail, applyProps, assertInjectionContext, checkNeedsUpdate, checkUpdate, createAttachFunction, createInjectionToken, diffProps, extend, getLocalState, injectBeforeRender, injectNgtLoader, injectNgtRef, injectNgtStore, invalidateInstance, is, makeDefaultCamera, makeDefaultRenderer, makeDpr, makeId, makeObjectGraph, prepare, provideNgtRenderer, provideNgtStore, safeDetectChanges, signalStore, updateCamera };
+export { HTML, NGT_STORE, NgtArgs, NgtCanvas, NgtPortal, NgtPortalContent, NgtRenderer, NgtRendererFactory, NgtRoutedScene, ROUTED_SCENE, addAfterEffect, addEffect, addTail, applyProps, cdAwareSignal, checkNeedsUpdate, checkUpdate, createApiToken, createAttachFunction, extend, getLocalState, injectBeforeRender, injectNgtLoader, injectNgtRef, injectNgtStore, invalidateInstance, is, makeCameraInstance, makeDpr, makeId, makeObjectGraph, makeRendererInstance, prepare, provideNgtRenderer, provideNgtStore, signalStore, updateCamera };
 //# sourceMappingURL=angular-three.mjs.map