@ngxs/store 19.0.0 → 20.0.0-dev.master-0db0003

package/fesm2022/ngxs-store.mjs

@@ -1,241 +1,22 @@
 import * as i0 from '@angular/core';
-import { Injectable, inject, NgZone, PLATFORM_ID, InjectionToken, INJECTOR, Injector, runInInjectionContext, ErrorHandler, ɵisPromise as _isPromise, computed, makeEnvironmentProviders, ENVIRONMENT_INITIALIZER, NgModule, APP_BOOTSTRAP_LISTENER, PendingTasks } from '@angular/core';
-import { Subject, filter, Observable, share, config, of, forkJoin, throwError, mergeMap as mergeMap$1, map as map$1, defaultIfEmpty, catchError, from, isObservable, takeUntil, finalize, shareReplay as shareReplay$1, distinctUntilChanged, take as take$1, ReplaySubject } from 'rxjs';
-import { ɵwrapObserverCalls as _wrapObserverCalls, ɵOrderedSubject as _OrderedSubject, ɵStateStream as _StateStream, ɵmemoize as _memoize, ɵgetStoreMetadata as _getStoreMetadata, ɵgetSelectorMetadata as _getSelectorMetadata, ɵMETA_KEY as _META_KEY, ɵINITIAL_STATE_TOKEN as _INITIAL_STATE_TOKEN, ɵ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, ɵisPromise as _isPromise, computed, makeEnvironmentProviders, provideEnvironmentInitializer, NgModule, APP_BOOTSTRAP_LISTENER, ApplicationRef, PendingTasks, 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';
 export { StateToken } from '@ngxs/store/internals';
-import { isPlatformServer } from '@angular/common';
-import { map, shareReplay, filter as filter$1, take, mergeMap, tap, takeUntil as takeUntil$1, startWith, pairwise } from 'rxjs/operators';
 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';
 
-class NoopNgxsExecutionStrategy {
-    enter(func) {
-        return func();
-    }
-    leave(func) {
-        return func();
-    }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NoopNgxsExecutionStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NoopNgxsExecutionStrategy, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NoopNgxsExecutionStrategy, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-function throwStateNameError(name) {
-    throw new Error(`${name} is not a valid state name. It needs to be a valid object property name.`);
-}
-function throwStateNamePropertyError() {
-    throw new Error(`States must register a 'name' property.`);
-}
-function throwStateUniqueError(current, newName, oldName) {
-    throw new Error(`State name '${current}' from ${newName} already exists in ${oldName}.`);
-}
-function throwStateDecoratorError(name) {
-    throw new Error(`States must be decorated with @State() decorator, but "${name}" isn't.`);
-}
-function throwActionDecoratorError() {
-    throw new Error('@Action() decorator cannot be used with static methods.');
-}
-function throwSelectorDecoratorError() {
-    throw new Error('Selectors only work on methods.');
-}
-function getZoneWarningMessage() {
-    return ('Your application was bootstrapped with nooped zone and your execution strategy requires an actual NgZone!\n' +
-        'Please set the value of the executionStrategy property to NoopNgxsExecutionStrategy.\n' +
-        'NgxsModule.forRoot(states, { executionStrategy: NoopNgxsExecutionStrategy })');
-}
-function getUndecoratedStateWithInjectableWarningMessage(name) {
-    return `'${name}' class should be decorated with @Injectable() right after the @State() decorator`;
-}
-function getInvalidInitializationOrderMessage(addedStates) {
-    let message = 'You have an invalid state initialization order. This typically occurs when `NgxsModule.forFeature`\n' +
-        'or `provideStates` is called before `NgxsModule.forRoot` or `provideStore`.\n' +
-        'One example is when `NgxsRouterPluginModule.forRoot` is called before `NgxsModule.forRoot`.';
-    if (addedStates) {
-        const stateNames = Object.keys(addedStates).map(stateName => `"${stateName}"`);
-        message +=
-            '\nFeature states added before the store initialization is complete: ' +
-                `${stateNames.join(', ')}.`;
-    }
-    return message;
-}
-function throwSelectFactoryNotConnectedError() {
-    throw new Error('You have forgotten to import the NGXS module!');
-}
-function throwPatchingArrayError() {
-    throw new Error('Patching arrays is not supported.');
-}
-function throwPatchingPrimitiveError() {
-    throw new Error('Patching primitives is not supported.');
-}
-
-class DispatchOutsideZoneNgxsExecutionStrategy {
-    constructor() {
-        this._ngZone = inject(NgZone);
-        this._isServer = isPlatformServer(inject(PLATFORM_ID));
-        if (typeof ngDevMode !== 'undefined' && ngDevMode) {
-            verifyZoneIsNotNooped(this._ngZone);
-        }
-    }
-    enter(func) {
-        if (this._isServer) {
-            return this.runInsideAngular(func);
-        }
-        return this.runOutsideAngular(func);
-    }
-    leave(func) {
-        return this.runInsideAngular(func);
-    }
-    runInsideAngular(func) {
-        if (NgZone.isInAngularZone()) {
-            return func();
-        }
-        return this._ngZone.run(func);
-    }
-    runOutsideAngular(func) {
-        if (NgZone.isInAngularZone()) {
-            return this._ngZone.runOutsideAngular(func);
-        }
-        return func();
-    }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: DispatchOutsideZoneNgxsExecutionStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: DispatchOutsideZoneNgxsExecutionStrategy, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: DispatchOutsideZoneNgxsExecutionStrategy, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [] });
-// Caretaker note: this should exist as a separate function and not a class method,
-// since class methods are not tree-shakable.
-function verifyZoneIsNotNooped(ngZone) {
-    // `NoopNgZone` is not exposed publicly as it doesn't expect
-    // to be used outside of the core Angular code, thus we just have
-    // to check if the zone doesn't extend or instanceof `NgZone`.
-    if (ngZone instanceof NgZone) {
-        return;
-    }
-    console.warn(getZoneWarningMessage());
-}
-
-/**
- * Consumers have the option to utilize the execution strategy provided by
- * `NgxsModule.forRoot({executionStrategy})` or `provideStore([], {executionStrategy})`.
- */
-const CUSTOM_NGXS_EXECUTION_STRATEGY = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'CUSTOM_NGXS_EXECUTION_STRATEGY' : '');
-/**
- * The injection token is used internally to resolve an instance of the execution
- * strategy. It checks whether consumers have provided their own `executionStrategy`
- * and also verifies if we are operating in a zone-aware environment.
- */
-const NGXS_EXECUTION_STRATEGY = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'NGXS_EXECUTION_STRATEGY' : '', {
-    providedIn: 'root',
-    factory: () => {
-        const ngZone = inject(NgZone);
-        const injector = inject(INJECTOR);
-        const executionStrategy = injector.get(CUSTOM_NGXS_EXECUTION_STRATEGY);
-        const isNgZoneEnabled = ngZone instanceof NgZone;
-        return executionStrategy
-            ? injector.get(executionStrategy)
-            : injector.get(isNgZoneEnabled
-                ? DispatchOutsideZoneNgxsExecutionStrategy
-                : NoopNgxsExecutionStrategy);
-    }
-});
-
-class InternalNgxsExecutionStrategy {
-    constructor() {
-        this._executionStrategy = inject(NGXS_EXECUTION_STRATEGY);
-    }
-    enter(func) {
-        return this._executionStrategy.enter(func);
-    }
-    leave(func) {
-        return this._executionStrategy.leave(func);
-    }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: InternalNgxsExecutionStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: InternalNgxsExecutionStrategy, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: InternalNgxsExecutionStrategy, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-/**
- * Returns operator that will run
- * `subscribe` outside of the ngxs execution context
- */
-function leaveNgxs(ngxsExecutionStrategy) {
-    return _wrapObserverCalls(fn => ngxsExecutionStrategy.leave(fn));
-}
-
-/**
- * Internal Action stream that is emitted anytime an action is dispatched.
- */
-class InternalActions extends _OrderedSubject {
-    constructor() {
-        super();
-        // This subject will be the first to know about the dispatched action, its purpose is for
-        // any logic that must be executed before action handlers are invoked (i.e., cancelation).
-        this.dispatched$ = new Subject();
-        this.pipe(filter(ctx => ctx.status === "DISPATCHED" /* ActionStatus.Dispatched */)).subscribe(ctx => {
-            this.dispatched$.next(ctx);
-        });
-    }
-    ngOnDestroy() {
-        this.complete();
-    }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: InternalActions, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: InternalActions, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: InternalActions, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [] });
-/**
- * Action stream that is emitted anytime an action is dispatched.
- *
- * You can listen to this in services to react without stores.
- */
-class Actions extends Observable {
-    constructor() {
-        const internalActions$ = inject(InternalActions);
-        const internalExecutionStrategy = inject(InternalNgxsExecutionStrategy);
-        const sharedInternalActions$ = internalActions$.pipe(leaveNgxs(internalExecutionStrategy), 
-        // The `InternalActions` subject emits outside of the Angular zone.
-        // We have to re-enter the Angular zone for any incoming consumer.
-        // The `share()` operator reduces the number of change detections.
-        // This would call leave only once for any stream emission across all active subscribers.
-        share());
-        super(observer => {
-            const childSubscription = sharedInternalActions$.subscribe({
-                next: ctx => observer.next(ctx),
-                error: error => observer.error(error),
-                complete: () => observer.complete()
-            });
-            observer.add(childSubscription);
-        });
-    }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: Actions, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: Actions, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: Actions, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [] });
-
 class PluginManager {
+    plugins = [];
+    _parentManager = inject(PluginManager, {
+        optional: true,
+        skipSelf: true
+    });
+    _pluginHandlers = inject(NGXS_PLUGINS, {
+        optional: true
+    });
     constructor() {
-        this.plugins = [];
-        this._parentManager = inject(PluginManager, {
-            optional: true,
-            skipSelf: true
-        });
-        this._pluginHandlers = inject(NGXS_PLUGINS, {
-            optional: true
-        });
         this.registerHandlers();
     }
     get _rootPlugins() {
@@ -249,14 +30,22 @@ class PluginManager {
         const handlers = this._pluginHandlers || [];
         return handlers.map((plugin) => (plugin.handle ? plugin.handle.bind(plugin) : plugin));
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: PluginManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: PluginManager, providedIn: 'root' }); }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: PluginManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: PluginManager, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: PluginManager, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: PluginManager, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
 
