@ngxs/store 21.0.0 → 22.0.0-dev.master-d79b246

package/fesm2022/ngxs-store.mjs

@@ -1,12 +1,12 @@
 import * as i0 from '@angular/core';
-import { inject, Injectable, DestroyRef, NgZone, Injector, runInInjectionContext, InjectionToken, ErrorHandler, ɵisPromise as _isPromise, computed, makeEnvironmentProviders, provideEnvironmentInitializer, NgModule, APP_BOOTSTRAP_LISTENER, PendingTasks, ApplicationRef, assertInInjectionContext, EnvironmentInjector, createEnvironmentInjector } from '@angular/core';
-import { config, Observable, Subject, of, forkJoin, map, shareReplay, filter, take, mergeMap, EMPTY, from, isObservable, defaultIfEmpty, takeUntil, finalize, catchError, distinctUntilChanged, startWith, skip, buffer, debounceTime } from 'rxjs';
-import { ɵwrapObserverCalls as _wrapObserverCalls, ɵOrderedSubject as _OrderedSubject, ɵStateStream as _StateStream, ɵhasOwnProperty as _hasOwnProperty, ɵmemoize as _memoize, ɵgetStoreMetadata as _getStoreMetadata, ɵgetSelectorMetadata as _getSelectorMetadata, ɵMETA_KEY as _META_KEY, ɵINITIAL_STATE_TOKEN as _INITIAL_STATE_TOKEN, ɵNgxsActionRegistry as _NgxsActionRegistry, ɵNgxsAppBootstrappedState as _NgxsAppBootstrappedState, ɵensureStoreMetadata as _ensureStoreMetadata, ɵMETA_OPTIONS_KEY as _META_OPTIONS_KEY, ɵensureSelectorMetadata as _ensureSelectorMetadata, ɵNGXS_STATE_CONTEXT_FACTORY as _NGXS_STATE_CONTEXT_FACTORY, ɵNGXS_STATE_FACTORY as _NGXS_STATE_FACTORY } from '@ngxs/store/internals';
+import { inject, Injectable, DestroyRef, NgZone, Injector, runInInjectionContext, InjectionToken, ErrorHandler, EnvironmentInjector, ɵisPromise as _isPromise, computed, makeEnvironmentProviders, provideEnvironmentInitializer, assertInInjectionContext, createEnvironmentInjector, NgModule, APP_BOOTSTRAP_LISTENER, PendingTasks, ApplicationRef } from '@angular/core';
+import { config, Observable, Subject, of, forkJoin, map, shareReplay, mergeMap, EMPTY, filter, from, isObservable, defaultIfEmpty, takeUntil, finalize, catchError, distinctUntilChanged, take, buffer, debounceTime } from 'rxjs';
+import { ɵwrapObserverCalls as _wrapObserverCalls, ɵOrderedSubject as _OrderedSubject, ɵStateStream as _StateStream, ɵhasOwnProperty as _hasOwnProperty, ɵmemoize as _memoize, ɵgetStoreMetadata as _getStoreMetadata, ɵgetSelectorMetadata as _getSelectorMetadata, ɵMETA_KEY as _META_KEY, ɵNGXS_DEVELOPMENT_OPTIONS as _NGXS_DEVELOPMENT_OPTIONS, ɵINITIAL_STATE_TOKEN as _INITIAL_STATE_TOKEN, ɵNgxsActionRegistry as _NgxsActionRegistry, ɵNGXS_APP_BOOTSTRAP_STATE as _NGXS_APP_BOOTSTRAP_STATE, ɵensureStoreMetadata as _ensureStoreMetadata, ɵMETA_OPTIONS_KEY as _META_OPTIONS_KEY, ɵensureSelectorMetadata as _ensureSelectorMetadata, ɵNGXS_STATE_CONTEXT_FACTORY as _NGXS_STATE_CONTEXT_FACTORY, ɵNGXS_STATE_FACTORY as _NGXS_STATE_FACTORY } from '@ngxs/store/internals';
 export { StateToken } from '@ngxs/store/internals';
 import { NGXS_PLUGINS, getActionTypeFromInstance, InitState, UpdateState, setValue, getValue, ɵisPluginClass as _isPluginClass } from '@ngxs/store/plugins';
 export { InitState, NGXS_PLUGINS, UpdateState, actionMatcher, getActionTypeFromInstance, getValue, setValue } from '@ngxs/store/plugins';
 import { isStateOperator } from '@ngxs/store/operators';