+/**
+ * Returns operator that will run
+ * `subscribe` outside of the ngxs execution context
+ */
+function leaveNgxs(ngxsExecutionStrategy) {
+    return _wrapObserverCalls(fn => ngxsExecutionStrategy.leave(fn));
+}
+
 const ɵɵunhandledRxjsErrorCallbacks = new WeakMap();
 let installed = false;
 function installOnUnhandhedErrorHandler() {
@@ -290,7 +79,7 @@ function assignUnhandledCallback(error, callback) {
     // Since the error can be essentially anything, we must ensure that we only
     // handle objects, as weak maps do not allow any other key type besides objects.
     // The error can also be a string if thrown in the following manner: `throwError('My Error')`.
-    if (error !== null && typeof error === 'object') {
+    if (error && typeof error === 'object') {
         let hasBeenCalled = false;
         ɵɵunhandledRxjsErrorCallbacks.set(error, () => {
             if (!hasBeenCalled) {
@@ -336,23 +125,134 @@ function fallbackSubscriber(ngZone) {
  * The dispatcher then asynchronously pushes the result from this stream onto the main action stream as a result.
  */
 class InternalDispatchedActionResults extends Subject {
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: InternalDispatchedActionResults, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: InternalDispatchedActionResults, providedIn: 'root' }); }
+    constructor() {
+        super();
+        // 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());
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: InternalDispatchedActionResults, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: InternalDispatchedActionResults, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: InternalDispatchedActionResults, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: InternalDispatchedActionResults, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+class InternalNgxsExecutionStrategy {
+    _ngZone = inject(NgZone);
+    enter(func) {
+        if (typeof ngServerMode !== 'undefined' && ngServerMode) {
+            return this._runInsideAngular(func);
+        }
+        return this._runOutsideAngular(func);
+    }
+    leave(func) {
+        return this._runInsideAngular(func);
+    }
+    _runInsideAngular(func) {
+        if (NgZone.isInAngularZone()) {
+            return func();
+        }
+        return this._ngZone.run(func);
+    }
+    _runOutsideAngular(func) {
+        if (NgZone.isInAngularZone()) {
+            return this._ngZone.runOutsideAngular(func);
+        }
+        return func();
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: InternalNgxsExecutionStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: InternalNgxsExecutionStrategy, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: InternalNgxsExecutionStrategy, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
-class InternalDispatcher {
+
+/**
+ * Status of a dispatched action
+ */
+var ActionStatus;
+(function (ActionStatus) {
+    ActionStatus["Dispatched"] = "DISPATCHED";
+    ActionStatus["Successful"] = "SUCCESSFUL";
+    ActionStatus["Canceled"] = "CANCELED";
+    ActionStatus["Errored"] = "ERRORED";
+})(ActionStatus || (ActionStatus = {}));
+/**
+ * Internal Action stream that is emitted anytime an action is dispatched.
+ */
+class InternalActions extends _OrderedSubject {
+    // This subject will be the first to know about the dispatched action, its purpose is for
+    // any logic that must be executed before action handlers are invoked (i.e., cancelation).
+    dispatched$ = new Subject();
+    constructor() {
+        super();
+        this.subscribe(ctx => {
+            if (ctx.status === ActionStatus.Dispatched) {
+                this.dispatched$.next(ctx);
+            }
+        });
+        const destroyRef = inject(DestroyRef);
+        destroyRef.onDestroy(() => {
+            // 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.
+            this.complete();
+            this.dispatched$.complete();
+        });
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: InternalActions, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: InternalActions, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: InternalActions, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+/**
+ * Action stream that is emitted anytime an action is dispatched.
+ *
+ * You can listen to this in services to react without stores.
+ */
+class Actions extends Observable {
     constructor() {
-        this._ngZone = inject(NgZone);
-        this._actions = inject(InternalActions);
-        this._actionResults = inject(InternalDispatchedActionResults);
-        this._pluginManager = inject(PluginManager);
-        this._stateStream = inject(_StateStream);
-        this._ngxsExecutionStrategy = inject(InternalNgxsExecutionStrategy);
-        this._injector = inject(Injector);
+        const internalActions$ = inject(InternalActions);
+        const internalExecutionStrategy = inject(InternalNgxsExecutionStrategy);
+        // The `InternalActions` subject emits outside of the Angular zone.
+        // We have to re-enter the Angular zone for any incoming consumer.
+        // The shared `Subject` reduces the number of change detections.
+        // This would call leave only once for any stream emission across all active subscribers.
+        const sharedInternalActions$ = new Subject();
+        internalActions$
+            .pipe(leaveNgxs(internalExecutionStrategy))
+            .subscribe(sharedInternalActions$);
+        super(observer => {
+            const childSubscription = sharedInternalActions$.subscribe({
+                next: ctx => observer.next(ctx),
+                error: error => observer.error(error),
+                complete: () => observer.complete()
+            });
+            observer.add(childSubscription);
+        });
     }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: Actions, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: Actions, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: Actions, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+class InternalDispatcher {
+    _ngZone = inject(NgZone);
+    _actions = inject(InternalActions);
+    _actionResults = inject(InternalDispatchedActionResults);
+    _pluginManager = inject(PluginManager);
+    _stateStream = inject(_StateStream);
+    _ngxsExecutionStrategy = inject(InternalNgxsExecutionStrategy);
+    _injector = inject(Injector);
     /**
      * Dispatches event(s).
      */
@@ -375,7 +275,7 @@ class InternalDispatcher {
             const type = getActionTypeFromInstance(action);
             if (!type) {
                 const error = new Error(`This action doesn't have a type property: ${action.constructor.name}`);
-                return throwError(() => error);
+                return new Observable(subscriber => subscriber.error(error));
             }
         }
         const prevState = this._stateStream.getValue();
@@ -388,34 +288,34 @@ class InternalDispatcher {
                 }
                 const actionResult$ = this.getActionResultStream(nextAction);
                 actionResult$.subscribe(ctx => this._actions.next(ctx));
-                this._actions.next({ action: nextAction, status: "DISPATCHED" /* ActionStatus.Dispatched */ });
+                this._actions.next({ action: nextAction, status: ActionStatus.Dispatched });
                 return this.createDispatchObservable(actionResult$);
             }
         ])(prevState, action).pipe(shareReplay());
     }
     getActionResultStream(action) {
-        return this._actionResults.pipe(filter$1((ctx) => ctx.action === action && ctx.status !== "DISPATCHED" /* ActionStatus.Dispatched */), take(1), shareReplay());
+        return this._actionResults.pipe(filter((ctx) => ctx.action === action && ctx.status !== ActionStatus.Dispatched), take(1), shareReplay());
     }
     createDispatchObservable(actionResult$) {
         return actionResult$.pipe(mergeMap((ctx) => {
             switch (ctx.status) {
-                case "SUCCESSFUL" /* ActionStatus.Successful */:
+                case ActionStatus.Successful:
                     // The `createDispatchObservable` function should return the
                     // state, as its result is used by plugins.
                     return of(this._stateStream.getValue());
-                case "ERRORED" /* ActionStatus.Errored */:
-                    return throwError(() => ctx.error);
+                case ActionStatus.Errored:
+                    throw ctx.error;
                 default:
                     // Once dispatched or canceled, we complete it immediately because
                     // `dispatch()` should emit (or error, or complete) as soon as it succeeds or fails.
-                    return of();
+                    return EMPTY;
             }
         }), shareReplay());
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: InternalDispatcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: InternalDispatcher, providedIn: 'root' }); }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: InternalDispatcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: InternalDispatcher, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: InternalDispatcher, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: InternalDispatcher, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -458,32 +358,28 @@ const NGXS_OPTIONS = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDe
  * The NGXS config settings.
  */
 class NgxsConfig {
-    constructor() {
-        this.compatibility = {
-            strictContentSecurityPolicy: false
-        };
-        /**
-         * Determines the execution context to perform async operations inside. An implementation can be
-         * provided to override the default behaviour where the async operations are run
-         * outside Angular's zone but all observable behaviours of NGXS are run back inside Angular's zone.
-         * These observable behaviours are from:
-         *   `store.selectSignal(...)`, `store.select(...)`, `actions.subscribe(...)` or `store.dispatch(...).subscribe(...)`
-         * Every `zone.run` causes Angular to run change detection on the whole tree (`app.tick()`) so of your
-         * application doesn't rely on zone.js running change detection then you can switch to the
-         * `NoopNgxsExecutionStrategy` that doesn't interact with zones.
-         * (default: null)
-         */
-        this.executionStrategy = DispatchOutsideZoneNgxsExecutionStrategy;
-        /**
-         * Defining shared selector options
-         */
-        this.selectorOptions = {
-            injectContainerState: false,
-            suppressErrors: false
-        };
-    }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsConfig, providedIn: 'root', useFactory: () => {
+    /**
+     * Run in development mode. This will add additional debugging features:
+     * - Object.freeze on the state and actions to guarantee immutability
+     * (default: false)
+     *
+     * Note: this property will be accounted only in development mode.
+     * It makes sense to use it only during development to ensure there're no state mutations.
+     * When building for production, the `Object.freeze` will be tree-shaken away.
+     */
+    developmentMode;
+    compatibility = {
+        strictContentSecurityPolicy: false
+    };
+    /**
+     * Defining shared selector options
+     */
+    selectorOptions = {
+        injectContainerState: false,
+        suppressErrors: false
+    };
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsConfig, providedIn: 'root', useFactory: () => {
             const defaultConfig = new NgxsConfig();
             const config = inject(NGXS_OPTIONS);
             return {
@@ -494,9 +390,9 @@ class NgxsConfig {
                     ...config.selectorOptions
                 }
             };
-        } }); }
+        } });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsConfig, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsConfig, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -519,6 +415,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImpor
  * Passed as a value in a NgxsSimpleChanges object to the ngxsOnChanges hook.
  */
 class NgxsSimpleChange {
+    previousValue;
+    currentValue;
+    firstChange;
     constructor(previousValue, currentValue, firstChange) {
         this.previousValue = previousValue;
         this.currentValue = currentValue;
@@ -533,9 +432,8 @@ class NgxsSimpleChange {
 const deepFreeze = (o) => {
     Object.freeze(o);
     const oIsFunction = typeof o === 'function';
-    const hasOwnProp = Object.prototype.hasOwnProperty;
     Object.getOwnPropertyNames(o).forEach(function (prop) {
-        if (hasOwnProp.call(o, prop) &&
+        if (_hasOwnProperty(o, prop) &&
             (oIsFunction ? prop !== 'caller' && prop !== 'callee' && prop !== 'arguments' : true) &&
             o[prop] !== null &&
             (typeof o[prop] === 'object' || typeof o[prop] === 'function') &&
@@ -550,11 +448,9 @@ const deepFreeze = (o) => {
  * @ignore
  */
 class InternalStateOperations {
-    constructor() {
-        this._stateStream = inject(_StateStream);
-        this._dispatcher = inject(InternalDispatcher);
-        this._config = inject(NgxsConfig);
-    }
+    _stateStream = inject(_StateStream);
+    _dispatcher = inject(InternalDispatcher);
+    _config = inject(NgxsConfig);
     /**
      * Returns the root state operators.
      */
@@ -580,10 +476,10 @@ class InternalStateOperations {
         // Set the state to the current + new
         stateOperations.setState({ ...currentState, ...results.defaults });
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: InternalStateOperations, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: InternalStateOperations, providedIn: 'root' }); }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: InternalStateOperations, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: InternalStateOperations, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: InternalStateOperations, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: InternalStateOperations, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -635,7 +531,7 @@ function createRootSelectorFactory(selectorMetaData, selectors, memoizedSelector
     };
 }
 function createMemoizedSelectorFn(originalFn, creationMetadata) {
-    const containerClass = creationMetadata && creationMetadata.containerClass;
+    const containerClass = creationMetadata?.containerClass;
     const wrappedFn = function wrappedSelectorFn() {
         // eslint-disable-next-line prefer-rest-params
         const returnValue = originalFn.apply(containerClass, arguments);
@@ -691,7 +587,7 @@ function getSelectorsToApply(selectors = [], selectorOptions, containerClass) {
  */
 function getRootSelectorFactory(selector) {
     const metadata = _getSelectorMetadata(selector) || _getStoreMetadata(selector);
-    return (metadata && metadata.makeRootSelector) || (() => selector);
+    return metadata?.makeRootSelector || (() => selector);
 }
 
 /**
@@ -733,31 +629,6 @@ function fastPropGetter(paths) {
     const fn = new Function('store', 'return ' + expr + ';');
     return fn;
 }
-/**
- * Get a deeply nested value. Example:
- *
- *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
- *
- * @ignore
- *
- * Marked for removal. It's only used within `createSelectorFn`.
- */
-function propGetter(paths, config) {
-    if (config?.compatibility?.strictContentSecurityPolicy) {
-        return compliantPropGetter(paths);
-    }
-    else {
-        return fastPropGetter(paths);
-    }
-}
-// This injection token selects the prop getter implementation once the app is
-// bootstrapped, as the `propGetter` function's behavior determines the implementation
-// each time it's called. It accepts the config as the second argument. We no longer
-// need to check for the `strictContentSecurityPolicy` every time the prop getter
-// implementation is selected. Now, the `propGetter` function is only used within
-// `createSelectorFn`, which, in turn, is solely used by the `Select` decorator.
-// We've been trying to deprecate the `Select` decorator because it's unstable with
-// server-side rendering and micro-frontend applications.
 const ɵPROP_GETTER = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'PROP_GETTER' : '', {
     providedIn: 'root',
     factory: () => inject(NgxsConfig).compatibility?.strictContentSecurityPolicy
@@ -783,17 +654,19 @@ const ɵPROP_GETTER = new InjectionToken(typeof ngDevMode !== 'undefined' && ngD
  * @ignore
  */
 function buildGraph(stateClasses) {
+    // Resolve a state's name from the class reference.
     const findName = (stateClass) => {
-        const meta = stateClasses.find(g => g === stateClass);
+        const meta = stateClasses.find(s => s === stateClass);
         if (typeof ngDevMode !== 'undefined' && ngDevMode && !meta) {
             throw new Error(`Child state not found: ${stateClass}. \r\nYou may have forgotten to add states to module`);
         }
         return meta[_META_KEY].name;
     };
-    return stateClasses.reduce((result, stateClass) => {
-        const { name, children } = stateClass[_META_KEY];
-        result[name] = (children || []).map(findName);
-        return result;
+    // Build the dependency graph.
+    return stateClasses.reduce((graph, stateClass) => {
+        const meta = stateClass[_META_KEY];
+        graph[meta.name] = (meta.children || []).map(findName);
+        return graph;
     }, {});
 }
 /**
@@ -833,23 +706,23 @@ function nameToState(states) {
  *
  * @ignore
  */
-function findFullParentPath(obj, newObj = {}) {
-    const visit = (child, keyToFind) => {
-        for (const key in child) {
-            if (child.hasOwnProperty(key) && child[key].indexOf(keyToFind) >= 0) {
-                const parent = visit(child, key);
-                return parent !== null ? `${parent}.${key}` : key;
+function findFullParentPath(obj, out = {}) {
+    // Recursively find the full dotted parent path for a given key.
+    const find = (graph, target) => {
+        for (const key in graph) {
+            if (graph[key]?.includes(target)) {
+                const parent = find(graph, key);
+                return parent ? `${parent}.${key}` : key;
             }
         }
         return null;
     };
+    // Build full path for each key
     for (const key in obj) {
-        if (obj.hasOwnProperty(key)) {
-            const parent = visit(obj, key);
-            newObj[key] = parent ? `${parent}.${key}` : key;
-        }
+        const parent = find(obj, key);
+        out[key] = parent ? `${parent}.${key}` : key;
     }
-    return newObj;
+    return out;
 }
 /**
  * Given a object graph, it will return the items topologically sorted Example:
@@ -873,62 +746,68 @@ function findFullParentPath(obj, newObj = {}) {
 function topologicalSort(graph) {
     const sorted = [];
     const visited = {};
+    // DFS (Depth-First Search) to visit each node and its dependencies.
     const visit = (name, ancestors = []) => {
-        if (!Array.isArray(ancestors)) {
-            ancestors = [];
-        }
-        ancestors.push(name);
         visited[name] = true;
-        graph[name].forEach((dep) => {
-            if (typeof ngDevMode !== 'undefined' && ngDevMode && ancestors.indexOf(dep) >= 0) {
+        ancestors.push(name);
+        for (const dep of graph[name]) {
+            if (typeof ngDevMode !== 'undefined' && ngDevMode && ancestors.includes(dep)) {
                 throw new Error(`Circular dependency '${dep}' is required by '${name}': ${ancestors.join(' -> ')}`);
             }
-            if (visited[dep]) {
-                return;
-            }
-            visit(dep, ancestors.slice(0));
-        });
-        if (sorted.indexOf(name) < 0) {
-            sorted.push(name);
+            if (!visited[dep])
+                visit(dep, ancestors.slice());
         }
+        // Add to sorted list if not already included.
+        if (!sorted.includes(name))
+            sorted.push(name);
     };
-    Object.keys(graph).forEach(k => visit(k));
+    // Start DFS from each key
+    for (const key in graph)
+        visit(key);
     return sorted.reverse();
 }
 
-class NgxsActionRegistry {
-    constructor() {
-        // Instead of going over the states list every time an action is dispatched,
-        // we are constructing a map of action types to lists of action metadata.
-        // If the `@@Init` action is handled in two different states, the action
-        // metadata list will contain two objects that have the state `instance` and
-        // method names to be used as action handlers (decorated with `@Action(InitState)`).
-        this._actionTypeToHandlersMap = new Map();
-    }
-    ngOnDestroy() {
-        this._actionTypeToHandlersMap.clear();
-    }
-    get(type) {
-        return this._actionTypeToHandlersMap.get(type);
-    }
-    register(type, handler) {
-        const handlers = this._actionTypeToHandlersMap.get(type) ?? new Set();
-        handlers.add(handler);
-        this._actionTypeToHandlersMap.set(type, handlers);
-        return () => {
-            const handlers = this._actionTypeToHandlersMap.get(type);
-            handlers.delete(handler);
-        };
+function throwStateNameError(name) {
+    throw new Error(`${name} is not a valid state name. It needs to be a valid object property name.`);
+}
+function throwStateNamePropertyError() {
+    throw new Error(`States must register a 'name' property.`);
+}
+function throwStateUniqueError(current, newName, oldName) {
+    throw new Error(`State name '${current}' from ${newName} already exists in ${oldName}.`);
+}
+function throwStateDecoratorError(name) {
+    throw new Error(`States must be decorated with @State() decorator, but "${name}" isn't.`);
+}
+function throwActionDecoratorError() {
+    throw new Error('@Action() decorator cannot be used with static methods.');
+}
+function throwSelectorDecoratorError() {
+    throw new Error('Selectors only work on methods.');
+}
+function getUndecoratedStateWithInjectableWarningMessage(name) {
+    return `'${name}' class should be decorated with @Injectable() right after the @State() decorator`;
+}
+function getInvalidInitializationOrderMessage(addedStates) {
+    let message = 'You have an invalid state initialization order. This typically occurs when `NgxsModule.forFeature`\n' +
+        'or `provideStates` is called before `NgxsModule.forRoot` or `provideStore`.\n' +
+        'One example is when `NgxsRouterPluginModule.forRoot` is called before `NgxsModule.forRoot`.';
+    if (addedStates) {
+        const stateNames = Object.keys(addedStates).map(stateName => `"${stateName}"`);
+        message +=
+            '\nFeature states added before the store initialization is complete: ' +
+                `${stateNames.join(', ')}.`;
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsActionRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsActionRegistry, providedIn: 'root' }); }
+    return message;
+}
+function throwPatchingArrayError() {
+    throw new Error('Patching arrays is not supported.');
+}
+function throwPatchingPrimitiveError() {
+    throw new Error('Patching primitives is not supported.');
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsActionRegistry, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
 
-const stateNameRegex = new RegExp('^[a-zA-Z0-9_]+$');
+const stateNameRegex = /* @__PURE__ */ new RegExp('^[a-zA-Z0-9_]+$');
 function ensureStateNameIsValid(name) {
     if (!name) {
         throwStateNamePropertyError();
@@ -982,12 +861,12 @@ const NGXS_DEVELOPMENT_OPTIONS =
 });
 
 class NgxsUnhandledActionsLogger {
+    /**
+     * These actions should be ignored by default; the user can increase this
+     * list in the future via the `ignoreActions` method.
+     */
+    _ignoredActions = new Set([InitState.type, UpdateState.type]);
     constructor() {
-        /**
-         * These actions should be ignored by default; the user can increase this
-         * list in the future via the `ignoreActions` method.
-         */
-        this._ignoredActions = new Set([InitState.type, UpdateState.type]);
         const options = inject(NGXS_DEVELOPMENT_OPTIONS);
         if (typeof options.warnOnUnhandledActions === 'object') {
             this.ignoreActions(...options.warnOnUnhandledActions.ignore);
@@ -1013,122 +892,37 @@ 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 { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsUnhandledActionsLogger, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsUnhandledActionsLogger }); }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsUnhandledActionsLogger, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsUnhandledActionsLogger });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsUnhandledActionsLogger, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsUnhandledActionsLogger, decorators: [{
             type: Injectable
         }], ctorParameters: () => [] });
-
-class NgxsUnhandledErrorHandler {
-    constructor() {
-        this._ngZone = inject(NgZone);
-        this._errorHandler = inject(ErrorHandler);
-    }
-    /**
-     * The `_unhandledErrorContext` is left unused internally since we do not
-     * require it for internal operations. However, developers who wish to provide
-     * their own custom error handler may utilize this context information.
-     */
-    handleError(error, _unhandledErrorContext) {
-        // In order to avoid duplicate error handling, it is necessary to leave
-        // the Angular zone to ensure that errors are not caught twice. The `handleError`
-        // method may contain a `throw error` statement, which is used to re-throw the error.
-        // If the error is re-thrown within the Angular zone, it will be caught again by the
-        // Angular zone. By default, `@angular/core` leaves the Angular zone when invoking
-        // `handleError` (see `_callAndReportToErrorHandler`).
-        this._ngZone.runOutsideAngular(() => this._errorHandler.handleError(error));
-    }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsUnhandledErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsUnhandledErrorHandler, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsUnhandledErrorHandler, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-function simplePatch(value) {
-    return (existingState) => {
-        if (typeof ngDevMode !== 'undefined' && ngDevMode) {
-            if (Array.isArray(value)) {
-                throwPatchingArrayError();
-            }
-            else if (typeof value !== 'object') {
-                throwPatchingPrimitiveError();
-            }
-        }
-        const newState = { ...existingState };
-        for (const key in value) {
-            // deep clone for patch compatibility
-            newState[key] = value[key];
-        }
-        return newState;
-    };
-}
-
-/**
- * State Context factory class
- * @ignore
- */
-class StateContextFactory {
-    constructor() {
-        this._internalStateOperations = inject(InternalStateOperations);
-    }
-    /**
-     * Create the state context
-     */
-    createStateContext(path) {
-        const root = this._internalStateOperations.getRootStateOperations();
-        return {
-            getState() {
-                const currentAppState = root.getState();
-                return getState(currentAppState, path);
-            },
-            patchState(val) {
-                const currentAppState = root.getState();
-                const patchOperator = simplePatch(val);
-                setStateFromOperator(root, currentAppState, patchOperator, path);
-            },
-            setState(val) {
-                const currentAppState = root.getState();
-                if (isStateOperator(val)) {
-                    setStateFromOperator(root, currentAppState, val, path);
-                }
-                else {
-                    setStateValue(root, currentAppState, val, path);
-                }
-            },
-            dispatch(actions) {
-                return root.dispatch(actions);
-            }
-        };
+
+class NgxsUnhandledErrorHandler {
+    _ngZone = inject(NgZone);
+    _errorHandler = inject(ErrorHandler);
+    /**
+     * The `_unhandledErrorContext` is left unused internally since we do not
+     * require it for internal operations. However, developers who wish to provide
+     * their own custom error handler may utilize this context information.
+     */
+    handleError(error, _unhandledErrorContext) {
+        // In order to avoid duplicate error handling, it is necessary to leave
+        // the Angular zone to ensure that errors are not caught twice. The `handleError`
+        // method may contain a `throw error` statement, which is used to re-throw the error.
+        // If the error is re-thrown within the Angular zone, it will be caught again by the
+        // Angular zone. By default, `@angular/core` leaves the Angular zone when invoking
+        // `handleError` (see `_callAndReportToErrorHandler`).
+        this._ngZone.runOutsideAngular(() => this._errorHandler.handleError(error));
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: StateContextFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: StateContextFactory, providedIn: 'root' }); }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsUnhandledErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsUnhandledErrorHandler, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: StateContextFactory, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsUnhandledErrorHandler, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
-function setStateValue(root, currentAppState, newValue, path) {
-    const newAppState = setValue(currentAppState, path, newValue);
-    root.setState(newAppState);
-    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) {
-    const local = getState(currentAppState, path);
-    const newValue = stateOperator(local);
-    return setStateValue(root, currentAppState, newValue, path);
-}
-function getState(currentAppState, path) {
-    return getValue(currentAppState, path);
-}
 
 /**
  * RxJS operator for selecting out specific actions.
@@ -1144,7 +938,7 @@ function ofAction(...allowedTypes) {
  * This will ONLY grab actions that have just been dispatched
  */
 function ofActionDispatched(...allowedTypes) {
-    return ofActionOperator(allowedTypes, ["DISPATCHED" /* ActionStatus.Dispatched */]);
+    return ofActionOperator(allowedTypes, [ActionStatus.Dispatched]);
 }
 /**
  * RxJS operator for selecting out specific actions.
@@ -1152,7 +946,7 @@ function ofActionDispatched(...allowedTypes) {
  * This will ONLY grab actions that have just been successfully completed
  */
 function ofActionSuccessful(...allowedTypes) {
-    return ofActionOperator(allowedTypes, ["SUCCESSFUL" /* ActionStatus.Successful */]);
+    return ofActionOperator(allowedTypes, [ActionStatus.Successful]);
 }
 /**
  * RxJS operator for selecting out specific actions.
@@ -1160,7 +954,7 @@ function ofActionSuccessful(...allowedTypes) {
  * This will ONLY grab actions that have just been canceled
  */
 function ofActionCanceled(...allowedTypes) {
-    return ofActionOperator(allowedTypes, ["CANCELED" /* ActionStatus.Canceled */]);
+    return ofActionOperator(allowedTypes, [ActionStatus.Canceled]);
 }
 /**
  * RxJS operator for selecting out specific actions.
@@ -1169,9 +963,9 @@ function ofActionCanceled(...allowedTypes) {
  */
 function ofActionCompleted(...allowedTypes) {
     const allowedStatuses = [
-        "SUCCESSFUL" /* ActionStatus.Successful */,
-        "CANCELED" /* ActionStatus.Canceled */,
-        "ERRORED" /* ActionStatus.Errored */
+        ActionStatus.Successful,
+        ActionStatus.Canceled,
+        ActionStatus.Errored
     ];
     return ofActionOperator(allowedTypes, allowedStatuses, mapActionResult);
 }
@@ -1181,7 +975,7 @@ function ofActionCompleted(...allowedTypes) {
  * This will ONLY grab actions that have just thrown an error
  */
 function ofActionErrored(...allowedTypes) {
-    return ofActionOperator(allowedTypes, ["ERRORED" /* ActionStatus.Errored */], mapActionResult);
+    return ofActionOperator(allowedTypes, [ActionStatus.Errored], mapActionResult);
 }
 function ofActionOperator(allowedTypes, statuses, 
 // This could have been written as
@@ -1197,7 +991,7 @@ mapOperator = mapAction) {
     };
 }
 function filterStatus(allowedTypes, allowedStatuses) {
-    return filter$1((ctx) => {
+    return filter((ctx) => {
         const actionType = getActionTypeFromInstance(ctx.action);
         const typeMatch = allowedTypes[actionType];
         const statusMatch = allowedStatuses ? allowedStatuses[ctx.status] : true;
@@ -1209,8 +1003,8 @@ function mapActionResult() {
         return {
             action,
             result: {
-                successful: "SUCCESSFUL" /* ActionStatus.Successful */ === status,
-                canceled: "CANCELED" /* ActionStatus.Canceled */ === status,
+                successful: ActionStatus.Successful === status,
+                canceled: ActionStatus.Canceled === status,
                 error
             }
         };
@@ -1232,6 +1026,160 @@ function createAllowedStatusesMap(statuses) {
     }, {});
 }
 
+function simplePatch(value) {
+    return (existingState) => {
+        if (typeof ngDevMode !== 'undefined' && ngDevMode) {
+            if (Array.isArray(value)) {
+                throwPatchingArrayError();
+            }
+            else if (typeof value !== 'object') {
+                throwPatchingPrimitiveError();
+            }
+        }
+        const newState = { ...existingState };
+        for (const key in value) {
+            // deep clone for patch compatibility
+            newState[key] = value[key];
+        }
+        return newState;
+    };
+}
+
+/**
+ * State Context factory class
+ * @ignore
+ */
+class StateContextFactory {
+    _internalStateOperations = inject(InternalStateOperations);
+    /**
+     * Create the state context
+     */
+    createStateContext(path) {
+        const root = this._internalStateOperations.getRootStateOperations();
+        return {
+            getState() {
+                const currentAppState = root.getState();
+                return getState(currentAppState, path);
+            },
+            patchState(val) {
+                const currentAppState = root.getState();
+                const patchOperator = simplePatch(val);
+                setStateFromOperator(root, currentAppState, patchOperator, path);
+            },
+            setState(val) {
+                const currentAppState = root.getState();
+                if (isStateOperator(val)) {
+                    setStateFromOperator(root, currentAppState, val, path);
+                }
+                else {
+                    setStateValue(root, currentAppState, val, path);
+                }
+            },
+            dispatch(actions) {
+                return root.dispatch(actions);
+            }
+        };
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: StateContextFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: StateContextFactory, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: StateContextFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+function setStateValue(root, currentAppState, newValue, path) {
+    const newAppState = setValue(currentAppState, path, newValue);
+    root.setState(newAppState);
+    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) {
+    const local = getState(currentAppState, path);
+    const newValue = stateOperator(local);
+    return setStateValue(root, currentAppState, newValue, path);
+}
+function getState(currentAppState, path) {
+    return getValue(currentAppState, path);
+}
+
+class InternalActionHandlerFactory {
+    _actions = inject(InternalActions);
+    _stateContextFactory = inject(StateContextFactory);
+    createActionHandler(path, handlerFn, options) {
+        const { dispatched$ } = this._actions;
+        return (action) => {
+            const stateContext = this._stateContextFactory.createStateContext(path);
+            let result = handlerFn(stateContext, action);
+            // We need to use `isPromise` instead of checking whether
+            // `result instanceof Promise`. In zone.js patched environments, `global.Promise`
+            // is the `ZoneAwarePromise`. Some APIs, which are likely not patched by zone.js
+            // for certain reasons, might not work with `instanceof`. For instance, the dynamic
+            // import returns a native promise (not a `ZoneAwarePromise`), causing this check to
+            // be falsy.
+            if (_isPromise(result)) {
+                result = from(result);
+            }
+            if (isObservable(result)) {
+                result = result.pipe(mergeMap(value => (_isPromise(value) || isObservable(value) ? value : of(value))), 
+                // If this observable has completed without emitting any values,
+                // we wouldn't want to complete the entire chain of actions.
+                // If any observable completes, then the action will be canceled.
+                // For instance, if any action handler had a statement like
+                // `handler(ctx) { return EMPTY; }`, then the action would be canceled.
+                // See https://github.com/ngxs/store/issues/1568
+                // Note that we actually don't care about the return type; we only care
+                // about emission, and thus `undefined` is applicable by the framework.
+                defaultIfEmpty(undefined));
+                if (options.cancelUncompleted) {
+                    const canceled = dispatched$.pipe(ofActionDispatched(action));
+                    result = result.pipe(takeUntil(canceled));
+                }
+                result = result.pipe(
+                // Note that we use the `finalize` operator only when the action handler
+                // explicitly returns an observable (or a promise) to wait for. This means
+                // the action handler is written in a "fire & wait" style. If the handler’s
+                // result is unsubscribed (either because the observable has completed or
+                // it was unsubscribed by `takeUntil` due to a new action being dispatched),
+                // we prevent writing to the state context.
+                finalize(() => {
+                    if (typeof ngDevMode !== 'undefined' && ngDevMode) {
+                        function noopAndWarn() {
+                            console.warn(`"${action}" attempted to change the state, but the change was ignored because state updates are not allowed after the action handler has completed.`);
+                        }
+                        stateContext.setState = noopAndWarn;
+                        stateContext.patchState = noopAndWarn;
+                    }
+                    else {
+                        stateContext.setState = noop;
+                        stateContext.patchState = noop;
+                    }
+                }));
+            }
+            else {
+                // If the action handler is synchronous and returns nothing (`void`), we
+                // still have to convert the result to a synchronous observable.
+                result = of(undefined);
+            }
+            return result;
+        };
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: InternalActionHandlerFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: InternalActionHandlerFactory, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: InternalActionHandlerFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+// This is used to replace `setState` and `patchState` once the action
+// handler has been unsubscribed or completed, to prevent writing
+// to the state context.
+function noop() { }
+
 function cloneDefaults(defaults) {
     let value = defaults === undefined ? {} : defaults;
     if (defaults) {
@@ -1256,57 +1204,55 @@ function cloneDefaults(defaults) {
  * @ignore
  */
 class StateFactory {
-    constructor() {
-        this._injector = inject(Injector);
-        this._config = inject(NgxsConfig);
-        this._stateContextFactory = inject(StateContextFactory);
-        this._actions = inject(InternalActions);
-        this._actionResults = inject(InternalDispatchedActionResults);
-        this._initialState = inject(_INITIAL_STATE_TOKEN, { optional: true });
-        this._actionRegistry = inject(NgxsActionRegistry);
-        this._propGetter = inject(ɵPROP_GETTER);
-        this._actionsSubscription = null;
-        this._ngxsUnhandledErrorHandler = null;
-        this._states = [];
-        this._statesByName = {};
-        this._statePaths = {};
-        this.getRuntimeSelectorContext = _memoize(() => {
-            // eslint-disable-next-line @typescript-eslint/no-this-alias
-            const stateFactory = this;
-            const propGetter = stateFactory._propGetter;
-            function resolveGetter(key) {
-                const path = stateFactory._statePaths[key];
-                return path ? propGetter(path.split('.')) : null;
-            }
-            const context = {
-                getStateGetter(key) {
-                    // Use `@__INLINE__` annotation to forcely inline `resolveGetter`.
-                    // This is a Terser annotation, which will function only in the production mode.
-                    let getter = /*@__INLINE__*/ resolveGetter(key);
-                    if (getter) {
-                        return getter;
-                    }
-                    return (...args) => {
-                        // Late loaded getter
-                        if (!getter) {
-                            getter = /*@__INLINE__*/ resolveGetter(key);
-                        }
-                        return getter ? getter(...args) : undefined;
-                    };
-                },
-                getSelectorOptions(localOptions) {
-                    const globalSelectorOptions = stateFactory._config.selectorOptions;
-                    return {
-                        ...globalSelectorOptions,
-                        ...(localOptions || {})
-                    };
+    _injector = inject(Injector);
+    _config = inject(NgxsConfig);
+    _actionHandlerFactory = inject(InternalActionHandlerFactory);
+    _actions = inject(InternalActions);
+    _actionResults = inject(InternalDispatchedActionResults);
+    _initialState = inject(_INITIAL_STATE_TOKEN, { optional: true });
+    _actionRegistry = inject(_NgxsActionRegistry);
+    _propGetter = inject(ɵPROP_GETTER);
+    _actionsSubscription = null;
+    _ngxsUnhandledErrorHandler = null;
+    _states = [];
+    _statesByName = {};
+    _statePaths = {};
+    getRuntimeSelectorContext = _memoize(() => {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const stateFactory = this;
+        const propGetter = stateFactory._propGetter;
+        function resolveGetter(key) {
+            const path = stateFactory._statePaths[key];
+            return path ? propGetter(path.split('.')) : null;
+        }
+        const context = {
+            getStateGetter(key) {
+                // Use `@__INLINE__` annotation to forcely inline `resolveGetter`.
+                // This is a Terser annotation, which will function only in the production mode.
+                let getter = /*@__INLINE__*/ resolveGetter(key);
+                if (getter) {
+                    return getter;
                 }
-            };
-            return context;
-        });
-    }
-    ngOnDestroy() {
-        this._actionsSubscription?.unsubscribe();
+                return (...args) => {
+                    // Late loaded getter
+                    if (!getter) {
+                        getter = /*@__INLINE__*/ resolveGetter(key);
+                    }
+                    return getter ? getter(...args) : undefined;
+                };
+            },
+            getSelectorOptions(localOptions) {
+                const globalSelectorOptions = stateFactory._config.selectorOptions;
+                return {
+                    ...globalSelectorOptions,
+                    ...(localOptions || {})
+                };
+            }
+        };
+        return context;
+    });
+    constructor() {
+        inject(DestroyRef).onDestroy(() => this._actionsSubscription?.unsubscribe());
     }
     /**
      * Add a new state to the global defs.
@@ -1328,10 +1274,6 @@ class StateFactory {
             const path = paths[name];
             const meta = stateClass[_META_KEY];
             this.addRuntimeInfoToMeta(meta, path);
-            // Note: previously we called `ensureStateClassIsInjectable` within the
-            // `State` decorator. This check is moved here because the `ɵprov` property
-            // will not exist on the class in JIT mode (because it's set asynchronously
-            // during JIT compilation through `Object.defineProperty`).
             if (typeof ngDevMode !== 'undefined' && ngDevMode) {
                 ensureStateClassIsInjectable(stateClass);
             }
@@ -1365,15 +1307,15 @@ class StateFactory {
     }
     connectActionHandlers() {
         this._actionsSubscription = this._actions
-            .pipe(filter((ctx) => ctx.status === "DISPATCHED" /* ActionStatus.Dispatched */), mergeMap$1(ctx => {
+            .pipe(filter((ctx) => ctx.status === ActionStatus.Dispatched), mergeMap(ctx => {
             const action = ctx.action;
-            return this.invokeActions(action).pipe(map$1(() => ({ action, status: "SUCCESSFUL" /* ActionStatus.Successful */ })), defaultIfEmpty({ action, status: "CANCELED" /* ActionStatus.Canceled */ }), catchError(error => {
+            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: "ERRORED" /* ActionStatus.Errored */,
+                    status: ActionStatus.Errored,
                     error: handleableError
                 });
             }));
@@ -1397,7 +1339,7 @@ class StateFactory {
                     result = actionHandler(action);
                 }
                 catch (e) {
-                    result = throwError(() => e);
+                    result = new Observable(subscriber => subscriber.error(e));
                 }
                 results.push(result);
                 actionHasBeenHandled = true;
@@ -1447,98 +1389,37 @@ class StateFactory {
         return this._statesByName[name] && valueIsBootstrappedInInitialState;
     }
     hydrateActionMetasMap({ path, actions, instance }) {
-        const { dispatched$ } = this._actions;
         for (const actionType of Object.keys(actions)) {
             const actionHandlers = actions[actionType].map(actionMeta => {
-                const cancelable = !!actionMeta.options.cancelUncompleted;
-                return (action) => {
-                    const stateContext = this._stateContextFactory.createStateContext(path);
-                    let result = instance[actionMeta.fn](stateContext, action);
-                    // We need to use `isPromise` instead of checking whether
-                    // `result instanceof Promise`. In zone.js patched environments, `global.Promise`
-                    // is the `ZoneAwarePromise`. Some APIs, which are likely not patched by zone.js
-                    // for certain reasons, might not work with `instanceof`. For instance, the dynamic
-                    // import returns a native promise (not a `ZoneAwarePromise`), causing this check to
-                    // be falsy.
-                    if (_isPromise(result)) {
-                        result = from(result);
-                    }
-                    if (isObservable(result)) {
-                        result = result.pipe(mergeMap$1((value) => {
-                            if (_isPromise(value)) {
-                                return from(value);
-                            }
-                            else if (isObservable(value)) {
-                                return value;
-                            }
-                            else {
-                                return of(value);
-                            }
-                        }), 
-                        // If this observable has completed without emitting any values,
-                        // we wouldn't want to complete the entire chain of actions.
-                        // If any observable completes, then the action will be canceled.
-                        // For instance, if any action handler had a statement like
-                        // `handler(ctx) { return EMPTY; }`, then the action would be canceled.
-                        // See https://github.com/ngxs/store/issues/1568
-                        // Note that we actually don't care about the return type; we only care
-                        // about emission, and thus `undefined` is applicable by the framework.
-                        defaultIfEmpty(undefined));
-                        if (cancelable) {
-                            const notifier$ = dispatched$.pipe(ofActionDispatched(action));
-                            result = result.pipe(takeUntil(notifier$));
-                        }
-                        result = result.pipe(
-                        // Note that we use the `finalize` operator only when the action handler
-                        // returns an observable. If the action handler is synchronous, we do not
-                        // need to set the state context functions to `noop`, as the absence of a
-                        // return value indicates no asynchronous functionality. If the handler's
-                        // result is unsubscribed (either because the observable has completed or it
-                        // was unsubscribed by `takeUntil` due to a new action being dispatched),
-                        // we prevent writing to the state context.
-                        finalize(() => {
-                            stateContext.setState = noop;
-                            stateContext.patchState = noop;
-                        }));
-                    }
-                    else {
-                        // If the action handler is synchronous and returns nothing (`void`), we
-                        // still have to convert the result to a synchronous observable.
-                        result = of(undefined);
-                    }
-                    return result;
-                };
+                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);
             }
         }
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: StateFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: StateFactory, providedIn: 'root' }); }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: StateFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: StateFactory, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: StateFactory, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: StateFactory, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }] });
-// This is used to replace `setState` and `patchState` once the action
-// handler has been unsubscribed or completed, to prevent writing
-// to the state context.
-function noop() { }
+        }], ctorParameters: () => [] });
 
 class Store {
+    _stateStream = inject(_StateStream);
+    _internalStateOperations = inject(InternalStateOperations);
+    _config = inject(NgxsConfig);
+    _internalExecutionStrategy = inject(InternalNgxsExecutionStrategy);
+    _stateFactory = inject(StateFactory);
+    /**
+     * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,
+     * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.
+     * All selects would use this stream, and it would call leave only once for any state change across all active selectors.
+     */
+    _selectableStateStream = this._stateStream.pipe(leaveNgxs(this._internalExecutionStrategy), shareReplay({ bufferSize: 1, refCount: true }));
     constructor() {
-        this._stateStream = inject(_StateStream);
-        this._internalStateOperations = inject(InternalStateOperations);
-        this._config = inject(NgxsConfig);
-        this._internalExecutionStrategy = inject(InternalNgxsExecutionStrategy);
-        this._stateFactory = inject(StateFactory);
-        /**
-         * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,
-         * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.
-         * All selects would use this stream, and it would call leave only once for any state change across all active selectors.
-         */
-        this._selectableStateStream = this._stateStream.pipe(leaveNgxs(this._internalExecutionStrategy), shareReplay$1({ bufferSize: 1, refCount: true }));
         this.initStateStream();
     }
     /**
@@ -1552,7 +1433,7 @@ class Store {
                 // If a list of actions is dispatched and any of the actions are nullable.
                 (Array.isArray(actionOrActions) && actionOrActions.some(action => action == null))) {
                 const error = new Error('`dispatch()` was called without providing an action.');
-                return throwError(() => error);
+                return new Observable(subscriber => subscriber.error(error));
             }
         }
         return this._internalStateOperations.getRootStateOperations().dispatch(actionOrActions);
@@ -1562,20 +1443,20 @@ class Store {
      */
     select(selector) {
         const selectorFn = this.getStoreBoundSelectorFn(selector);
-        return this._selectableStateStream.pipe(map$1(selectorFn), catchError((error) => {
+        return this._selectableStateStream.pipe(map(selectorFn), catchError((error) => {
             // if error is TypeError we swallow it to prevent usual errors with property access
             if (this._config.selectorOptions.suppressErrors && error instanceof TypeError) {
                 return of(undefined);
             }
             // rethrow other errors
-            return throwError(error);
+            throw error;
         }), distinctUntilChanged(), leaveNgxs(this._internalExecutionStrategy));
     }
     /**
      * Select one slice of data from the store.
      */
     selectOnce(selector) {
-        return this.select(selector).pipe(take$1(1));
+        return this.select(selector).pipe(take(1));
     }
     /**
      * Select a snapshot from the state.
@@ -1625,10 +1506,10 @@ class Store {
             this._stateStream.next(initialStateValue);
         }
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: Store, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: Store, providedIn: 'root' }); }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: Store, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: Store, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: Store, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: Store, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
@@ -1663,40 +1544,24 @@ function withNgxsPreboot(prebootFn) {
     ]);
 }
 
-/**
- * Allows the select decorator to get access to the DI store, this is used internally
- * in `@Select` decorator.
- */
-class SelectFactory {
-    static { this.store = null; }
-    static { this.config = null; }
-    constructor(store, config) {
-        SelectFactory.store = store;
-        SelectFactory.config = config;
-    }
-    ngOnDestroy() {
-        SelectFactory.store = null;
-        SelectFactory.config = null;
+const ROOT_STORE_GUARD = /* @__PURE__ */ new InjectionToken('ROOT_STORE_GUARD', {
+    providedIn: 'root',
+    factory: () => ({ initialized: false })
+});
+function assertRootStoreNotInitialized() {
+    const rootStoreGuard = inject(ROOT_STORE_GUARD);
+    if (rootStoreGuard.initialized) {
+        throw new Error('provideStore() should only be called once.');
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: SelectFactory, deps: [{ token: Store }, { token: NgxsConfig }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: SelectFactory, providedIn: 'root' }); }
+    rootStoreGuard.initialized = true;
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: SelectFactory, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: Store }, { type: NgxsConfig }] });
 
 class LifecycleStateManager {
-    constructor() {
-        this._store = inject(Store);
-        this._internalStateOperations = inject(InternalStateOperations);
-        this._stateContextFactory = inject(StateContextFactory);
-        this._appBootstrappedState = inject(_NgxsAppBootstrappedState);
-        this._destroy$ = new ReplaySubject(1);
-    }
-    ngOnDestroy() {
-        this._destroy$.next();
-    }
+    _store = inject(Store);
+    _internalStateOperations = inject(InternalStateOperations);
+    _stateContextFactory = inject(StateContextFactory);
+    _appBootstrappedState = inject(_NgxsAppBootstrappedState);
+    _initStateHasBeenDispatched;
     ngxsBootstrap(action, results) {
         if (typeof ngDevMode !== 'undefined' && ngDevMode) {
             if (action instanceof InitState) {
@@ -1713,21 +1578,45 @@ class LifecycleStateManager {
                 console.error(getInvalidInitializationOrderMessage(action.addedStates));
             }
         }
+        // It does not need to unsubscribe because it is completed when the
+        // root injector is destroyed.
         this._internalStateOperations
             .getRootStateOperations()
             .dispatch(action)
-            .pipe(filter$1(() => !!results), tap(() => this._invokeInitOnStates(results.states)), mergeMap(() => this._appBootstrappedState), filter$1(appBootstrapped => !!appBootstrapped), takeUntil$1(this._destroy$))
-            .subscribe(() => this._invokeBootstrapOnStates(results.states));
+            .pipe(mergeMap(() => {
+            // If no states are provided, we safely complete the stream
+            // and do not proceed further.
+            if (!results) {
+                return EMPTY;
+            }
+            this._invokeInitOnStates(results.states);
+            return this._appBootstrappedState;
+        }))
+            .subscribe(appBootstrapped => {
+            if (appBootstrapped) {
+                this._invokeBootstrapOnStates(results.states);
+            }
+        });
     }
     _invokeInitOnStates(mappedStores) {
         for (const mappedStore of mappedStores) {
             const instance = mappedStore.instance;
             if (instance.ngxsOnChanges) {
+                // We are manually keeping track of the previous value
+                // within the subscribe block in order to drop the `pairwise()` operator.
+                let previousValue;
+                // It does not need to unsubscribe because it is completed when the
+                // root injector is destroyed.
                 this._store
                     .select(state => getValue(state, mappedStore.path))
-                    .pipe(startWith(undefined), pairwise(), takeUntil$1(this._destroy$))
-                    .subscribe(([previousValue, currentValue]) => {
+                    .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;
                     instance.ngxsOnChanges(change);
                 });
             }
@@ -1748,10 +1637,10 @@ class LifecycleStateManager {
     _getStateContext(mappedStore) {
         return this._stateContextFactory.createStateContext(mappedStore.path);
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: LifecycleStateManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: LifecycleStateManager, providedIn: 'root' }); }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: LifecycleStateManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: LifecycleStateManager, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: LifecycleStateManager, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: LifecycleStateManager, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -1762,6 +1651,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImpor
  * same initialization functionality.
  */
 function rootStoreInitializer() {
+    if (typeof ngDevMode !== 'undefined' && ngDevMode) {
+        assertRootStoreNotInitialized();
+    }
     // Override the RxJS `config.onUnhandledError` within the root store initializer,
     // but only after other code has already executed.
     // If users have a custom `config.onUnhandledError`, we might overwrite it too
@@ -1772,7 +1664,6 @@ function rootStoreInitializer() {
     const factory = inject(StateFactory);
     const internalStateOperations = inject(InternalStateOperations);
     inject(Store);
-    inject(SelectFactory);
     const states = inject(ROOT_STATE_TOKEN, { optional: true }) || [];
     const lifecycleStateManager = inject(LifecycleStateManager);
     // Add stores to the state graph and return their defaults.
@@ -1815,13 +1706,7 @@ const NGXS_ROOT_STORE_INITIALIZER = new InjectionToken(typeof ngDevMode !== 'und
 const NGXS_FEATURE_STORE_INITIALIZER = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'NGXS_FEATURE_STORE_INITIALIZER' : '');
 const NGXS_ROOT_ENVIRONMENT_INITIALIZER = [
     { provide: NGXS_ROOT_STORE_INITIALIZER, useFactory: rootStoreInitializer },
-    {
-        provide: ENVIRONMENT_INITIALIZER,
-        multi: true,
-        useFactory() {
-            return () => inject(NGXS_ROOT_STORE_INITIALIZER);
-        }
-    }
+    provideEnvironmentInitializer(() => inject(NGXS_ROOT_STORE_INITIALIZER))
 ];
 /**
  * The `NGXS_FEATURE_ENVIRONMENT_INITIALIZER` functions as an environment initializer
@@ -1831,13 +1716,7 @@ const NGXS_ROOT_ENVIRONMENT_INITIALIZER = [
  */
 const NGXS_FEATURE_ENVIRONMENT_INITIALIZER = [
     { provide: NGXS_FEATURE_STORE_INITIALIZER, useFactory: featureStatesInitializer },
-    {
-        provide: ENVIRONMENT_INITIALIZER,
-        multi: true,
-        useFactory() {
-            return () => inject(NGXS_FEATURE_STORE_INITIALIZER);
-        }
-    }
+    provideEnvironmentInitializer(() => inject(NGXS_FEATURE_STORE_INITIALIZER))
 ];
 
 /**
@@ -1847,11 +1726,11 @@ class NgxsRootModule {
     constructor() {
         rootStoreInitializer();
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsRootModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.0", ngImport: i0, type: NgxsRootModule }); }
-    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsRootModule }); }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsRootModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    /** @nocollapse */ static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.0.3", ngImport: i0, type: NgxsRootModule });
+    /** @nocollapse */ static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsRootModule });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsRootModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsRootModule, decorators: [{
             type: NgModule
         }], ctorParameters: () => [] });
 
@@ -1862,11 +1741,11 @@ class NgxsFeatureModule {
     constructor() {
         featureStatesInitializer();
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsFeatureModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.0", ngImport: i0, type: NgxsFeatureModule }); }
-    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsFeatureModule }); }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsFeatureModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    /** @nocollapse */ static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.0.3", ngImport: i0, type: NgxsFeatureModule });
+    /** @nocollapse */ static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsFeatureModule });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsFeatureModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsFeatureModule, decorators: [{
             type: NgModule
         }], ctorParameters: () => [] });
 
@@ -1892,10 +1771,6 @@ function getRootProviders(states, options) {
         {
             provide: NGXS_OPTIONS,
             useValue: options
-        },
-        {
-            provide: CUSTOM_NGXS_EXECUTION_STRATEGY,
-            useValue: options.executionStrategy
         }
     ];
 }
@@ -1929,11 +1804,11 @@ class NgxsModule {
             providers: getFeatureProviders(states)
         };
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.0", ngImport: i0, type: NgxsModule }); }
-    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsModule }); }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    /** @nocollapse */ static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.0.3", ngImport: i0, type: NgxsModule });
+    /** @nocollapse */ static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsModule });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsModule, decorators: [{
             type: NgModule
         }] });
 
@@ -1945,7 +1820,7 @@ function Action(actions, options) {
     // This parameter ensures that the decorated method has a call signature that could be passed an instance of the given action(s).
     _descriptor) => {
         if (typeof ngDevMode !== 'undefined' && ngDevMode) {
-            const isStaticMethod = target.hasOwnProperty('prototype');
+            const isStaticMethod = _hasOwnProperty(target, 'prototype');
             if (isStaticMethod) {
                 throwActionDecoratorError();
             }
@@ -1972,91 +1847,34 @@ function Action(actions, options) {
 function State(options) {
     return (target) => {
         const stateClass = target;
+        const inherited = Object.getPrototypeOf(stateClass);
         const meta = _ensureStoreMetadata(stateClass);
-        const inheritedStateClass = Object.getPrototypeOf(stateClass);
-        const optionsWithInheritance = getStateOptions(inheritedStateClass, options);
-        mutateMetaData({ meta, inheritedStateClass, optionsWithInheritance });
-        stateClass[_META_OPTIONS_KEY] = optionsWithInheritance;
+        const mergedOptions = { ...(inherited[_META_OPTIONS_KEY] || {}), ...options };
+        // Apply merged options to metadata.
+        mutateMetaData(meta, inherited, mergedOptions);
+        stateClass[_META_OPTIONS_KEY] = mergedOptions;
     };
 }
-function getStateOptions(inheritedStateClass, options) {
-    const inheritanceOptions = inheritedStateClass[_META_OPTIONS_KEY] || {};
-    return { ...inheritanceOptions, ...options };
-}
-function mutateMetaData(params) {
-    const { meta, inheritedStateClass, optionsWithInheritance } = params;
-    const { children, defaults, name } = optionsWithInheritance;
-    const stateName = typeof name === 'string' ? name : (name && name.getName()) || null;
+// Updates metadata using inherited and current options
+function mutateMetaData(meta, inherited, options) {
+    const { name, defaults, children } = options;
+    const stateName = typeof name === 'string' ? name : name?.getName?.() || null;
     if (typeof ngDevMode !== 'undefined' && ngDevMode) {
         ensureStateNameIsValid(stateName);
     }
-    if (inheritedStateClass.hasOwnProperty(_META_KEY)) {
-        const inheritedMeta = inheritedStateClass[_META_KEY] || {};
+    if (_hasOwnProperty(inherited, _META_KEY)) {
+        const inheritedMeta = inherited[_META_KEY] || {};
         meta.actions = { ...meta.actions, ...inheritedMeta.actions };
     }
-    meta.children = children;
-    meta.defaults = defaults;
     meta.name = stateName;
-}
-
-const DOLLAR_CHAR_CODE = 36;
-function createSelectObservable(selector) {
-    if (!SelectFactory.store) {
-        throwSelectFactoryNotConnectedError();
-    }
-    return SelectFactory.store.select(selector);
-}
-function createSelectorFn(name, rawSelector, paths = []) {
-    rawSelector = !rawSelector ? removeDollarAtTheEnd(name) : rawSelector;
-    if (typeof rawSelector === 'string') {
-        const propsArray = paths.length
-            ? [rawSelector, ...paths]
-            : rawSelector.split('.');
-        return propGetter(propsArray, SelectFactory.config);
-    }
-    return rawSelector;
-}
-/**
- * @example If `foo$` => make it just `foo`
- */
-function removeDollarAtTheEnd(name) {
-    const lastCharIndex = name.length - 1;
-    const dollarAtTheEnd = name.charCodeAt(lastCharIndex) === DOLLAR_CHAR_CODE;
-    return dollarAtTheEnd ? name.slice(0, lastCharIndex) : name;
-}
-
-/**
- * Decorator for selecting a slice of state from the store.
- *
- * @deprecated
- * Read the deprecation notice at this link: https://ngxs.io/deprecations/select-decorator-deprecation.
- */
-function Select(rawSelector, ...paths) {
-    return function (target, key) {
-        const name = key.toString();
-        const selectorId = `__${name}__selector`;
-        const selector = createSelectorFn(name, rawSelector, paths);
-        Object.defineProperties(target, {
-            [selectorId]: {
-                writable: true,
-                enumerable: false,
-                configurable: true
-            },
-            [name]: {
-                enumerable: true,
-                configurable: true,
-                get() {
-                    return this[selectorId] || (this[selectorId] = createSelectObservable(selector));
-                }
-            }
-        });
-    };
+    meta.defaults = defaults;
+    meta.children = children;
 }
 
 const SELECTOR_OPTIONS_META_KEY = 'NGXS_SELECTOR_OPTIONS_META';
 const selectorOptionsMetaAccessor = {
     getOptions: (target) => {
-        return (target && target[SELECTOR_OPTIONS_META_KEY]) || {};
+        return target?.[SELECTOR_OPTIONS_META_KEY] || {};
     },
     defineOptions: (target, options) => {
         if (!target)
@@ -2119,7 +1937,7 @@ function Selector(selectors) {
         descriptor ||= Object.getOwnPropertyDescriptor(target, key);
         const originalFn = descriptor?.value;
         if (typeof ngDevMode !== 'undefined' && ngDevMode) {
-            if (originalFn && typeof originalFn !== 'function') {
+            if (typeof originalFn !== 'function') {
                 throwSelectorDecoratorError();
             }
         }
@@ -2141,6 +1959,21 @@ function Selector(selectors) {
     };
 }
 
+class ActionDirector {
+    _registry = inject(_NgxsActionRegistry);
+    _actionHandlerFactory = inject(InternalActionHandlerFactory);
+    attachAction(stateToken, Action, handlerFn, options = {}) {
+        const actionHandler = this._actionHandlerFactory.createActionHandler(stateToken.getName(), handlerFn, options);
+        this._registry.register(Action.type, actionHandler);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: ActionDirector, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: ActionDirector, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: ActionDirector, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
 class NgxsDevelopmentModule {
     static forRoot(options) {
         return {
@@ -2151,11 +1984,11 @@ class NgxsDevelopmentModule {
             ]
         };
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsDevelopmentModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.0", ngImport: i0, type: NgxsDevelopmentModule }); }
-    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsDevelopmentModule }); }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsDevelopmentModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    /** @nocollapse */ static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.0.3", ngImport: i0, type: NgxsDevelopmentModule });
+    /** @nocollapse */ static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsDevelopmentModule });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxsDevelopmentModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgxsDevelopmentModule, decorators: [{
             type: NgModule
         }] });
 function withNgxsDevelopmentOptions(options) {
@@ -2276,19 +2109,60 @@ function createPropertySelectors(parentSelector) {
  */
 function withNgxsPendingTasks() {
     return withNgxsPreboot(() => {
-        const pendingTasks = inject(PendingTasks);
         const actions$ = inject(Actions);
-        const actionToRemoveTaskFnMap = new Map();
-        actions$.subscribe(ctx => {
-            if (ctx.status === "DISPATCHED" /* ActionStatus.Dispatched */) {
-                const removeTaskFn = pendingTasks.add();
-                actionToRemoveTaskFnMap.set(ctx.action, removeTaskFn);
+        const appRef = inject(ApplicationRef);
+        const pendingTasks = inject(PendingTasks);
+        // Removing a pending task via the public API forces a scheduled tick, ensuring that
+        // stability is async and delayed until there was at least an opportunity to run
+        // app synchronization.
+        // Adding a new task every time an action is dispatched drastically increases the
+        // number of change detection cycles because removing a task schedules a new change
+        // detection cycle.
+        // If 10 actions are dispatched with synchronous action handlers, this would trigger
+        // 10 change detection cycles in a row, potentially leading to an
+        // `INFINITE_CHANGE_DETECTION` error.
+        let removeTask = null;
+        const executedActions = new Set();
+        // If the app is forcely destroyed before all actions are completed,
+        // we clean up the set of actions being executed to prevent memory leaks
+        // and remove the pending task to stabilize the app.
+        appRef.onDestroy(() => executedActions.clear());
+        let isStable = false;
+        appRef.whenStable().then(() => {
+            isStable = true;
+        });
+        const subscription = actions$
+            .pipe(filter(context => {
+            if (context.status === ActionStatus.Dispatched) {
+                executedActions.add(context.action);
+                removeTask ||= pendingTasks.add();
+                return false;
             }
             else {
-                const removeTaskFn = actionToRemoveTaskFnMap.get(ctx.action);
-                if (typeof removeTaskFn === 'function') {
-                    actionToRemoveTaskFnMap.delete(ctx.action);
-                    removeTaskFn();
+                return true;
+            }
+        }), 
+        // Every time an action is completed, we debounce the stream to ensure only one
+        // task is removed, even if multiple synchronous actions are completed in a row.
+        // We use `buffer` to collect action contexts because, if we only use
+        // `debounceTime(0)`, we may lose action contexts that are never removed from the set.
+        buffer(actions$.pipe(debounceTime(0))))
+            .subscribe(contexts => {
+            for (const context of contexts) {
+                if (!executedActions.has(context.action)) {
+                    continue;
+                }
+                executedActions.delete(context.action);
+                // Mark app as stable once all of the debounced actions have completed.
+                if (executedActions.size === 0) {
+                    removeTask?.();
+                    removeTask = null;
+                    if (isStable) {
+                        // Stop contributing to stability once the application has become stable,
+                        // which may happen on the server before the platform is destroyed or in
+                        // the browser once hydration is complete.
+                        subscription.unsubscribe();
+                    }
                 }
             }
         });
@@ -2332,6 +2206,9 @@ function isEnvironmentProvider(target) {
  *   }
  * ];
  * ```
+ *
+ * To lazy-load feature states at the route level,
+ * please refer to the `lazyProvider` utility function.
  */
 function provideStates(states, ...features) {
     return makeEnvironmentProviders([
@@ -2363,11 +2240,7 @@ function withNgxsPlugin(plugin) {
         // 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.
-        {
-            provide: ENVIRONMENT_INITIALIZER,
-            useValue: () => inject(PluginManager),
-            multi: true
-        }
+        provideEnvironmentInitializer(() => inject(PluginManager))
     ]);
 }
 
@@ -2396,24 +2269,79 @@ function dispatch(ActionType) {
 function createSelectMap(selectorMap) {
     const store = inject(Store);
     return Object.entries(selectorMap).reduce((accumulator, [key, selector]) => {
-        Object.defineProperty(accumulator, key, {
-            enumerable: true,
-            value: store.selectSignal(selector)
-        });
+        accumulator[key] = store.selectSignal(selector);
         return accumulator;
     }, {});
 }
 
 function createDispatchMap(actionMap) {
     return Object.entries(actionMap).reduce((accumulator, [key, ActionType]) => {
-        Object.defineProperty(accumulator, key, {
-            enumerable: true,
-            value: dispatch(ActionType)
-        });
+        accumulator[key] = dispatch(ActionType);
         return accumulator;
     }, {});
 }
 
+function isWrappedDefaultExport(value) {
+    return value && typeof value === 'object' && 'default' in value;
+}
+function maybeUnwrapDefaultExport(input) {
+    return isWrappedDefaultExport(input) ? input['default'] : input;
+}
+const REGISTERED_PROVIDERS = new InjectionToken('', {
+    providedIn: 'root',
+    factory: () => {
+        const registeredProviders = new Set();
+        inject(ApplicationRef).onDestroy(() => registeredProviders.clear());
+        return registeredProviders;
+    }
+});
+/**
+ * This function serves as a utility to lazy-load providers at the injection
+ * context level — for example, at the route level. If the feature state needs
+ * to be provided in more than one place, it might be indirectly included in
+ * the main bundle, which we want to avoid. This function can be used at the
+ * guard level to lazy-load the state provider before resolvers run and the
+ * component is initialized:
+ *
+ * ```ts
+ * const routes = [
+ *   {
+ *     path: 'home',
+ *     loadComponent: () => import(...),
+ *     canActivate: [
+ *       lazyProvider(async () => (await import('path-to-state-library')).invoicesStateProvider)
+ *     ]
+ *   }
+ * ];
+ * ```
+ *
+ * Where `invoicesStateProvider` is the following:
+ *
+ * ```ts
+ * // path-to-state-library/index.ts
+ *
+ * export const invoicesStateProvider = provideStates([InvoicesState]);
+ * ```
+ */
+function lazyProvider(factory) {
+    return async () => {
+        if (typeof ngDevMode !== 'undefined' && ngDevMode) {
+            assertInInjectionContext(lazyProvider);
+        }
+        const appRef = inject(ApplicationRef);
+        const parentInjector = inject(EnvironmentInjector);
+        const registeredProviders = inject(REGISTERED_PROVIDERS);
+        const provider = maybeUnwrapDefaultExport(await factory());
+        if (registeredProviders.has(provider)) {
+            return true;
+        }
+        registeredProviders.add(provider);
+        const injector = createEnvironmentInjector([provider], parentInjector);
+        appRef.onDestroy(() => injector.destroy());
+        return true;
+    };
+}
+
 // Backward compatibility is provided because these tokens are used by third-party
 // libraries. We expose a separate function to allow tree-shaking of these tokens
 // if they are not used in standard applications that do not rely on them.
@@ -2438,5 +2366,5 @@ function ɵprovideNgxsInternalStateTokens() {
  * Generated bundle index. Do not edit.
  */
 
-export { Action, Actions, NgxsConfig, NgxsDevelopmentModule, NgxsModule, NgxsSimpleChange, NgxsUnhandledActionsLogger, NgxsUnhandledErrorHandler, NoopNgxsExecutionStrategy, Select, Selector, SelectorOptions, State, Store, createDispatchMap, createModelSelector, createPickSelector, createPropertySelectors, createSelectMap, createSelector, dispatch, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, provideStates, provideStore, select, withNgxsDevelopmentOptions, withNgxsPendingTasks, withNgxsPlugin, withNgxsPreboot, NgxsFeatureModule as ɵNgxsFeatureModule, NgxsRootModule as ɵNgxsRootModule, ɵprovideNgxsInternalStateTokens };
+export { Action, ActionDirector, ActionStatus, Actions, NgxsConfig, NgxsDevelopmentModule, NgxsModule, NgxsSimpleChange, NgxsUnhandledActionsLogger, NgxsUnhandledErrorHandler, Selector, SelectorOptions, State, Store, createDispatchMap, createModelSelector, createPickSelector, createPropertySelectors, createSelectMap, createSelector, dispatch, lazyProvider, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, provideStates, provideStore, select, withNgxsDevelopmentOptions, withNgxsPendingTasks, withNgxsPlugin, withNgxsPreboot, NgxsFeatureModule as ɵNgxsFeatureModule, NgxsRootModule as ɵNgxsRootModule, ɵprovideNgxsInternalStateTokens };
 //# sourceMappingURL=ngxs-store.mjs.map