-import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { toObservable, takeUntilDestroyed } from '@angular/core/rxjs-interop';
 
 class PluginManager {
     plugins = [];
@@ -31,10 +31,10 @@ class PluginManager {
         const handlers = this._pluginHandlers || [];
         return handlers.map((plugin) => (plugin.handle ? plugin.handle.bind(plugin) : plugin));
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: PluginManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: PluginManager, providedIn: 'root' });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: PluginManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: PluginManager, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: PluginManager, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: PluginManager, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
@@ -131,12 +131,15 @@ class InternalDispatchedActionResults extends Subject {
         // Complete the subject once the root injector is destroyed to ensure
         // there are no active subscribers that would receive events or perform
         // any actions after the application is destroyed.
-        inject(DestroyRef).onDestroy(() => this.complete());
+        inject(DestroyRef).onDestroy(() => {
+            this.complete();
+            this.unsubscribe();
+        });
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: InternalDispatchedActionResults, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: InternalDispatchedActionResults, providedIn: 'root' });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: InternalDispatchedActionResults, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: InternalDispatchedActionResults, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: InternalDispatchedActionResults, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: InternalDispatchedActionResults, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
@@ -164,10 +167,10 @@ class InternalNgxsExecutionStrategy {
         }
         return func();
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: InternalNgxsExecutionStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: InternalNgxsExecutionStrategy, providedIn: 'root' });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: InternalNgxsExecutionStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: InternalNgxsExecutionStrategy, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: InternalNgxsExecutionStrategy, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: InternalNgxsExecutionStrategy, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -202,13 +205,15 @@ class InternalActions extends _OrderedSubject {
             // there are no active subscribers that would receive events or perform
             // any actions after the application is destroyed.
             this.complete();
+            this.unsubscribe();
             this.dispatched$.complete();
+            this.dispatched$.unsubscribe();
         });
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: InternalActions, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: InternalActions, providedIn: 'root' });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: InternalActions, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: InternalActions, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: InternalActions, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: InternalActions, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
@@ -238,10 +243,10 @@ class Actions extends Observable {
             observer.add(childSubscription);
         });
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: Actions, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: Actions, providedIn: 'root' });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: Actions, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: Actions, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: Actions, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: Actions, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
@@ -296,7 +301,23 @@ class InternalDispatcher {
         ])(prevState, action).pipe(shareReplay());
     }
     getActionResultStream(action) {
-        return this._actionResults.pipe(filter((ctx) => ctx.action === action && ctx.status !== ActionStatus.Dispatched), take(1), shareReplay());
+        // Hot path: avoid allocating `filter` + `take(1)` operator subscriber wrappers on every
+        // dispatch. Instead, subscribe directly and complete inline — functionally identical but
+        // without the intermediate operator chain objects.
+        // `subscriber.complete()` triggers the outer subscription's teardown synchronously, which
+        // calls `.unsubscribe()` on the inner `_actionResults` subscription (the returned
+        // TeardownLogic), so there is no leak even though unsubscription fires mid-callback.
+        return new Observable(subscriber => {
+            return this._actionResults.subscribe({
+                next: ctx => {
+                    if (ctx.action === action && ctx.status !== ActionStatus.Dispatched) {
+                        subscriber.next(ctx);
+                        subscriber.complete();
+                    }
+                },
+                complete: () => !subscriber.closed && subscriber.complete()
+            });
+        }).pipe(shareReplay());
     }
     createDispatchObservable(actionResult$) {
         return actionResult$.pipe(mergeMap((ctx) => {
@@ -314,10 +335,10 @@ class InternalDispatcher {
             }
         }), shareReplay());
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: InternalDispatcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: InternalDispatcher, providedIn: 'root' });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: InternalDispatcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: InternalDispatcher, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: InternalDispatcher, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: InternalDispatcher, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -384,8 +405,8 @@ class NgxsConfig {
         injectContainerState: false,
         suppressErrors: false
     };
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsConfig, providedIn: 'root', useFactory: () => {
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsConfig, providedIn: 'root', useFactory: () => {
             const defaultConfig = new NgxsConfig();
             const config = inject(NGXS_OPTIONS);
             return {
@@ -398,7 +419,7 @@ class NgxsConfig {
             };
         } });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsConfig, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsConfig, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -482,10 +503,10 @@ class InternalStateOperations {
         // Set the state to the current + new
         stateOperations.setState({ ...currentState, ...results.defaults });
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: InternalStateOperations, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: InternalStateOperations, providedIn: 'root' });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: InternalStateOperations, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: InternalStateOperations, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: InternalStateOperations, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: InternalStateOperations, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -547,7 +568,7 @@ function createMemoizedSelectorFn(originalFn, creationMetadata) {
         }
         return returnValue;
     };
-    const memoizedFn = _memoize(wrappedFn);
+    const memoizedFn = _memoize(wrappedFn, originalFn);
     Object.setPrototypeOf(memoizedFn, originalFn);
     return memoizedFn;
 }
@@ -673,7 +694,7 @@ function buildGraph(stateClasses) {
         const meta = stateClass[_META_KEY];
         graph[meta.name] = (meta.children || []).map(findName);
         return graph;
-    }, {});
+    }, Object.create(null));
 }
 /**
  * Given a states array, returns object graph
@@ -690,7 +711,7 @@ function nameToState(states) {
         const meta = stateClass[_META_KEY];
         result[meta.name] = stateClass;
         return result;
-    }, {});
+    }, Object.create(null));
 }
 /**
  * Given a object relationship graph will return the full path
@@ -712,7 +733,7 @@ function nameToState(states) {
  *
  * @ignore
  */
-function findFullParentPath(obj, out = {}) {
+function findFullParentPath(obj, out = Object.create(null)) {
     // Recursively find the full dotted parent path for a given key.
     const find = (graph, target) => {
         for (const key in graph) {
@@ -751,7 +772,7 @@ function findFullParentPath(obj, out = {}) {
  */
 function topologicalSort(graph) {
     const sorted = [];
-    const visited = {};
+    const visited = Object.create(null);
     // DFS (Depth-First Search) to visit each node and its dependencies.
     const visit = (name, ancestors = []) => {
         visited[name] = true;
@@ -860,12 +881,6 @@ function jit_hasInjectableAnnotation(stateClass) {
     return annotations.some((annotation) => annotation?.ngMetadataName === 'Injectable');
 }
 
-const NGXS_DEVELOPMENT_OPTIONS = 
-/* @__PURE__ */ new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'NGXS_DEVELOPMENT_OPTIONS' : '', {
-    providedIn: 'root',
-    factory: () => ({ warnOnUnhandledActions: true })
-});
-
 class NgxsUnhandledActionsLogger {
     /**
      * These actions should be ignored by default; the user can increase this
@@ -873,7 +888,7 @@ class NgxsUnhandledActionsLogger {
      */
     _ignoredActions = new Set([InitState.type, UpdateState.type]);
     constructor() {
-        const options = inject(NGXS_DEVELOPMENT_OPTIONS);
+        const options = inject(_NGXS_DEVELOPMENT_OPTIONS);
         if (typeof options.warnOnUnhandledActions === 'object') {
             this.ignoreActions(...options.warnOnUnhandledActions.ignore);
         }
@@ -898,10 +913,10 @@ class NgxsUnhandledActionsLogger {
                 : action.type;
         console.warn(`The ${action} action has been dispatched but hasn't been handled. This may happen if the state with an action handler for this action is not registered.`);
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsUnhandledActionsLogger, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsUnhandledActionsLogger });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsUnhandledActionsLogger, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsUnhandledActionsLogger });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsUnhandledActionsLogger, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsUnhandledActionsLogger, decorators: [{
             type: Injectable
         }], ctorParameters: () => [] });
 
@@ -922,10 +937,10 @@ class NgxsUnhandledErrorHandler {
         // `handleError` (see `_callAndReportToErrorHandler`).
         this._ngZone.runOutsideAngular(() => this._errorHandler.handleError(error));
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsUnhandledErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsUnhandledErrorHandler, providedIn: 'root' });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsUnhandledErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsUnhandledErrorHandler, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsUnhandledErrorHandler, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsUnhandledErrorHandler, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -1023,13 +1038,13 @@ function createAllowedActionTypesMap(types) {
     return types.reduce((filterMap, klass) => {
         filterMap[getActionTypeFromInstance(klass)] = true;
         return filterMap;
-    }, {});
+    }, Object.create(null));
 }
 function createAllowedStatusesMap(statuses) {
     return statuses.reduce((filterMap, status) => {
         filterMap[status] = true;
         return filterMap;
-    }, {});
+    }, Object.create(null));
 }
 
 function simplePatch(value) {
@@ -1051,35 +1066,74 @@ function simplePatch(value) {
     };
 }
 
+class StateContextDestroyedError extends Error {
+    path;
+    name = 'StateContextDestroyedError';
+    constructor(path) {
+        super(typeof ngDevMode !== 'undefined' && ngDevMode
+            ? `Attempted to interact with state after the injector has been destroyed. State path: "${path}". ` +
+                `This can happen in server-side rendering when the app is destroyed before all async operations complete, ` +
+                `e.g. inside a finalize() operator that runs after the injector has been destroyed.`
+            : path);
+        this.path = path;
+        Object.setPrototypeOf(this, StateContextDestroyedError.prototype);
+    }
+}
 /**
- * State Context factory class
+ * Creates `StateContext` instances scoped to a specific state path.
+ * Each action handler receives one of these contexts so it can read and
+ * write only its own slice of the global state tree.
  * @ignore
  */
 class StateContextFactory {
+    _injector = inject(EnvironmentInjector);
     _internalStateOperations = inject(InternalStateOperations);
+    // Resolved lazily via `setErrorHandler` to avoid a cyclic dependency when
+    // the ErrorHandler itself injects the Store.
+    _errorHandler = null;
     /**
      * Create the state context
      */
     createStateContext(path, abortSignal) {
+        const injector = this._injector;
+        const errorHandler = this._errorHandler;
         const root = this._internalStateOperations.getRootStateOperations();
         return {
             abortSignal,
             getState() {
+                if (injector.destroyed) {
+                    // Only report — do not return early. Returning `undefined as T` would
+                    // be a breaking change for callers that assume getState() always
+                    // returns a value. handleError is just for observability (e.g. Rollbar);
+                    // the state data is still readable even after the injector is gone.
+                    errorHandler?.handleError(new StateContextDestroyedError(path));
+                }
                 const currentAppState = root.getState();
                 return getState(currentAppState, path);
             },
-            patchState(val) {
+            patchState(value) {
+                // If the injector has been destroyed (e.g. app destroyed mid-action),
+                // skip the state update to avoid writing to completed subjects.
+                if (injector.destroyed) {
+                    errorHandler?.handleError(new StateContextDestroyedError(path));
+                    return;
+                }
                 const currentAppState = root.getState();
-                const patchOperator = simplePatch(val);
-                setStateFromOperator(root, currentAppState, patchOperator, path);
+                const patchOperator = simplePatch(value);
+                setStateFromOperator(root, currentAppState, patchOperator, path, injector);
             },
-            setState(val) {
+            setState(value) {
+                // Same guard as patchState — no-op if the injector is already destroyed.
+                if (injector.destroyed) {
+                    errorHandler?.handleError(new StateContextDestroyedError(path));
+                    return;
+                }
                 const currentAppState = root.getState();
-                if (isStateOperator(val)) {
-                    setStateFromOperator(root, currentAppState, val, path);
+                if (isStateOperator(value)) {
+                    setStateFromOperator(root, currentAppState, value, path, injector);
                 }
                 else {
-                    setStateValue(root, currentAppState, val, path);
+                    setStateValue(root, currentAppState, value, path, injector);
                 }
             },
             dispatch(actions) {
@@ -1087,32 +1141,58 @@ class StateContextFactory {
             }
         };
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: StateContextFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: StateContextFactory, providedIn: 'root' });
+    /** @internal */
+    setErrorHandler() {
+        // Called from `LifecycleStateManager.ngxsBootstrap` rather than at
+        // construction time. If we injected ErrorHandler in the constructor,
+        // an ErrorHandler that itself injects Store would create a circular
+        // dependency — deferring the lookup breaks the cycle.
+        this._errorHandler ??= this._injector.get(ErrorHandler);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: StateContextFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: StateContextFactory, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: StateContextFactory, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: StateContextFactory, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
-function setStateValue(root, currentAppState, newValue, path) {
+function setStateValue(root, currentAppState, newValue, path, injector) {
+    if (typeof ngDevMode !== 'undefined' && ngDevMode) {
+        warnIfNewReferenceHasIdenticalValue(injector, getState(currentAppState, path), newValue, path);
+    }
     const newAppState = setValue(currentAppState, path, newValue);
     root.setState(newAppState);
+    // Note: this returns the full app state rather than just the patched slice.
+    // That's a long-standing quirk (present since the original state-factory.ts)
+    // and fixing it would be a breaking change — tracked for a future release.
     return newAppState;
-    // In doing this refactoring I noticed that there is a 'bug' where the
-    // application state is returned instead of this state slice.
-    // This has worked this way since the beginning see:
-    // https://github.com/ngxs/store/blame/324c667b4b7debd8eb979006c67ca0ae347d88cd/src/state-factory.ts
-    // This needs to be fixed, but is a 'breaking' change.
-    // I will do this fix in a subsequent PR and we can decide how to handle it.
-}
-function setStateFromOperator(root, currentAppState, stateOperator, path) {
+}
+function setStateFromOperator(root, currentAppState, stateOperator, path, injector) {
     const local = getState(currentAppState, path);
     const newValue = stateOperator(local);
-    return setStateValue(root, currentAppState, newValue, path);
+    return setStateValue(root, currentAppState, newValue, path, injector);
 }
 function getState(currentAppState, path) {
     return getValue(currentAppState, path);
 }
+// Mirrors `warnOnNewReferenceWithIdenticalValue` in `Store#selectSignal`, but catches the
+// producer side: an action handler that sets a new reference with an identical value causes
+// unnecessary re-emissions for every `select()`/`selectSignal()` subscriber on this slice.
+function warnIfNewReferenceHasIdenticalValue(injector, oldValue, newValue, path) {
+    if (Object.is(oldValue, newValue) || injector.destroyed)
+        return;
+    const warnOption = injector.get(_NGXS_DEVELOPMENT_OPTIONS, null)?.warnOnNewReferenceWithIdenticalValue;
+    if (!warnOption)
+        return;
+    try {
+        if (warnOption.isEqual(oldValue, newValue)) {
+            console.error(`A new reference with an identical value was set on the "${path}" state slice. This will cause unnecessary re-emissions for subscribers relying on reference-based equality.`);
+        }
+    }
+    catch {
+        // Swallow silently.
+    }
+}
 
 class InternalActionHandlerFactory {
     _actions = inject(InternalActions);
@@ -1182,10 +1262,10 @@ class InternalActionHandlerFactory {
             return result;
         };
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: InternalActionHandlerFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: InternalActionHandlerFactory, providedIn: 'root' });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: InternalActionHandlerFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: InternalActionHandlerFactory, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: InternalActionHandlerFactory, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: InternalActionHandlerFactory, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -1229,8 +1309,8 @@ class StateFactory {
     _actionsSubscription = null;
     _ngxsUnhandledErrorHandler = null;
     _states = [];
-    _statesByName = {};
-    _statePaths = {};
+    _statesByName = Object.create(null);
+    _statePaths = Object.create(null);
     getRuntimeSelectorContext = _memoize(() => {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const stateFactory = this;
@@ -1326,20 +1406,51 @@ class StateFactory {
     }
     connectActionHandlers() {
         this._actionsSubscription = this._actions
-            .pipe(filter((ctx) => ctx.status === ActionStatus.Dispatched), mergeMap(ctx => {
+            .pipe(mergeMap(ctx => {
+            if (ctx.status !== ActionStatus.Dispatched) {
+                return EMPTY;
+            }
             const action = ctx.action;
-            return this.invokeActions(action).pipe(map(() => ({ action, status: ActionStatus.Successful })), defaultIfEmpty({ action, status: ActionStatus.Canceled }), catchError(error => {
-                const ngxsUnhandledErrorHandler = (this._ngxsUnhandledErrorHandler ||=
-                    this._injector.get(NgxsUnhandledErrorHandler));
-                const handleableError = assignUnhandledCallback(error, () => ngxsUnhandledErrorHandler.handleError(error, { action }));
-                return of({
-                    action,
-                    status: ActionStatus.Errored,
-                    error: handleableError
-                });
+            return new Observable(subscriber => this.invokeActions(action).subscribe({
+                next: () => {
+                    subscriber.next({ action, status: ActionStatus.Successful });
+                    subscriber.complete();
+                },
+                error: error => {
+                    const ngxsUnhandledErrorHandler = (this._ngxsUnhandledErrorHandler ||=
+                        this._injector.get(NgxsUnhandledErrorHandler));
+                    function callback() {
+                        ngxsUnhandledErrorHandler.handleError(error, { action });
+                    }
+                    // An arrow function here would share the `[[Context]]` of the enclosing `error =>`
+                    // arrow function, which captures `this` (StateFactory), causing the error object to
+                    // retain the entire instance. A named function declaration creates its own context and
+                    // V8 only captures variables it actually references — `ngxsUnhandledErrorHandler`,
+                    // `error`, `action` — so `this` is never captured. `.bind(null)` goes one step further:
+                    // a JSBoundFunction has no `[[Context]]` slot at all, fully severing the retention chain.
+                    // This matters because the callback is stored as a value in the
+                    // `ɵɵunhandledRxjsErrorCallbacks` WeakMap, keyed by the error object. The error may be
+                    // held by third-party code (e.g. error trackers, logging) for an indeterminate duration,
+                    // and we have no control over when that key is released.
+                    const handleableError = assignUnhandledCallback(error, callback.bind(null));
+                    subscriber.next({
+                        action,
+                        status: ActionStatus.Errored,
+                        error: handleableError
+                    });
+                    subscriber.complete();
+                },
+                complete: () => {
+                    if (subscriber.closed)
+                        return;
+                    subscriber.next({ action, status: ActionStatus.Canceled });
+                    subscriber.complete();
+                }
             }));
         }))
-            .subscribe(ctx => this._actionResults.next(ctx));
+            .subscribe(ctx => {
+            this._actionResults.next(ctx);
+        });
     }
     /**
      * Invoke actions on the states.
@@ -1373,10 +1484,7 @@ class StateFactory {
             // didn't return `null` so we may ensure the module has been imported.
             unhandledActionsLogger?.warn(action);
         }
-        if (!results.length) {
-            results.push(of(undefined));
-        }
-        return forkJoin(results);
+        return results.length > 0 ? forkJoin(results) : of(undefined);
     }
     addToStatesMap(stateClasses) {
         const newStates = [];
@@ -1409,24 +1517,23 @@ class StateFactory {
     }
     hydrateActionMetasMap({ path, actions, instance }) {
         for (const actionType of Object.keys(actions)) {
-            const actionHandlers = actions[actionType].map(actionMeta => {
+            for (const actionMeta of actions[actionType]) {
                 const handlerFn = (ctx, action) => instance[actionMeta.fn](ctx, action);
-                return this._actionHandlerFactory.createActionHandler(path, handlerFn, actionMeta.options);
-            });
-            for (const actionHandler of actionHandlers) {
-                this._actionRegistry.register(actionType, actionHandler);
+                const actionHandler = this._actionHandlerFactory.createActionHandler(path, handlerFn, actionMeta.options);
+                this._actionRegistry.register(actionType, actionHandler, actionMeta.actionClass);
             }
         }
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: StateFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: StateFactory, providedIn: 'root' });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: StateFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: StateFactory, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: StateFactory, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: StateFactory, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
 
 class Store {
+    _injector;
     _stateStream = inject(_StateStream);
     _internalStateOperations = inject(InternalStateOperations);
     _config = inject(NgxsConfig);
@@ -1440,6 +1547,9 @@ class Store {
     _selectableStateStream = this._stateStream.pipe(leaveNgxs(this._internalExecutionStrategy), shareReplay({ bufferSize: 1, refCount: true }));
     constructor() {
         this.initStateStream();
+        if (typeof ngDevMode !== 'undefined' && ngDevMode) {
+            this._injector = inject(Injector);
+        }
     }
     /**
      * Dispatches action(s).
@@ -1491,6 +1601,21 @@ class Store {
         const selectorFn = this.getStoreBoundSelectorFn(selector);
         if (typeof ngDevMode !== 'undefined' && ngDevMode) {
             return computed(() => selectorFn(this._stateStream.state()), {
+                equal: (a, b) => {
+                    const warnOption = this._injector?.get(_NGXS_DEVELOPMENT_OPTIONS, null)?.warnOnNewReferenceWithIdenticalValue;
+                    if (warnOption && !Object.is(a, b)) {
+                        try {
+                            const originalFn = selector.originalFn;
+                            if (warnOption.isEqual(a, b) && originalFn) {
+                                console.error('The selector returned the same value shape as it was before triggering signal recomputation. Selector function: ', originalFn);
+                            }
+                        }
+                        catch {
+                            // Swallow silently.
+                        }
+                    }
+                    return a === b;
+                },
                 debugName: 'NGXS selectSignal'
             });
         }
@@ -1532,10 +1657,10 @@ class Store {
             this._stateStream.next(initialStateValue);
         }
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: Store, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: Store, providedIn: 'root' });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: Store, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: Store, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: Store, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: Store, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
@@ -1570,6 +1695,125 @@ function withNgxsPreboot(prebootFn) {
     ]);
 }
 
+/**
+ * This function registers a custom global plugin for the state.
+ *
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideStore(
+ *       [CountriesState],
+ *       withNgxsPlugin(LogoutPlugin)
+ *     )
+ *   ]
+ * });
+ * ```
+ */
+function withNgxsPlugin(plugin) {
+    return makeEnvironmentProviders([
+        _isPluginClass(plugin)
+            ? { provide: NGXS_PLUGINS, useClass: plugin, multi: true }
+            : { provide: NGXS_PLUGINS, useValue: plugin, multi: true },
+        // We should inject the `PluginManager` to retrieve `NGXS_PLUGINS` and
+        // register those plugins. The plugin can be added from inside the child
+        // route, so the plugin manager should be re-injected.
+        provideEnvironmentInitializer(() => inject(PluginManager))
+    ]);
+}
+
+const REGISTERED_PLUGINS = /* @__PURE__ */ new InjectionToken('', {
+    factory: () => {
+        const plugins = new Set();
+        inject(DestroyRef).onDestroy(() => plugins.clear());
+        return plugins;
+    }
+});
+/**
+ * Dynamically registers an NGXS plugin in the current injection context.
+ *
+ * This function allows you to register NGXS plugins at runtime, creating an isolated
+ * environment injector for the plugin. The plugin is automatically cleaned up when
+ * the injection context is destroyed. In development mode, the function validates
+ * that the same plugin is not registered multiple times.
+ *
+ * @param plugin - The NGXS plugin to register. Can be either a class type implementing
+ *                 `NgxsPlugin` or a plugin function (`NgxsPluginFn`).
+ *
+ * @throws {Error} Throws an error if called outside of an injection context.
+ * @throws {Error} In development mode, throws an error if the plugin has already been registered.
+ *
+ * @remarks
+ * - Must be called within an injection context (e.g., constructor, field initializer, or `runInInjectionContext`).
+ * - The created environment injector is automatically destroyed when the parent context is destroyed.
+ * - Duplicate plugin registration is only checked in development mode for performance reasons.
+ *
+ * @example
+ * ```ts
+ * // Register a plugin class
+ * import { MyThirdPartyIntegrationPlugin } from './plugins/third-party.plugin';
+ *
+ * @Component({
+ *   selector: 'app-root',
+ *   template: '...'
+ * })
+ * export class AppComponent {
+ *   constructor() {
+ *     registerNgxsPlugin(MyThirdPartyIntegrationPlugin);
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Register a plugin function
+ * import { myThirdPartyIntegrationPluginFn } from './plugins/third-party.plugin';
+ *
+ * @Component({
+ *   selector: 'app-feature',
+ *   template: '...'
+ * })
+ * export class FeatureComponent {
+ *   constructor() {
+ *     registerNgxsPlugin(myThirdPartyIntegrationPluginFn);
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Register conditionally based on environment
+ * import { MyDevtoolsPlugin } from './plugins/devtools.plugin';
+ *
+ * @Component({
+ *   selector: 'app-root',
+ *   template: '...'
+ * })
+ * export class AppComponent {
+ *   constructor() {
+ *     if (ngDevMode) {
+ *       registerNgxsPlugin(MyDevtoolsPlugin);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+function registerNgxsPlugin(plugin) {
+    ngDevMode && assertInInjectionContext(registerNgxsPlugin);
+    if (typeof ngDevMode !== 'undefined' && ngDevMode) {
+        const registeredPlugins = inject(REGISTERED_PLUGINS);
+        if (registeredPlugins.has(plugin)) {
+            throw new Error('Plugin has already been registered. Each plugin should only be registered once to avoid unexpected behavior.');
+        }
+        registeredPlugins.add(plugin);
+    }
+    // Create a new environment injector with the plugin configuration.
+    // This isolates the plugin's dependencies and providers.
+    const injector = createEnvironmentInjector([PluginManager, withNgxsPlugin(plugin)], inject(EnvironmentInjector));
+    // Ensure the created injector is destroyed when the injection context is destroyed.
+    // This prevents memory leaks and ensures proper cleanup.
+    inject(DestroyRef).onDestroy(() => injector.destroy());
+}
+
 const ROOT_STORE_GUARD = /* @__PURE__ */ new InjectionToken('ROOT_STORE_GUARD', {
     providedIn: 'root',
     factory: () => ({ initialized: false })
@@ -1597,25 +1841,28 @@ class SelectFactory {
             SelectFactory.config = null;
         });
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: SelectFactory, deps: [{ token: Store }, { token: NgxsConfig }], target: i0.ɵɵFactoryTarget.Injectable });
-    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: SelectFactory, providedIn: 'root' });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: SelectFactory, deps: [{ token: Store }, { token: NgxsConfig }], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: SelectFactory, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: SelectFactory, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: SelectFactory, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: Store }, { type: NgxsConfig }] });
 
 class LifecycleStateManager {
+    _destroyRef = inject(DestroyRef);
+    _injector = inject(Injector);
     _store = inject(Store);
     _internalStateOperations = inject(InternalStateOperations);
     _stateContextFactory = inject(StateContextFactory);
-    _appBootstrappedState = inject(_NgxsAppBootstrappedState);
+    _appBootstrapState = inject(_NGXS_APP_BOOTSTRAP_STATE);
     _abortController = new AbortController();
     _initStateHasBeenDispatched;
     constructor() {
         inject(DestroyRef).onDestroy(() => this._abortController.abort());
     }
     ngxsBootstrap(action, results) {
+        this._stateContextFactory.setErrorHandler();
         if (typeof ngDevMode !== 'undefined' && ngDevMode) {
             if (action instanceof InitState) {
                 this._initStateHasBeenDispatched = true;
@@ -1633,22 +1880,22 @@ class LifecycleStateManager {
         }
         // It does not need to unsubscribe because it is completed when the
         // root injector is destroyed.
-        this._internalStateOperations
-            .getRootStateOperations()
-            .dispatch(action)
-            .pipe(mergeMap(() => {
+        const rootStateOperations = this._internalStateOperations.getRootStateOperations();
+        rootStateOperations.dispatch(action).subscribe(() => {
             // If no states are provided, we safely complete the stream
             // and do not proceed further.
             if (!results) {
-                return EMPTY;
+                return;
             }
             this._invokeInitOnStates(results.states);
-            return this._appBootstrappedState;
-        }))
-            .subscribe(appBootstrapped => {
-            if (appBootstrapped) {
+            const options = { injector: this._injector };
+            toObservable(this._appBootstrapState, options)
+                .pipe(takeUntilDestroyed(this._destroyRef))
+                .subscribe(appBootstrapped => {
+                if (!appBootstrapped)
+                    return;
                 this._invokeBootstrapOnStates(results.states);
-            }
+            });
         });
     }
     _invokeInitOnStates(mappedStores) {
@@ -1662,11 +1909,6 @@ class LifecycleStateManager {
                 // root injector is destroyed.
                 this._store
                     .select(state => getValue(state, mappedStore.path))
-                    .pipe(
-                // Ensure initial state is captured
-                startWith(undefined), 
-                // `skip` is using `filter` internally.
-                skip(1))
                     .subscribe(currentValue => {
                     const change = new NgxsSimpleChange(previousValue, currentValue, !mappedStore.isInitialised);
                     previousValue = currentValue;
@@ -1686,10 +1928,10 @@ class LifecycleStateManager {
     _getStateContext(mappedStore) {
         return this._stateContextFactory.createStateContext(mappedStore.path, this._abortController.signal);
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: LifecycleStateManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: LifecycleStateManager, providedIn: 'root' });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: LifecycleStateManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: LifecycleStateManager, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: LifecycleStateManager, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: LifecycleStateManager, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
@@ -1776,11 +2018,11 @@ class NgxsRootModule {
     constructor() {
         rootStoreInitializer();
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsRootModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    /** @nocollapse */ static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.2", ngImport: i0, type: NgxsRootModule });
-    /** @nocollapse */ static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsRootModule });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsRootModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    /** @nocollapse */ static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.25", ngImport: i0, type: NgxsRootModule });
+    /** @nocollapse */ static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsRootModule });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsRootModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsRootModule, decorators: [{
             type: NgModule
         }], ctorParameters: () => [] });
 
@@ -1791,11 +2033,11 @@ class NgxsFeatureModule {
     constructor() {
         featureStatesInitializer();
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsFeatureModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    /** @nocollapse */ static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.2", ngImport: i0, type: NgxsFeatureModule });
-    /** @nocollapse */ static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsFeatureModule });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsFeatureModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    /** @nocollapse */ static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.25", ngImport: i0, type: NgxsFeatureModule });
+    /** @nocollapse */ static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsFeatureModule });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsFeatureModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsFeatureModule, decorators: [{
             type: NgModule
         }], ctorParameters: () => [] });
 
@@ -1813,8 +2055,8 @@ function getRootProviders(states, options) {
         {
             provide: APP_BOOTSTRAP_LISTENER,
             useFactory: () => {
-                const appBootstrappedState = inject(_NgxsAppBootstrappedState);
-                return () => appBootstrappedState.bootstrap();
+                const bootstrapState = inject(_NGXS_APP_BOOTSTRAP_STATE);
+                return () => bootstrapState.set(true);
             },
             multi: true
         },
@@ -1841,24 +2083,33 @@ function getFeatureProviders(states) {
     ];
 }
 
+/**
+ * @deprecated Use `provideStore()` and `provideStates()` instead.
+ */
 class NgxsModule {
+    /**
+     * @deprecated Use `provideStore()` instead.
+     */
     static forRoot(states = [], options = {}) {
         return {
             ngModule: NgxsRootModule,
             providers: getRootProviders(states, options)
         };
     }
+    /**
+     * @deprecated Use `provideStates()` instead.
+     */
     static forFeature(states = []) {
         return {
             ngModule: NgxsFeatureModule,
             providers: getFeatureProviders(states)
         };
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    /** @nocollapse */ static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.2", ngImport: i0, type: NgxsModule });
-    /** @nocollapse */ static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsModule });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    /** @nocollapse */ static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.25", ngImport: i0, type: NgxsModule });
+    /** @nocollapse */ static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsModule });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsModule, decorators: [{
             type: NgModule
         }] });
 
@@ -1885,7 +2136,8 @@ function Action(actions, options) {
             meta.actions[type].push({
                 fn: name,
                 options: options || {},
-                type
+                type,
+                actionClass: action
             });
         }
     };
@@ -2049,6 +2301,12 @@ function SelectorOptions(options) {
     });
 }
 
+/**
+ * Function for creating a selector
+ * @param selectors The selectors to use to create the arguments of this function
+ * @param originalFn The original function being made into a selector
+ * @param creationMetadata
+ */
 function createSelector(selectors, projector, creationMetadata) {
     const memoizedFn = createMemoizedSelectorFn(projector, creationMetadata);
     const selectorMetaData = setupSelectorMetadata(projector, creationMetadata);
@@ -2065,7 +2323,7 @@ function Selector(selectors) {
                 throwSelectorDecoratorError();
             }
         }
-        const memoizedFn = createSelector(selectors, originalFn, {
+        const memoizedFn = createSelector(selectors || [], originalFn, {
             containerClass: target,
             selectorName: key.toString(),
             getSelectorOptions() {
@@ -2088,38 +2346,44 @@ class ActionDirector {
     _actionHandlerFactory = inject(InternalActionHandlerFactory);
     attachAction(stateToken, Action, handlerFn, options = {}) {
         const actionHandler = this._actionHandlerFactory.createActionHandler(stateToken.getName(), handlerFn, options);
-        const detach = this._registry.register(Action.type, actionHandler);
+        const detach = this._registry.register(Action.type, actionHandler, Action);
         return { detach };
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: ActionDirector, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: ActionDirector, providedIn: 'root' });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: ActionDirector, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: ActionDirector, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: ActionDirector, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: ActionDirector, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
 
+/**
+ * @deprecated Use `withNgxsDevelopmentOptions()` instead.
+ */
 class NgxsDevelopmentModule {
+    /**
+     * @deprecated Use `withNgxsDevelopmentOptions()` instead.
+     */
     static forRoot(options) {
         return {
             ngModule: NgxsDevelopmentModule,
             providers: [
                 NgxsUnhandledActionsLogger,
-                { provide: NGXS_DEVELOPMENT_OPTIONS, useValue: options }
+                { provide: _NGXS_DEVELOPMENT_OPTIONS, useValue: options }
             ]
         };
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsDevelopmentModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    /** @nocollapse */ static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.2", ngImport: i0, type: NgxsDevelopmentModule });
-    /** @nocollapse */ static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsDevelopmentModule });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsDevelopmentModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    /** @nocollapse */ static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.25", ngImport: i0, type: NgxsDevelopmentModule });
+    /** @nocollapse */ static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsDevelopmentModule });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NgxsDevelopmentModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NgxsDevelopmentModule, decorators: [{
             type: NgModule
         }] });
 function withNgxsDevelopmentOptions(options) {
     return makeEnvironmentProviders([
         NgxsUnhandledActionsLogger,
-        { provide: NGXS_DEVELOPMENT_OPTIONS, useValue: options }
+        { provide: _NGXS_DEVELOPMENT_OPTIONS, useValue: options }
     ]);
 }
 
@@ -2130,10 +2394,10 @@ class NoopNgxsExecutionStrategy {
     leave(func) {
         return func();
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NoopNgxsExecutionStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NoopNgxsExecutionStrategy, providedIn: 'root' });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NoopNgxsExecutionStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NoopNgxsExecutionStrategy, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: NoopNgxsExecutionStrategy, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: NoopNgxsExecutionStrategy, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -2273,9 +2537,13 @@ function createPropertySelectors(parentSelector) {
  */
 function withNgxsPendingTasks() {
     return withNgxsPreboot(() => {
+        // We silently return instead of logging a warning when not in server mode,
+        // as `withNgxsPendingTasks` may legitimately be included in a shared
+        // `provideStore` configuration used by both browser and server apps.
+        // In the browser, data hydrated from the transfer state is consumed
+        // synchronously, so there is no need to contribute to app stability.
         if (typeof ngServerMode === 'undefined' || !ngServerMode) {
-            console.warn('[withNgxsPendingTasks] This setup is recommended for server-side rendering only. ' +
-                'Using it in the browser may lead to redundant change detection cycles and degraded performance.');
+            return;
         }
         const actions$ = inject(Actions);
         const pendingTasks = inject(PendingTasks);
@@ -2376,32 +2644,6 @@ function provideStates(states, ...features) {
     ]);
 }
 
-/**
- * This function registers a custom global plugin for the state.
- *
- * ```ts
- * bootstrapApplication(AppComponent, {
- *   providers: [
- *     provideStore(
- *       [CountriesState],
- *       withNgxsPlugin(LogoutPlugin)
- *     )
- *   ]
- * });
- * ```
- */
-function withNgxsPlugin(plugin) {
-    return makeEnvironmentProviders([
-        _isPluginClass(plugin)
-            ? { provide: NGXS_PLUGINS, useClass: plugin, multi: true }
-            : { provide: NGXS_PLUGINS, useValue: plugin, multi: true },
-        // We should inject the `PluginManager` to retrieve `NGXS_PLUGINS` and
-        // register those plugins. The plugin can be added from inside the child
-        // route, so the plugin manager should be re-injected.
-        provideEnvironmentInitializer(() => inject(PluginManager))
-    ]);
-}
-
 /**
  * This function serves as a utility and has multiple purposes.
  * Firstly, it allows you to select properties from the state class
@@ -2419,9 +2661,39 @@ function select(selector) {
     return inject(Store).selectSignal(selector);
 }
 
+// Extends Observable so callers can subscribe to emission updates (e.g. progress, intermediate states),
+// while implementing PromiseLike so the JS engine treats it as a thenable when `await` is used —
+// without this dual nature, callers would have to choose upfront between async/await and reactive patterns.
+class AsyncReturnType extends Observable {
+    dispatchResult$;
+    constructor(dispatchResult$) {
+        super(subscriber => dispatchResult$.subscribe(subscriber));
+        this.dispatchResult$ = dispatchResult$;
+    }
+    // Called automatically by the JS engine when `await dispatch(...)` is used.
+    // The PromiseLike contract requires full generics on TResult1/TResult2 to support
+    // promise chaining (e.g. `await dispatch(...).then(x => transform(x))`).
+    then(onfulfilled, onrejected) {
+        return new Promise((resolve, reject) => {
+            this.dispatchResult$.subscribe({
+                // Propagate observable errors into the promise rejection path so
+                // `try/catch` around `await dispatch(...)` works as expected.
+                error: reject,
+                // Resolve on complete rather than on next emission — dispatch returns void,
+                // so the caller cares about the action finishing, not any intermediate values.
+                complete: resolve
+            });
+        }).then(
+        // Bridge void → undefined because PromiseLike<void> resolves with no value,
+        // but `onfulfilled` still needs to be invoked to continue the chain correctly.
+        onfulfilled ? () => onfulfilled(undefined) : undefined, 
+        // Normalize null to undefined since Promise.then doesn't accept null for rejection handler.
+        onrejected ?? undefined);
+    }
+}
 function dispatch(ActionType) {
     const store = inject(Store);
-    return (...args) => store.dispatch(new ActionType(...args));
+    return (...args) => new AsyncReturnType(store.dispatch(new ActionType(...args)));
 }
 
 function createSelectMap(selectorMap) {
@@ -2515,6 +2787,19 @@ function ɵprovideNgxsInternalStateTokens() {
         }
     ]);
 }
+// For internal third-party usage only.
+// Provides a type-safe accessor for `StateFactory`'s private fields so that
+// third-party consumers do not have to cast or use bracket notation themselves.
+function ɵgetTypedNgxsStateFactory(stateFactory) {
+    return {
+        // The flat list of all registered mapped stores.
+        states: stateFactory['_states'],
+        // A name-keyed map of all registered states.
+        statesByName: stateFactory['_statesByName'],
+        // A map of dot-separated state paths (e.g. "parent.child") to each state's name.
+        statePaths: stateFactory['_statePaths']
+    };
+}
 
 /**
  * The public api for consumers of @ngxs/store
@@ -2524,5 +2809,5 @@ function ɵprovideNgxsInternalStateTokens() {
  * Generated bundle index. Do not edit.
  */
 
-export { Action, ActionDirector, ActionStatus, Actions, NgxsConfig, NgxsDevelopmentModule, NgxsModule, NgxsSimpleChange, NgxsUnhandledActionsLogger, NgxsUnhandledErrorHandler, Select, Selector, SelectorOptions, State, Store, createDispatchMap, createModelSelector, createPickSelector, createPropertySelectors, createSelectMap, createSelector, dispatch, lazyProvider, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, provideStates, provideStore, select, withNgxsDevelopmentOptions, withNgxsNoopExecutionStrategy, withNgxsPendingTasks, withNgxsPlugin, withNgxsPreboot, NgxsFeatureModule as ɵNgxsFeatureModule, NgxsRootModule as ɵNgxsRootModule, ɵprovideNgxsInternalStateTokens };
+export { Action, ActionDirector, ActionStatus, Actions, AsyncReturnType, NgxsConfig, NgxsDevelopmentModule, NgxsModule, NgxsSimpleChange, NgxsUnhandledActionsLogger, NgxsUnhandledErrorHandler, Select, Selector, SelectorOptions, State, StateContextDestroyedError, Store, createDispatchMap, createModelSelector, createPickSelector, createPropertySelectors, createSelectMap, createSelector, dispatch, lazyProvider, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, provideStates, provideStore, registerNgxsPlugin, select, withNgxsDevelopmentOptions, withNgxsNoopExecutionStrategy, withNgxsPendingTasks, withNgxsPlugin, withNgxsPreboot, NgxsFeatureModule as ɵNgxsFeatureModule, NgxsRootModule as ɵNgxsRootModule, ɵgetTypedNgxsStateFactory, ɵprovideNgxsInternalStateTokens };
 //# sourceMappingURL=ngxs-store.mjs.map