@nativescript/angular 21.0.1-alpha.2 → 21.0.1-alpha.3

package/fesm2022/nativescript-angular.mjs

@@ -6,8 +6,8 @@ import { __decorate, __param, __metadata } from 'tslib';
 import * as i1$2 from '@angular/common';
 import { LocationStrategy, XhrFactory, CommonModule, ɵNullViewportScroller as _NullViewportScroller, ViewportScroller, PlatformLocation, DOCUMENT } from '@angular/common';
 import * as i1$3 from '@angular/router';
-import { DefaultUrlSerializer, Router, PRIMARY_OUTLET, NavigationEnd, ChildrenOutletContexts, ActivatedRoute, RouteReuseStrategy, RouterModule, provideRouter } from '@angular/router';
-import { BehaviorSubject, Subject, fromEvent, defer, Observable as Observable$1 } from 'rxjs';
+import { DefaultUrlSerializer, Router, PRIMARY_OUTLET, NavigationEnd, ChildrenOutletContexts, ActivatedRoute, NavigationCancel, NavigationError, NavigationStart, RouteReuseStrategy, RouterModule, provideRouter } from '@angular/router';
+import { BehaviorSubject, Subject, ReplaySubject, fromEvent, defer, Observable as Observable$1 } from 'rxjs';
 import { filter, map, take, distinctUntilChanged, startWith } from 'rxjs/operators';
 import { NG_VALUE_ACCESSOR, FormsModule } from '@angular/forms';
 import { ɵBrowserAnimationBuilder as _BrowserAnimationBuilder, AnimationBuilder } from '@angular/animations';
@@ -256,6 +256,560 @@ function resetAngularHmrCompiledComponents(core) {
     }
 }
 
+/**
+ * Centralised dev-mode + HMR detection for `@nativescript/angular` helpers.
+ *
+ * The package ships HMR scaffolding (route tracker, route replay, modal
+ * preservation, compiled-component reset) that subscribes to long-lived
+ * router and bootstrap streams. None of that work belongs in a production
+ * binary — it would attach observers that never fire and keep references
+ * that confuse Angular's destroy logic.
+ *
+ * Every HMR helper consults {@link isAngularHmrEnabled} from its
+ * constructor. The check is intentionally cheap (no network, no I/O) so it
+ * is safe to call in dependency-injection factories and in fast paths.
+ *
+ * Detection cascade (returns the first match):
+ *  1. **Production build short-circuit** — `ngDevMode === false` means
+ *     Angular built the app in production mode. We bail immediately.
+ *  2. **NativeScript Vite dev signal** — see
+ *     {@link isNativeScriptViteHmrActive}. We accept either of the two
+ *     persistent globals the NS Vite root-placeholder installer manages
+ *     (`__NS_DEV_PLACEHOLDER_ROOT_EARLY__` during early boot,
+ *     `__NS_HMR_BOOT_COMPLETE__` after the real app root commits) so
+ *     services that are constructed *after* the placeholder has handed
+ *     off — e.g. `NativeDialog` instantiated lazily when the user opens
+ *     their first modal — still detect HMR correctly.
+ *  3. **Webpack HMR signal** — `globalThis.__webpack_require__` is set
+ *     when the webpack runtime is loaded. Combined with the `ngDevMode`
+ *     short-circuit above, its presence means "webpack dev". The
+ *     production webpack runtime also sets the global, but `ngDevMode`
+ *     would already be `false`, so the production case never reaches
+ *     here.
+ *
+ * If none of these match, the caller should treat HMR as disabled and
+ * skip subscribing to disposal/bootstrap streams.
+ *
+ * The webpack signal lives on `globalThis` rather than `import.meta` so
+ * this file compiles cleanly under `--module commonjs` (the jest spec
+ * compiler) and under `--module esnext` (the library build).
+ */
+function isAngularHmrEnabled() {
+    if (typeof ngDevMode !== 'undefined' && ngDevMode === false) {
+        return false;
+    }
+    return isNativeScriptViteHmrActive() || isWebpackHmrActive();
+}
+/**
+ * True when the NativeScript Vite dev HMR runtime is active. This is the
+ * most reliable signal that the project's `nativescript.config.ts` set
+ * `bundler: 'vite'` AND we are running the dev server.
+ *
+ * The NS Vite root-placeholder installer manages two persistent globals:
+ *  - `__NS_DEV_PLACEHOLDER_ROOT_EARLY__` is set the moment the placeholder
+ *    runs (very early, before the real app boots), then **deleted** by
+ *    `clearPlaceholderGlobals` once `tryFinalizeBootPlaceholder` succeeds.
+ *  - `__NS_HMR_BOOT_COMPLETE__` is set in the same finalize step and is
+ *    **never deleted** for the lifetime of the dev session.
+ *
+ * Callers run the gamut of timing — e.g. the route tracker is constructed
+ * during bootstrap (early flag still set) but `NativeDialog` is typically
+ * instantiated lazily when the user opens their first modal (early flag
+ * already cleared, complete flag set). Checking either global covers both
+ * windows. If we only checked the early flag, every late-instantiated
+ * service would silently no-op and HMR features (modal preservation,
+ * route replay) would appear broken in development.
+ */
+function isNativeScriptViteHmrActive() {
+    const g = globalThis;
+    return !!(g.__NS_DEV_PLACEHOLDER_ROOT_EARLY__ || g.__NS_HMR_BOOT_COMPLETE__);
+}
+/**
+ * True when the webpack runtime is loaded. The webpack runtime sets
+ * `__webpack_require__` on `globalThis` whenever a webpack bundle is
+ * executing — both in dev and prod. Callers gate on
+ * {@link isAngularHmrEnabled} (not this directly) so the production
+ * short-circuit fires first.
+ */
+function isWebpackHmrActive() {
+    return typeof globalThis.__webpack_require__ === 'function';
+}
+/**
+ * True when Angular reports we are running with dev-mode flags. Useful
+ * for code paths that want to opt out of cost in production but don't
+ * care which bundler is running.
+ */
+function isAngularDevMode() {
+    if (typeof ngDevMode === 'undefined') {
+        return true;
+    }
+    return ngDevMode !== false;
+}
+
+class NativeScriptDebug {
+    static { this.animationsTraceCategory = 'ns-animations'; }
+    static { this.rendererTraceCategory = 'ns-renderer'; }
+    static { this.viewUtilCategory = 'ns-view-util'; }
+    static { this.routerTraceCategory = 'ns-router'; }
+    static { this.routeReuseStrategyTraceCategory = 'ns-route-reuse-strategy'; }
+    static { this.listViewTraceCategory = 'ns-list-view'; }
+    static { this.bootstrapCategory = 'bootstrap'; }
+    static { this.hmrTraceCategory = 'ns-ng-hmr'; }
+    // TODO: migrate all usage to this - avoids extraneous method executions
+    static { this.enabled = Trace.isEnabled(); }
+    static isLogEnabled() {
+        return Trace.isEnabled();
+    }
+    static animationsLog(message) {
+        Trace.write(message, NativeScriptDebug.animationsTraceCategory);
+    }
+    static rendererLog(msg) {
+        Trace.write(msg, NativeScriptDebug.rendererTraceCategory);
+    }
+    static rendererError(message) {
+        Trace.write(message, NativeScriptDebug.rendererTraceCategory, Trace.messageType.error);
+    }
+    static viewUtilLog(msg) {
+        Trace.write(msg, NativeScriptDebug.viewUtilCategory);
+    }
+    static routerLog(message) {
+        Trace.write(message, NativeScriptDebug.routerTraceCategory);
+    }
+    static routerError(message) {
+        Trace.write(message, NativeScriptDebug.routerTraceCategory, Trace.messageType.error);
+    }
+    static routeReuseStrategyLog(message) {
+        Trace.write(message, NativeScriptDebug.routeReuseStrategyTraceCategory);
+    }
+    static styleError(message) {
+        Trace.write(message, Trace.categories.Style, Trace.messageType.error);
+    }
+    static listViewLog(message) {
+        Trace.write(message, NativeScriptDebug.listViewTraceCategory);
+    }
+    static listViewError(message) {
+        Trace.write(message, NativeScriptDebug.listViewTraceCategory, Trace.messageType.error);
+    }
+    static bootstrapLog(message) {
+        Trace.write(message, NativeScriptDebug.bootstrapCategory);
+    }
+    static bootstrapLogError(message) {
+        Trace.write(message, NativeScriptDebug.bootstrapCategory, Trace.messageType.error);
+    }
+    static hmrLog(message) {
+        Trace.write(message, NativeScriptDebug.hmrTraceCategory);
+    }
+    static hmrLogError(message) {
+        Trace.write(message, NativeScriptDebug.hmrTraceCategory, Trace.messageType.error);
+    }
+}
+
+/**
+ * Fresh-class registry for HMR.
+ *
+ * After an HMR reboot, every previously imported component module is
+ * re-evaluated. Each `@Component()`-decorated class becomes a *new* class
+ * object — it shares the source name (e.g. `ResourceModalComponent`) but
+ * has a different identity from the class the host code captured before
+ * the reboot.
+ *
+ * Helpers like `NativeDialog._restoreSingleDialog` need to re-open a
+ * captured modal *with the new class so the visual update applies*.
+ * Holding onto the pre-reboot class reference reopens the modal with
+ * the old metadata, which manifests as "the change appears the next
+ * time I close and re-open the modal myself, but not when HMR auto-
+ * reopens it."
+ *
+ * The mechanism is:
+ *
+ *   1. The Vite plugin `ns-component-hmr-register` (in
+ *      `@nativescript/vite/configuration/angular`) injects a
+ *      registration call at the end of every user `.ts` file that
+ *      defines an `@Component`-decorated class:
+ *
+ *        if (typeof globalThis.__NS_HMR_REGISTER_COMPONENT__ === 'function') {
+ *          try { globalThis.__NS_HMR_REGISTER_COMPONENT__(
+ *            'ResourceModalComponent', ResourceModalComponent, import.meta.url
+ *          ); } catch {}
+ *        }
+ *
+ *   2. This module installs `__NS_HMR_REGISTER_COMPONENT__` on
+ *      `globalThis` so module re-evaluations after an HMR reboot
+ *      replace the previously-registered class with the fresh one.
+ *
+ *   3. HMR helpers (modal restore, route replay) read the registry
+ *      via {@link getFreshComponentClass} to swap in the fresh class.
+ *
+ * This avoids patching `ɵɵdefineComponent` directly, which is exported
+ * as an immutable ESM namespace binding from `@angular/core` — patch
+ * attempts silently fail (the assignment is a no-op under strict
+ * mode) so the registry never gets populated. With the self-
+ * registration approach the binding stays untouched and we don't
+ * depend on Angular's internal export shape.
+ *
+ * Production short-circuit: the registrar is only installed when
+ * {@link isAngularHmrEnabled} reports dev + (vite | webpack). In a
+ * production build the global hook is never assigned and the Vite
+ * plugin only runs in `apply: 'serve'`, so the registration calls
+ * never reach the runtime.
+ */
+const REGISTRY_KEY$1 = '__NS_ANGULAR_HMR_CLASS_REGISTRY__';
+const REGISTRY_META_KEY = '__NS_ANGULAR_HMR_CLASS_META__';
+const REGISTRAR_HOOK = '__NS_HMR_REGISTER_COMPONENT__';
+const REGISTRAR_INSTALLED_FLAG = '__NS_ANGULAR_HMR_REGISTRAR_INSTALLED__';
+/**
+ * Diagnostic: counters that survive across HMR cycles via globalThis.
+ * Used to spot patterns like "the same class registered N times in a
+ * single cycle" or "a brand-new class object every cycle".
+ */
+const DIAG_KEY = '__NS_HMR_DIAG__';
+function getDiag() {
+    const slot = globalThis;
+    if (!slot[DIAG_KEY]) {
+        slot[DIAG_KEY] = {
+            cycle: 0,
+            registerCalls: 0,
+            classIdentities: new Map(),
+            classRegisterCounts: new Map(),
+            classIds: new WeakMap(),
+            classIdNext: 1,
+        };
+    }
+    return slot[DIAG_KEY];
+}
+/** Get/assign a short stable id for a class object. */
+function getClassId(diag, cls) {
+    let id = diag.classIds.get(cls);
+    if (!id) {
+        id = `c${diag.classIdNext++}`;
+        diag.classIds.set(cls, id);
+    }
+    return id;
+}
+/**
+ * Class-registry HMR diagnostic.
+ */
+function diagLog(message) {
+    if (!isAngularHmrEnabled())
+        return;
+    if (!NativeScriptDebug.isLogEnabled())
+        return;
+    NativeScriptDebug.hmrLog(`[class-registry] ${message}`);
+}
+/**
+ * Log helper for "must surface at module-load time" messages — fires
+ * for any dev-mode build (not gated on the HMR-globals check) so the
+ * one-shot "registrar installed" line doesn't get suppressed by a
+ * module-load ordering race.
+ */
+function bootLog(message) {
+    if (!isAngularDevMode())
+        return;
+    if (!NativeScriptDebug.isLogEnabled())
+        return;
+    NativeScriptDebug.hmrLog(`[class-registry] ${message}`);
+}
+/**
+ * Public so callers from application.ts can bump the cycle counter when
+ * a new HMR reboot starts. Kept as a free function (not a class method)
+ * to avoid forcing more imports on the application module.
+ *
+ * Self-heal: by the time we hit cycle bump, dev/HMR globals are
+ * definitely set (`__NS_HMR_BOOT_COMPLETE__` was set before the first
+ * HMR cycle ever runs). Some module-load orderings end up with
+ * `installAngularHmrComponentRegistrar()` called before the early
+ * placeholder global was set, so the registrar would have returned
+ * early and never installed the hook. Re-attempting here closes that
+ * window — `installAngularHmrComponentRegistrar()` is idempotent.
+ */
+function _hmrDiagBumpCycle() {
+    const diag = getDiag();
+    diag.cycle += 1;
+    diagLog(`---- cycle ${diag.cycle} start ----`);
+    installAngularHmrComponentRegistrar();
+    return diag.cycle;
+}
+/** Public for tests. */
+function _hmrDiagSnapshot() {
+    const diag = getDiag();
+    return {
+        cycle: diag.cycle,
+        registerCalls: diag.registerCalls,
+        namesSeen: diag.classIdentities.size,
+    };
+}
+function getRegistry() {
+    const slot = globalThis;
+    let registry = slot[REGISTRY_KEY$1];
+    if (!registry) {
+        registry = new Map();
+        slot[REGISTRY_KEY$1] = registry;
+    }
+    return registry;
+}
+function getMetaRegistry() {
+    const slot = globalThis;
+    let registry = slot[REGISTRY_META_KEY];
+    if (!registry) {
+        registry = new Map();
+        slot[REGISTRY_META_KEY] = registry;
+    }
+    return registry;
+}
+/**
+ * Internal: write a class into the registry. Exposed for unit tests
+ * (which can call this directly to simulate a Vite-injected
+ * registration without spinning up the Vite plugin pipeline).
+ *
+ * Production callers should never need this — user code just calls
+ * the global `__NS_HMR_REGISTER_COMPONENT__` hook installed by
+ * {@link installAngularHmrComponentRegistrar}.
+ */
+function _registerComponentForHmr(name, cls, url = '') {
+    if (!name || typeof name !== 'string')
+        return;
+    if (cls === undefined || cls === null)
+        return;
+    const registry = getRegistry();
+    const meta = getMetaRegistry();
+    const previous = registry.get(name);
+    registry.set(name, cls);
+    meta.set(name, { url: url || '', cycle: getDiag().cycle });
+    const d = getDiag();
+    d.registerCalls += 1;
+    if (typeof cls === 'object' || typeof cls === 'function') {
+        const classId = getClassId(d, cls);
+        let identitySet = d.classIdentities.get(name);
+        if (!identitySet) {
+            identitySet = new Set();
+            d.classIdentities.set(name, identitySet);
+        }
+        identitySet.add(cls);
+        d.classRegisterCounts.set(name, (d.classRegisterCounts.get(name) ?? 0) + 1);
+        // Only log a small set of "interesting" components to keep noise
+        // manageable. Verbose mode is enabled by setting
+        // globalThis.__NS_HMR_DIAG_VERBOSE = true (e.g. from the user
+        // app's main.ts) when we want all names.
+        const verbose = !!globalThis.__NS_HMR_DIAG_VERBOSE;
+        const watchPattern = globalThis.__NS_HMR_DIAG_WATCH;
+        const matches = watchPattern instanceof RegExp ? watchPattern.test(name) : typeof watchPattern === 'string' ? name.includes(watchPattern) : /Modal|Dialog/.test(name);
+        if (verbose || matches) {
+            diagLog(`register name=${name} classId=${classId} sameAsPrev=${previous === cls} cycle=${d.cycle} totalIdentitiesForName=${identitySet.size} registerCountForName=${d.classRegisterCounts.get(name)} url=${url || '(none)'}`);
+        }
+    }
+}
+/**
+ * Install the cross-module `__NS_HMR_REGISTER_COMPONENT__` hook on
+ * `globalThis`. The Vite plugin `ns-component-hmr-register` injects
+ * a call to this hook at the end of every user `.ts` file that
+ * defines an `@Component`-decorated class, so re-evaluations after
+ * an HMR reboot keep the registry pointed at the live class.
+ *
+ * Idempotent: calling twice is a no-op (the second call sees the
+ * installed flag and returns).
+ *
+ * The hook is installed unconditionally — it's a single function
+ * reference on globalThis with negligible cost. Production builds
+ * never reach this code path because the Vite plugin
+ * `ns-component-hmr-register` runs only with `apply: 'serve'`, so
+ * the hook is never *called* in production. We previously gated
+ * this on `isAngularHmrEnabled()` but that check depends on
+ * NativeScript Vite globals (`__NS_DEV_PLACEHOLDER_ROOT_EARLY__` /
+ * `__NS_HMR_BOOT_COMPLETE__`) that are set imperatively from
+ * `main-entry.ts`. Module-load ordering can put `application.ts`
+ * evaluation *before* those globals are set in some startup paths,
+ * causing the install to silently no-op while the Vite plugin
+ * happily emits registration calls into user `.ts` files. The end
+ * result was an empty registry and `getFreshComponentClass` always
+ * reporting `reason=no-registry`. Removing the gate eliminates
+ * that race entirely.
+ */
+function installAngularHmrComponentRegistrar() {
+    const slot = globalThis;
+    if (slot[REGISTRAR_INSTALLED_FLAG]) {
+        return;
+    }
+    // Define the hook BEFORE marking installed so concurrent module
+    // initializers see the function as soon as the flag is observable.
+    slot[REGISTRAR_HOOK] = (name, cls, url) => {
+        try {
+            _registerComponentForHmr(name, cls, typeof url === 'string' ? url : '');
+        }
+        catch (err) {
+            // Registration is best-effort — never break a user module load
+            // because of a registration failure.
+            diagLog(`registrar threw for ${name}: ${err?.message ?? err}`);
+        }
+    };
+    slot[REGISTRAR_INSTALLED_FLAG] = true;
+    bootLog('installAngularHmrComponentRegistrar installed global hook __NS_HMR_REGISTER_COMPONENT__');
+}
+/**
+ * Look up the freshest registered component class for a given name, or
+ * `undefined` if no match. HMR helpers (e.g. dialog restore) call this
+ * with the captured class's `.name` to find the live class after a
+ * reboot. Returns `undefined` in production builds because the registrar
+ * is never installed there.
+ */
+function getFreshComponentClass(name) {
+    if (!name)
+        return undefined;
+    const slot = globalThis;
+    const registry = slot[REGISTRY_KEY$1];
+    // Diagnostics: log every lookup with the resolved class id so the
+    // restore path can be cross-referenced against register emissions.
+    if (registry) {
+        const value = registry.get(name);
+        const diag = getDiag();
+        const classId = value && (typeof value === 'object' || typeof value === 'function') ? getClassId(diag, value) : '(none)';
+        const knownNames = registry.size;
+        diagLog(`getFreshComponentClass name=${name} found=${!!value} classId=${classId} registrySize=${knownNames}`);
+        return value;
+    }
+    diagLog(`getFreshComponentClass name=${name} found=false reason=no-registry`);
+    return undefined;
+}
+/**
+ * Look up the source URL (`import.meta.url`) recorded for a registered
+ * component. Used by HMR helpers that need to force a fresh import of
+ * a lazily-loaded module (e.g. modals whose static import chain doesn't
+ * walk the bootstrap path).
+ *
+ * Returns `undefined` if the name was never registered or if no URL was
+ * provided at registration time.
+ */
+function getRegisteredComponentUrl(name) {
+    if (!name)
+        return undefined;
+    const slot = globalThis;
+    const meta = slot[REGISTRY_META_KEY];
+    const entry = meta?.get(name);
+    return entry?.url || undefined;
+}
+/**
+ * Test/debug helper: clear all registered classes. Production callers
+ * never need this; the registry stays empty without the registrar.
+ */
+function clearAngularHmrClassRegistry() {
+    const slot = globalThis;
+    slot[REGISTRY_KEY$1] = undefined;
+    slot[REGISTRY_META_KEY] = undefined;
+    slot[REGISTRAR_INSTALLED_FLAG] = undefined;
+    slot[REGISTRAR_HOOK] = undefined;
+    // Also reset diag so test isolation isn't broken by counts leaking.
+    const diagSlot = globalThis;
+    diagSlot[DIAG_KEY] = undefined;
+}
+
+const REGISTRY_KEY = '__NS_HMR_EAGER_SERVICES__';
+const REGISTER_KEY = '__NS_REGISTER_HMR_EAGER_SERVICE__';
+/**
+ * Diagnostic helper.
+ */
+function eagerDiag(message) {
+    const g = globalThis;
+    const ngDev = (typeof g.ngDevMode === 'boolean') ? g.ngDevMode : true;
+    const viteHmr = !!g.__NS_DEV_PLACEHOLDER_ROOT_EARLY__ || !!g.__NS_HMR_BOOT_COMPLETE__;
+    if (!(ngDev && viteHmr))
+        return;
+    if (!NativeScriptDebug.isLogEnabled())
+        return;
+    NativeScriptDebug.hmrLog(`[eager] ${message}`);
+}
+function getStore() {
+    return globalThis;
+}
+/**
+ * Returns the live (mutable) array of registered eager instantiators.
+ * Callers must not mutate it directly outside of the helpers in this
+ * module — use {@link registerHmrEagerInstantiator} or
+ * {@link clearHmrEagerInstantiators} instead.
+ */
+function getRegisteredHmrEagerInstantiators() {
+    const store = getStore();
+    const list = store[REGISTRY_KEY];
+    if (!Array.isArray(list)) {
+        const fresh = [];
+        store[REGISTRY_KEY] = fresh;
+        return fresh;
+    }
+    return list;
+}
+/**
+ * Idempotently register an instantiator callback. Returns `true` when the
+ * callback was added, `false` when it was already present.
+ */
+function registerHmrEagerInstantiator(fn) {
+    if (typeof fn !== 'function') {
+        return false;
+    }
+    const list = getRegisteredHmrEagerInstantiators();
+    if (list.includes(fn)) {
+        eagerDiag(`registerHmrEagerInstantiator dedup (already present) listSize=${list.length}`);
+        return false;
+    }
+    list.push(fn);
+    eagerDiag(`registerHmrEagerInstantiator added newSize=${list.length} fnName=${fn.name || '(anon)'}`);
+    return true;
+}
+/**
+ * Clear all registered instantiators. Tests use this to reset state
+ * between specs; production code should not call it.
+ */
+function clearHmrEagerInstantiators() {
+    const list = getRegisteredHmrEagerInstantiators();
+    list.length = 0;
+}
+/**
+ * Install the cross-module registration entry point on `globalThis` so
+ * consumer modules (e.g. `dialog-services.ts`) can register without
+ * statically importing this file. Idempotent across multiple calls so
+ * application.ts can call it on every reboot without leaking state.
+ */
+function installHmrEagerRegistrar() {
+    const store = getStore();
+    if (typeof store[REGISTER_KEY] === 'function') {
+        return;
+    }
+    store[REGISTER_KEY] = (fn) => {
+        registerHmrEagerInstantiator(fn);
+    };
+}
+/**
+ * Invoke every registered instantiator with the bootstrapped injector.
+ * Per-callback exceptions are swallowed; pass `onError` to receive them
+ * for logging.
+ */
+function runHmrEagerInstantiators(injector, onError) {
+    if (!injector) {
+        eagerDiag(`runHmrEagerInstantiators called without injector — no-op`);
+        return;
+    }
+    const list = getRegisteredHmrEagerInstantiators();
+    eagerDiag(`runHmrEagerInstantiators list.length=${list.length}`);
+    if (list.length === 0) {
+        return;
+    }
+    for (let i = 0; i < list.length; i++) {
+        const fn = list[i];
+        try {
+            eagerDiag(`runHmrEagerInstantiators calling [${i}] ${fn.name || '(anon)'}`);
+            fn(injector);
+        }
+        catch (err) {
+            eagerDiag(`runHmrEagerInstantiators [${i}] threw: ${err?.message ?? err}`);
+            if (onError) {
+                try {
+                    onError(err);
+                }
+                catch {
+                    // The error reporter must not itself break the loop.
+                }
+            }
+        }
+    }
+}
+
 class NativeScriptLoadingService {
     constructor() {
         this.mainModuleReady$ = new BehaviorSubject(false);
@@ -356,64 +910,6 @@ function clearAngularHmrRouteConfigCaches(routes) {
     return cleared;
 }
 
-class NativeScriptDebug {
-    static { this.animationsTraceCategory = 'ns-animations'; }
-    static { this.rendererTraceCategory = 'ns-renderer'; }
-    static { this.viewUtilCategory = 'ns-view-util'; }
-    static { this.routerTraceCategory = 'ns-router'; }
-    static { this.routeReuseStrategyTraceCategory = 'ns-route-reuse-strategy'; }
-    static { this.listViewTraceCategory = 'ns-list-view'; }
-    static { this.bootstrapCategory = 'bootstrap'; }
-    static { this.hmrTraceCategory = 'ns-ng-hmr'; }
-    // TODO: migrate all usage to this - avoids extraneous method executions
-    static { this.enabled = Trace.isEnabled(); }
-    static isLogEnabled() {
-        return Trace.isEnabled();
-    }
-    static animationsLog(message) {
-        Trace.write(message, NativeScriptDebug.animationsTraceCategory);
-    }
-    static rendererLog(msg) {
-        Trace.write(msg, NativeScriptDebug.rendererTraceCategory);
-    }
-    static rendererError(message) {
-        Trace.write(message, NativeScriptDebug.rendererTraceCategory, Trace.messageType.error);
-    }
-    static viewUtilLog(msg) {
-        Trace.write(msg, NativeScriptDebug.viewUtilCategory);
-    }
-    static routerLog(message) {
-        Trace.write(message, NativeScriptDebug.routerTraceCategory);
-    }
-    static routerError(message) {
-        Trace.write(message, NativeScriptDebug.routerTraceCategory, Trace.messageType.error);
-    }
-    static routeReuseStrategyLog(message) {
-        Trace.write(message, NativeScriptDebug.routeReuseStrategyTraceCategory);
-    }
-    static styleError(message) {
-        Trace.write(message, Trace.categories.Style, Trace.messageType.error);
-    }
-    static listViewLog(message) {
-        Trace.write(message, NativeScriptDebug.listViewTraceCategory);
-    }
-    static listViewError(message) {
-        Trace.write(message, NativeScriptDebug.listViewTraceCategory, Trace.messageType.error);
-    }
-    static bootstrapLog(message) {
-        Trace.write(message, NativeScriptDebug.bootstrapCategory);
-    }
-    static bootstrapLogError(message) {
-        Trace.write(message, NativeScriptDebug.bootstrapCategory, Trace.messageType.error);
-    }
-    static hmrLog(message) {
-        Trace.write(message, NativeScriptDebug.hmrTraceCategory);
-    }
-    static hmrLogError(message) {
-        Trace.write(message, NativeScriptDebug.hmrTraceCategory, Trace.messageType.error);
-    }
-}
-
 class FrameService {
     // TODO: Add any methods that are needed to handle frame/page navigation
     getFrame() {
@@ -1457,13 +1953,43 @@ function createAngularRootTransitionGuard(globalObj = globalThis, timers = { set
 // This is crucial because HMR imports a fresh @angular/core with empty LView tracking
 // We need to use the original one that has the registered LViews
 rememberAngularCoreForHmr(i0, globalThis);
+// Install the cross-module HMR component registrar. The Vite plugin
+// `ns-component-hmr-register` injects a call to the global hook
+// `__NS_HMR_REGISTER_COMPONENT__` at the end of every user `.ts` file
+// that declares an `@Component`-decorated class. After an HMR reboot,
+// each re-evaluated module pushes its fresh class into the registry,
+// and HMR helpers (modal restore, route replay) read the registry via
+// `getFreshComponentClass` to re-attach to the *live* class instead of
+// a captured stale reference. Production short-circuits inside the
+// helper (the hook is never assigned).
+//
+// We install the registrar before any other module initialization can
+// reference the hook so a user module loaded synchronously alongside
+// `@nativescript/angular` always finds the function present.
+installAngularHmrComponentRegistrar();
+// Install the cross-module registration entry point used by HMR-aware
+// services (e.g. `NativeDialog`) to ask for eager construction after
+// every bootstrap. Idempotent: re-evaluations after HMR are no-ops.
+installHmrEagerRegistrar();
 const angularHmrGlobal = globalThis;
-angularHmrGlobal.__NS_REMEMBER_ANGULAR_CORE__ = (core) => setAngularCoreForHmr(core, angularHmrGlobal);
+angularHmrGlobal.__NS_REMEMBER_ANGULAR_CORE__ = (core) => {
+    setAngularCoreForHmr(core, angularHmrGlobal);
+};
 function disableRootViewHanding(view) {
     view.__disable_root_view_handling = true;
 }
 const preAngularDisposal$ = new Subject();
-const postAngularBootstrap$ = new Subject();
+/**
+ * Stream that emits when an Angular module finishes bootstrapping. Modeled
+ * as a `ReplaySubject(1)` so consumers (e.g. `NativeDialog`) instantiated
+ * lazily — *after* the bootstrap event has already fired — still receive
+ * the latest event and can react. Without buffering, a service that the
+ * user app injects on first need (after bootstrap) would silently miss the
+ * `hotreload` notification and skip HMR-only work like restoring captured
+ * modal state. The buffer size of 1 means each new HMR cycle replaces the
+ * cached event so cycle N's late subscribers don't see cycle N-1's event.
+ */
+const postAngularBootstrap$ = new ReplaySubject(1);
 /**
  * @deprecated
  */
@@ -1480,14 +2006,34 @@ if (import.meta['webpackHot']) {
     };
 }
 function emitModuleBootstrapEvent(ref, name, reason) {
+    if (NativeScriptDebug.isLogEnabled()) {
+        NativeScriptDebug.hmrLog(`emitModuleBootstrapEvent name=${name} reason=${reason}`);
+    }
+    // Instantiate registered HMR-aware services *before* emitting so they
+    // attach their subscriptions in the same JS task and are guaranteed to
+    // observe the event being emitted. `postAngularBootstrap$` is also a
+    // `ReplaySubject(1)`, so a service injected later still receives the
+    // buffered event — the eager pass is the fast path that lets the
+    // restore work begin in the same task as bootstrap completion.
+    if (name === 'main') {
+        runHmrEagerInstantiators(ref.injector, (err) => NativeScriptDebug.bootstrapLogError(`HMR eager instantiator threw: ${err?.message ?? err}`));
+    }
     postAngularBootstrap$.next({
         moduleType: name,
         reference: ref,
         reason,
     });
+    if (NativeScriptDebug.isLogEnabled()) {
+        NativeScriptDebug.hmrLog(`postAngularBootstrap$.next() emitted name=${name} reason=${reason}`);
+    }
 }
 function destroyRef(ref, name, reason) {
     if (ref) {
+        const refKind = ref instanceof PlatformRef ? 'PlatformRef' : ref instanceof NgModuleRef ? 'NgModuleRef' : ref instanceof ApplicationRef ? 'ApplicationRef' : '(unknown)';
+        const traceEnabled = NativeScriptDebug.isLogEnabled();
+        if (traceEnabled) {
+            NativeScriptDebug.hmrLog(`destroyRef kind=${refKind} name=${name ?? '(none)'} reason=${reason ?? '(none)'}`);
+        }
         if (ref instanceof PlatformRef) {
             preAngularDisposal$.next({
                 moduleType: 'platform',
@@ -1503,6 +2049,9 @@ function destroyRef(ref, name, reason) {
             });
         }
         ref.destroy();
+        if (traceEnabled) {
+            NativeScriptDebug.hmrLog(`destroyRef DONE kind=${refKind} name=${name ?? '(none)'}`);
+        }
     }
 }
 function runZoneSyncTask(fn) {
@@ -1985,9 +2534,14 @@ function runNativeScriptAngularApp(options) {
         disposePlatform('hotreload');
     };
     global['__reboot_ng_modules__'] = (shouldDisposePlatform = false) => {
+        // Bump the global HMR cycle counter so subsequent diagnostic log
+        // lines (class registry, dialog services) can be cross-referenced
+        // to a specific reboot. Counter is always incremented; the trace
+        // category gates whether we surface it in the console.
+        const cycleNum = _hmrDiagBumpCycle();
         const traceEnabled = NativeScriptDebug.isLogEnabled();
         if (traceEnabled) {
-            NativeScriptDebug.hmrLog(`__reboot_ng_modules__ called shouldDisposePlatform=${shouldDisposePlatform} bootstrapId=${bootstrapId} hasMainModuleRef=${!!mainModuleRef}`);
+            NativeScriptDebug.hmrLog(`__reboot_ng_modules__ called cycle=${cycleNum} shouldDisposePlatform=${shouldDisposePlatform} bootstrapId=${bootstrapId} hasMainModuleRef=${!!mainModuleRef}`);
         }
         try {
             global['__NS_CAPTURE_ANGULAR_HMR_ROUTE__']?.();
@@ -1995,17 +2549,17 @@ function runNativeScriptAngularApp(options) {
         catch { }
         disposeLastModules('hotreload');
         if (traceEnabled) {
-            NativeScriptDebug.hmrLog(`after disposeLastModules bootstrapId=${bootstrapId}`);
+            NativeScriptDebug.hmrLog(`after disposeLastModules cycle=${cycleNum} bootstrapId=${bootstrapId}`);
         }
         if (shouldDisposePlatform) {
             disposePlatform('hotreload');
         }
         if (traceEnabled) {
-            NativeScriptDebug.hmrLog('calling bootstrapRoot');
+            NativeScriptDebug.hmrLog(`calling bootstrapRoot cycle=${cycleNum}`);
         }
         bootstrapRoot('hotreload');
         if (traceEnabled) {
-            NativeScriptDebug.hmrLog(`bootstrapRoot returned bootstrapId=${bootstrapId}`);
+            NativeScriptDebug.hmrLog(`bootstrapRoot returned cycle=${cycleNum} bootstrapId=${bootstrapId}`);
         }
     };
     if (isWebpackHot) {
@@ -5530,6 +6084,22 @@ class NativeDialogConfig {
          */
         this.closeOnNavigation = true;
         this.nativeOptions = {};
+        /**
+         * When true, this dialog will be re-opened automatically on Angular HMR
+         * reboots so the user does not lose context every time a related file
+         * changes. The new dialog reuses the same component class and `data` payload
+         * (provided via `data`); other config such as `nativeOptions` is preserved
+         * verbatim.
+         *
+         * The original `dialogRef.afterClosed()` subject is wired to the restored
+         * dialog so consumers `await openModal(...)` resolve normally when the user
+         * eventually closes the restored modal.
+         *
+         * Only opens via component class are restorable — `TemplateRef` openings
+         * carry references that don't survive an HMR reboot and are silently
+         * skipped. Has no effect outside of HMR.
+         */
+        this.preserveOnHmr = false;
         // TODO(jelbourn): add configuration for lifecycle hooks, ARIA labelling.
     }
 }
@@ -5652,6 +6222,183 @@ class NativeDialogRef {
     }
 }
 
+const STASH_KEY = '__NS_ANGULAR_HMR_PENDING_MODALS__';
+function getStashSlot() {
+    return globalThis;
+}
+/**
+ * Pure helper: filter the open dialog list down to entries that opted in via
+ * `preserveOnHmr` and that we actually know how to restore (component-class
+ * openings, not template openings).
+ */
+function selectPreservableDialogs(openDialogs) {
+    return openDialogs.filter((dialog) => isPreservable(dialog));
+}
+function isPreservable(dialog) {
+    if (!dialog.config?.preserveOnHmr) {
+        return false;
+    }
+    return typeof dialog.componentClass === 'function';
+}
+/**
+ * Capture the open dialogs that opted into HMR preservation. Returns the
+ * captured entries so callers can correlate counts in their logs.
+ */
+function captureDialogsForHmr(openDialogs) {
+    const preservable = selectPreservableDialogs(openDialogs);
+    if (preservable.length === 0) {
+        clearPendingHmrDialogs();
+        return [];
+    }
+    const captures = preservable.map(({ ref, componentClass, config }) => {
+        const subject = readAfterClosedSubject(ref);
+        // Capture the source name now — the class reference itself becomes
+        // stale after the reboot, but the name is stable across realms and
+        // is what the post-reboot registry is keyed on.
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const componentName = componentClass?.name ?? '';
+        return {
+            // Asserted non-null in `isPreservable`.
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            componentClass: componentClass,
+            componentName,
+            config,
+            graftAfterClosed: (value) => {
+                if (!subject) {
+                    return;
+                }
+                try {
+                    if (!subject.closed) {
+                        subject.next(value);
+                        subject.complete();
+                    }
+                }
+                catch {
+                    // Swallow: the subject may have completed during dispose; nothing for us to do.
+                }
+            },
+        };
+    });
+    globalThis[STASH_KEY] = captures;
+    return captures;
+}
+/**
+ * Drain the pending captures. The caller (the new `NativeDialog`) is expected
+ * to re-open each entry and graft `afterClosed` back into the original
+ * subject.
+ */
+function consumePendingHmrDialogs() {
+    const slot = globalThis[STASH_KEY];
+    if (!Array.isArray(slot)) {
+        return [];
+    }
+    delete globalThis[STASH_KEY];
+    return slot.filter((entry) => !!entry && typeof entry.componentClass === 'function');
+}
+/**
+ * Remove the pending captures without restoring. Useful when a reboot happens
+ * for reasons other than module replacement (e.g. platform dispose) and we
+ * don't want stale modal state to leak into the next bootstrap.
+ */
+function clearPendingHmrDialogs() {
+    delete globalThis[STASH_KEY];
+}
+/**
+ * Test/debug helper: read the current stash without consuming it.
+ */
+function peekPendingHmrDialogs() {
+    const slot = globalThis[STASH_KEY];
+    return Array.isArray(slot) ? slot.slice() : [];
+}
+/**
+ * Reach into the dialog ref's private `_afterClosed` subject. We touch the
+ * private field intentionally — the ref class lives inside this package and
+ * we want HMR restore to be a feature of the dialog system rather than a
+ * reason to widen its public surface for everyone.
+ */
+function readAfterClosedSubject(ref) {
+    const candidate = ref._afterClosed;
+    if (!candidate || typeof candidate !== 'object') {
+        return undefined;
+    }
+    if (typeof candidate.next !== 'function') {
+        return undefined;
+    }
+    return candidate;
+}
+/**
+ * Used by the resume-side: if the stash references something that can no
+ * longer be opened (e.g. the component class is dead post-reload), we still
+ * need to release its consumers so awaited promises don't dangle forever.
+ */
+function abortCapturedDialog(captured) {
+    try {
+        captured.graftAfterClosed(undefined);
+    }
+    catch {
+        // Best-effort.
+    }
+}
+
+/**
+ * Best-effort animation helpers used by the dialog HMR layer to make
+ * the close + reopen round-trip feel like an in-place content refresh.
+ *
+ * They live in a tiny standalone module on purpose:
+ *
+ * - `dialog-services.ts` pulls in `@angular/core`, which Jest cannot
+ *   load in our spec runner without an extra ESM transform. By
+ *   keeping these helpers free of `@angular/core` we can unit-test
+ *   them in isolation (`dialog-hmr-animation.spec.ts`) while
+ *   `dialog-services.ts` re-exports them at the public API layer.
+ * - The helpers are inherently best-effort: a missing
+ *   `_nativeModalRef`, a frozen `_modalAnimatedOptions` stack, or a
+ *   future `NativeDialogConfig` shape change must never break HMR
+ *   restore — we just fall back to the original animated behavior.
+ */
+/**
+ * Mutate the top of `parentView._modalAnimatedOptions` to `false` for
+ * the given candidate so the imminent native close runs un-animated.
+ *
+ * iOS reads `_modalAnimatedOptions.slice(-1)[0]` when dismissing a
+ * modal (see core `view-common.ts` / `view/index.ios.ts`). The
+ * Angular dialog service only pushes one entry per open call, so the
+ * top entry is the exact flag that controls the dismiss we're about
+ * to trigger as part of the HMR root-view replacement.
+ */
+function suppressNativeCloseAnimation(candidate) {
+    if (!candidate.config?.preserveOnHmr) {
+        return;
+    }
+    try {
+        const modalRef = candidate.ref?._nativeModalRef;
+        const parentView = modalRef?.parentView;
+        const stack = parentView?._modalAnimatedOptions;
+        if (Array.isArray(stack) && stack.length > 0) {
+            stack[stack.length - 1] = false;
+        }
+    }
+    catch {
+        // Swallow: a missing `_nativeModalRef` / `_modalAnimatedOptions`
+        // is acceptable — we just lose the no-animation optimisation.
+    }
+}
+/**
+ * Build a `NativeDialogConfig` clone of `original` whose
+ * `nativeOptions.animated` is forced to `false`. Used when re-opening
+ * a captured modal so the open animation matches the suppressed
+ * close — together they make the HMR round-trip feel like a content
+ * refresh instead of a close/reopen.
+ */
+function buildNonAnimatedRestoreConfig(original) {
+    // Clone via `Object.assign` so consumers holding the original
+    // config (e.g. caching it for re-open) don't see mutations from
+    // the HMR pathway.
+    const cloned = Object.assign(new NativeDialogConfig(), original);
+    cloned.nativeOptions = { ...(original?.nativeOptions || {}), animated: false };
+    return cloned;
+}
+
 let NativeModalRef = class NativeModalRef {
     constructor(_config, _injector, location) {
         this._config = _config;
@@ -5786,6 +6533,54 @@ NativeModalRef = __decorate([
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
+/**
+ * Dialog HMR lifecycle log.
+ */
+function hmrDialogLog(message) {
+    if (!isAngularHmrEnabled()) {
+        return;
+    }
+    if (!NativeScriptDebug.isLogEnabled()) {
+        return;
+    }
+    NativeScriptDebug.hmrLog(`[dialog] ${message}`);
+}
+/**
+ * Lower-level dialog HMR wiring trace (module-realm count, NativeDialog
+ * instance count, registry hits/misses). Distinct from `hmrDialogLog`
+ * for greppability — both fan into the same Trace category so a single
+ * `Trace.setCategories(NativeScriptDebug.hmrTraceCategory)` toggle
+ * surfaces them all.
+ */
+function hmrDialogDiag(message) {
+    if (!isAngularHmrEnabled()) {
+        return;
+    }
+    if (!NativeScriptDebug.isLogEnabled()) {
+        return;
+    }
+    NativeScriptDebug.hmrLog(`[dialog-diag] ${message}`);
+}
+/**
+ * Module-evaluation marker. Increments on every fresh evaluation of
+ * `dialog-services.ts`. If we see this number rise on every HMR cycle,
+ * the file is being re-evaluated (good). If it stays flat, the module
+ * is being served from cache (bad — class identities won't change).
+ */
+const DIALOG_MODULE_DIAG_KEY = '__NS_HMR_DIAG_DIALOG_MODULE__';
+function getDialogModuleDiag() {
+    const slot = globalThis;
+    if (!slot[DIALOG_MODULE_DIAG_KEY]) {
+        slot[DIALOG_MODULE_DIAG_KEY] = { evals: 0, instances: 0, lastEvalAt: 0 };
+    }
+    return slot[DIALOG_MODULE_DIAG_KEY];
+}
+{
+    const md = getDialogModuleDiag();
+    md.evals += 1;
+    md.lastEvalAt = Date.now();
+    hmrDialogDiag(`module-eval count=${md.evals} (file=dialog-services.ts) timestamp=${md.lastEvalAt}`);
+}
 /** Injection token that can be used to access the data that was passed in to a dialog. */
 const NATIVE_DIALOG_DATA = new InjectionToken('NativeDialogData');
 /** Injection token that can be used to specify default dialog options. */
@@ -5799,6 +6594,14 @@ class NativeDialog {
         this._openDialogsAtThisLevel = [];
         this._afterAllClosedAtThisLevel = new Subject();
         this._afterOpenedAtThisLevel = new Subject();
+        /**
+         * Maps each open dialog ref back to the `(componentClass, config)` pair it
+         * was opened with so the HMR snapshot can replay the call later. Dialogs
+         * opened with a `TemplateRef` are tracked with `componentClass: undefined`
+         * — the HMR layer skips them automatically.
+         */
+        this._openDialogMetadata = new WeakMap();
+        this._hmrSubscriptions = [];
         // TODO (jelbourn): tighten the typing right-hand side of this expression.
         /**
          * Stream that emits when all open dialog have finished closing.
@@ -5816,6 +6619,50 @@ class NativeDialog {
         this._nativeModalType = NativeModalRef;
         this._dialogDataToken = NATIVE_DIALOG_DATA;
         this.locationStrategy = inject(NSLocationStrategy);
+        // Bumps a global counter so we can detect duplicate or leaked
+        // `NativeDialog` instances across HMR cycles. Field initialiser
+        // ordering: this MUST run before `_initHmrLifecycle()` below so the
+        // log line in that helper can include the assigned id.
+        this._diagInstanceIdAssign = (() => {
+            const md = getDialogModuleDiag();
+            md.instances += 1;
+            this._diagInstanceId = md.instances;
+            hmrDialogDiag(`NativeDialog ctor instanceId=${md.instances} hasParentDialog=${!!this._parentDialog} moduleEvalCount=${md.evals}`);
+            return null;
+        })();
+        // Initialise after every dependency above so the subscriptions can call
+        // back into `this.open(...)` and `this.openDialogs` safely. The result is
+        // unused — we just want a side-effect at construction time.
+        this._hmrInitMarker = this._initHmrLifecycle();
+        /**
+         * Tracks whether a restore has already been scheduled for this
+         * `NativeDialog` instance's lifetime. We only need to restore once
+         * per HMR cycle — the rxjs `ReplaySubject(1)` for
+         * `postAngularBootstrap$` delivers both the *previous* cycle's
+         * cached event (replay on subscribe) **and** the *current* cycle's
+         * fresh event, and the constructor stash peek can independently
+         * notice pending work. Without this guard each of those triggers
+         * would queue its own `setTimeout` and the logs would show two or
+         * three "scheduling restore" lines per save.
+         *
+         * The guard is per-instance and the stash itself is the source of
+         * truth: `_restorePendingDialogs` calls `consumePendingHmrDialogs()`
+         * which atomically clears the stash, so even if the guard somehow
+         * fired twice, only the first call would do real work.
+         */
+        this._restoreScheduledForThisInstance = false;
+        /**
+         * Per-cycle guard to keep `_restorePendingDialogs` idempotent if more
+         * than one subscriber fires for the same bootstrap event. The
+         * regression we have seen (`postAngularBootstrap$ → restore` logged
+         * twice in the same hot reload) was caused by the `NativeDialogModule`
+         * also listing `NativeDialog` in its `providers` array. That has been
+         * removed, but we keep this flag as a defensive net so a future stray
+         * subscription does not consume the stash twice. The flag is reset
+         * after the consume so subsequent HMR cycles can run their own
+         * restore.
+         */
+        this._restoreInFlight = false;
     }
     /** Keeps track of the currently-open dialogs. */
     get openDialogs() {
@@ -5825,42 +6672,363 @@ class NativeDialog {
     get afterOpened() {
         return this._parentDialog ? this._parentDialog.afterOpened : this._afterOpenedAtThisLevel;
     }
-    _getAfterAllClosed() {
-        const parent = this._parentDialog;
-        return parent ? parent._getAfterAllClosed() : this._afterAllClosedAtThisLevel;
+    _getAfterAllClosed() {
+        const parent = this._parentDialog;
+        return parent ? parent._getAfterAllClosed() : this._afterAllClosedAtThisLevel;
+    }
+    open(componentOrTemplateRef, config) {
+        config = _applyConfigDefaults(config, this._defaultOptions || new NativeDialogConfig());
+        if (config.id && this.getDialogById(config.id) && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+            throw Error(`Dialog with id "${config.id}" exists already. The dialog id must be unique.`);
+        }
+        const dialogRef = this._attachDialogContent(componentOrTemplateRef, config);
+        this.openDialogs.push(dialogRef);
+        this._openDialogMetadata.set(dialogRef, {
+            componentClass: componentOrTemplateRef instanceof TemplateRef ? undefined : componentOrTemplateRef,
+            config,
+        });
+        dialogRef.afterClosed().subscribe(() => this._removeOpenDialog(dialogRef));
+        this.afterOpened.next(dialogRef);
+        // Notify the dialog container that the content has been attached.
+        // dialogContainer._initializeWithAttachedContent();
+        return dialogRef;
+    }
+    /**
+     * Closes all of the currently-open dialogs.
+     */
+    closeAll() {
+        this._closeDialogs(this.openDialogs);
+    }
+    /**
+     * Finds an open dialog by its id.
+     * @param id ID to use when looking up the dialog.
+     */
+    getDialogById(id) {
+        return this.openDialogs.find((dialog) => dialog.id === id);
+    }
+    ngOnDestroy() {
+        hmrDialogDiag(`NativeDialog ngOnDestroy instanceId=${this._diagInstanceId} openCount=${this._openDialogsAtThisLevel.length} subCount=${this._hmrSubscriptions.length}`);
+        // Only close the dialogs at this level on destroy
+        // since the parent service may still be active.
+        this._closeDialogs(this._openDialogsAtThisLevel);
+        this._afterAllClosedAtThisLevel.complete();
+        this._afterOpenedAtThisLevel.complete();
+        for (const sub of this._hmrSubscriptions) {
+            try {
+                sub.unsubscribe();
+            }
+            catch {
+                // Best-effort: tearing down the dialog service shouldn't prevent the
+                // rest of the module disposal from completing.
+            }
+        }
+        this._hmrSubscriptions = [];
+    }
+    /**
+     * Wires up HMR capture/restore. Only the root-level dialog manages the
+     * stash so a stack of `NativeDialog` instances inside a child injector
+     * doesn't fight for it.
+     *
+     * Production short-circuit: `isAngularHmrEnabled()` returns `false` in
+     * release builds and when no NS Vite / webpack HMR runtime is present,
+     * so the long-lived subscriptions below never attach in shipping apps.
+     *
+     * `postAngularBootstrap$` is a `ReplaySubject(1)` (see `application.ts`)
+     * which means a `NativeDialog` instantiated *after* the bootstrap event
+     * has already fired (typical when the user app injects `NativeDialog`
+     * lazily via a service like `view.service.ts`) still receives the
+     * buffered event and runs the restore path.
+     */
+    _initHmrLifecycle() {
+        if (this._parentDialog) {
+            hmrDialogDiag(`_initHmrLifecycle skipped (has parent dialog) instanceId=${this._diagInstanceId}`);
+            return null;
+        }
+        if (!isAngularHmrEnabled()) {
+            return null;
+        }
+        hmrDialogDiag(`_initHmrLifecycle wiring up subscriptions instanceId=${this._diagInstanceId} moduleEvalCount=${getDialogModuleDiag().evals}`);
+        const dispose = preAngularDisposal$.subscribe((event) => {
+            if (event.moduleType !== 'main' || event.reason !== 'hotreload') {
+                return;
+            }
+            hmrDialogDiag(`preAngularDisposal$ fired (reason=${event.reason}) instanceId=${this._diagInstanceId}`);
+            this._captureOpenDialogsForHmr();
+        });
+        const bootstrap = postAngularBootstrap$.subscribe((event) => {
+            if (event.moduleType !== 'main' || event.reason !== 'hotreload') {
+                return;
+            }
+            hmrDialogDiag(`postAngularBootstrap$ fired (reason=${event.reason}) instanceId=${this._diagInstanceId}`);
+            this._maybeScheduleRestore(`postAngularBootstrap$ (reason=${event.reason})`);
+        });
+        this._hmrSubscriptions.push(dispose, bootstrap);
+        // Belt-and-suspenders: even though `postAngularBootstrap$` replays
+        // the last event for late subscribers, also peek the global stash
+        // here. This catches the case where `NativeDialog` is instantiated
+        // lazily — *after* `emitModuleBootstrapEvent` has fired and the
+        // ReplaySubject's buffered event no longer matches the current
+        // cycle. The `_maybeScheduleRestore` guard makes this a no-op when
+        // the bootstrap subscriber already queued work.
+        const pendingNow = peekPendingHmrDialogs();
+        hmrDialogDiag(`_initHmrLifecycle stash peek pending=${pendingNow.length} instanceId=${this._diagInstanceId}`);
+        if (pendingNow.length > 0) {
+            this._maybeScheduleRestore(`stash peek on ctor: ${pendingNow.length} pending dialog(s)`);
+        }
+        return null;
+    }
+    /**
+     * Schedule a restore exactly once per `NativeDialog` instance.
+     *
+     * The work is deferred to the next macrotask for two reasons:
+     *
+     *  1. `postAngularBootstrap$.next(...)` is fired from inside
+     *     `emitModuleBootstrapEvent`, which itself runs inside the
+     *     `bootstrapApplication` callback — so the call stack still
+     *     contains Angular's ApplicationRef bootstrap pipeline. Doing
+     *     `this.open(...)` synchronously re-entered Angular DI while a
+     *     `providedIn: 'root'` factory could still be on the resolution
+     *     stack, which surfaced as `NG0200: Circular dependency detected
+     *     for NativeDialog`. Yielding to a macrotask lets the bootstrap
+     *     stack fully unwind first.
+     *  2. The eventual `parent.showModal(...)` cannot present onto a
+     *     view controller whose view is not yet in the iOS window
+     *     hierarchy (see `_scheduleRestoreOpenWhenReady` for the second
+     *     wait stage); a synchronous attempt would silently no-op
+     *     because iOS rejects the present without throwing.
+     */
+    _maybeScheduleRestore(triggerDescription) {
+        if (this._restoreScheduledForThisInstance) {
+            hmrDialogDiag(`_maybeScheduleRestore SKIP duplicate trigger=${triggerDescription} instanceId=${this._diagInstanceId}`);
+            return;
+        }
+        this._restoreScheduledForThisInstance = true;
+        hmrDialogLog(`scheduling restore (trigger=${triggerDescription}) instanceId=${this._diagInstanceId}`);
+        setTimeout(() => {
+            void this._restorePendingDialogs();
+        }, 0);
+    }
+    _captureOpenDialogsForHmr() {
+        const candidates = this._openDialogsAtThisLevel.map((ref) => {
+            const meta = this._openDialogMetadata.get(ref);
+            return {
+                ref,
+                componentClass: meta?.componentClass,
+                config: meta?.config ?? new NativeDialogConfig(),
+            };
+        });
+        hmrDialogDiag(`_captureOpenDialogsForHmr instanceId=${this._diagInstanceId} candidates=${candidates.length} (${candidates.map((c) => `${c.componentClass?.name ?? '(template)'}|preserveOnHmr=${!!c.config?.preserveOnHmr}`).join(', ')})`);
+        const captured = captureDialogsForHmr(candidates);
+        if (captured.length > 0) {
+            // Suppress the close animation that's about to fire as part of
+            // `_closeAllModalViewsInternal()` during root-view replacement.
+            // Without this the user sees a slide-down + slide-up flicker
+            // wrapping every HMR reboot.
+            for (const candidate of candidates) {
+                suppressNativeCloseAnimation(candidate);
+            }
+            hmrDialogLog(`captured ${captured.length} dialog(s) for HMR restore [${captured.map((c) => c.componentName).join(', ')}]`);
+        }
+        else if (this._openDialogsAtThisLevel.length > 0) {
+            hmrDialogLog(`skipped capture: ${this._openDialogsAtThisLevel.length} open dialog(s) but none preservable`);
+        }
+        if (captured.length > 0 && NativeScriptDebug.isLogEnabled()) {
+            NativeScriptDebug.hmrLog(`captured ${captured.length} dialog(s) for HMR restore`);
+        }
     }
-    open(componentOrTemplateRef, config) {
-        config = _applyConfigDefaults(config, this._defaultOptions || new NativeDialogConfig());
-        if (config.id && this.getDialogById(config.id) && (typeof ngDevMode === 'undefined' || ngDevMode)) {
-            throw Error(`Dialog with id "${config.id}" exists already. The dialog id must be unique.`);
+    async _restorePendingDialogs() {
+        if (this._restoreInFlight) {
+            hmrDialogLog('skipping restore: already in flight');
+            return;
+        }
+        const pending = consumePendingHmrDialogs();
+        if (pending.length === 0) {
+            return;
+        }
+        this._restoreInFlight = true;
+        hmrDialogLog(`restoring ${pending.length} dialog(s) after reboot [${pending.map((c) => c.componentName).join(', ')}]`);
+        if (NativeScriptDebug.isLogEnabled()) {
+            NativeScriptDebug.hmrLog(`restoring ${pending.length} dialog(s) after HMR reboot`);
+        }
+        try {
+            for (const captured of pending) {
+                this._restoreSingleDialog(captured);
+            }
+        }
+        finally {
+            this._restoreInFlight = false;
         }
-        const dialogRef = this._attachDialogContent(componentOrTemplateRef, config);
-        this.openDialogs.push(dialogRef);
-        dialogRef.afterClosed().subscribe(() => this._removeOpenDialog(dialogRef));
-        this.afterOpened.next(dialogRef);
-        // Notify the dialog container that the content has been attached.
-        // dialogContainer._initializeWithAttachedContent();
-        return dialogRef;
     }
     /**
-     * Closes all of the currently-open dialogs.
+     * Resolve the freshest known class object for the captured component
+     * name and re-open the dialog through the normal `open` path, but
+     * only once the new root view is actually attached to the iOS window
+     * hierarchy.
+     *
+     * Why a class lookup at all: an HMR reboot calls
+     * `ɵresetCompiledComponents()` which clears each component's `ɵcmp`
+     * field but **leaves the class identity unchanged**. The patched
+     * `ɵɵdefineComponent` then re-registers the same class object under
+     * the same source name when Angular re-renders the component. A
+     * fresh-class lookup therefore returns either the same object the
+     * stash captured (most common) or, on the rare occasion that the
+     * source file's `@Component` decorator was re-evaluated into a brand
+     * new class object (e.g. the user added `@Component(...)` to a new
+     * exported symbol), the live one. Either way, a single check is
+     * enough — the previous retry schedule was a no-op in 100 % of
+     * observed cycles because the captured class IS the live class.
      */
-    closeAll() {
-        this._closeDialogs(this.openDialogs);
+    _restoreSingleDialog(captured) {
+        const live = getFreshComponentClass(captured.componentName);
+        const componentClass = live ?? captured.componentClass;
+        const usingFresh = !!live && live !== captured.componentClass;
+        // Detailed diagnostic to disambiguate the three reasons
+        // `usingFreshClass=false` could log:
+        //   1. liveDefined=false: the patched ɵɵdefineComponent never
+        //      registered a class for this name in the new realm. Most
+        //      likely cause: the component module was not re-evaluated
+        //      after the eviction (file not in `evictPaths`, or runtime
+        //      did not actually evict it).
+        //   2. liveDefined=true but live === captured: the file WAS
+        //      re-evaluated, but the registry still hands back the same
+        //      class object. This shouldn't happen post-reboot for a
+        //      truly fresh realm; if it does, the captured snapshot was
+        //      taken from the same realm that's now serving the live
+        //      class — i.e. the disposal path is not actually disposing
+        //      the old realm before the new one boots.
+        //   3. liveDefined=true and live !== captured: usingFresh path,
+        //      the registry IS doing its job. This is the success case.
+        const liveDefined = !!live;
+        const sameAsCapture = liveDefined && live === captured.componentClass;
+        hmrDialogDiag(`_restoreSingleDialog name=${captured.componentName} liveDefined=${liveDefined} sameAsCapture=${sameAsCapture} usingFresh=${usingFresh} capturedFnName=${captured.componentClass?.name ?? '(none)'} liveFnName=${live?.name ?? '(none)'}`);
+        this._scheduleRestoreOpenWhenReady(captured, componentClass, usingFresh);
     }
     /**
-     * Finds an open dialog by its id.
-     * @param id ID to use when looking up the dialog.
+     * Maximum time we'll wait for the new root view to attach to the
+     * iOS window before giving up and trying the open anyway. NS Vite's
+     * worst observed reboot-to-rootview-loaded gap is ~250 ms; one
+     * second leaves headroom for slower devices without leaving the
+     * captured dialog stuck in the stash if something genuinely goes
+     * wrong.
      */
-    getDialogById(id) {
-        return this.openDialogs.find((dialog) => dialog.id === id);
+    static { this._ROOT_VIEW_LOADED_TIMEOUT_MS = 1_000; }
+    /**
+     * Defer the actual `this.open(...)` call until the new root view's
+     * underlying iOS `UIViewController.view` is in the window hierarchy.
+     *
+     * iOS silently rejects `presentViewControllerAnimatedCompletion` if
+     * the parent controller's view is not yet attached to a `UIWindow`
+     * (see `view/index.ios.ts::_showNativeModalView`, which logs to
+     * `Trace` and returns without throwing). In dev that would surface
+     * as a vanished modal with no actionable error.
+     *
+     * NS marks a view as `isLoaded === true` from
+     * `UILayoutViewController.viewWillAppear`, which fires once iOS has
+     * decided to add the view to its window. Listening for the
+     * `loadedEvent` (one-shot) plus an extra macrotask gives UIKit a
+     * chance to finish window attachment before we present.
+     */
+    _scheduleRestoreOpenWhenReady(captured, componentClass, usingFresh) {
+        const rootView = Application.getRootView();
+        if (rootView && rootView.isLoaded) {
+            // Even when isLoaded is already true we yield once: a previous
+            // capture in the same hot reload cycle may have set isLoaded on
+            // the *outgoing* root view and a new root view is about to take
+            // over. A single setTimeout(0) gives `setWindowContent` a chance
+            // to finish swapping `win.rootViewController` before we try to
+            // present on top of it.
+            setTimeout(() => this._performRestoreOpen(captured, componentClass, usingFresh), 0);
+            return;
+        }
+        if (!rootView) {
+            // No root view at all yet — extremely unusual at this point in
+            // the bootstrap, but protect against it by polling. We use the
+            // same timeout budget as the loaded path.
+            this._pollForRootView(captured, componentClass, usingFresh, Date.now());
+            return;
+        }
+        hmrDialogLog(`restore ${captured.componentName} waiting for root view loadedEvent`);
+        let settled = false;
+        const onLoaded = () => {
+            if (settled)
+                return;
+            settled = true;
+            try {
+                rootView.off(View.loadedEvent, onLoaded);
+            }
+            catch {
+                // off may throw on stale view bindings; the `settled` flag
+                // already prevents a double-fire.
+            }
+            // Defer one tick after viewWillAppear so UIKit completes the
+            // actual window attachment (`view.window` is set during the
+            // view-controller transition that follows viewWillAppear).
+            setTimeout(() => this._performRestoreOpen(captured, componentClass, usingFresh), 0);
+        };
+        try {
+            rootView.once(View.loadedEvent, onLoaded);
+        }
+        catch {
+            // If the event subscription fails (ancient core builds), fall
+            // back to a tiny delay — better to attempt the open and have
+            // iOS log a benign trace than to leak the dialog stash.
+            setTimeout(() => onLoaded(), 50);
+        }
+        // Bound the wait so a never-loading root view can't permanently
+        // pin the captured dialog in the stash.
+        setTimeout(() => {
+            if (settled)
+                return;
+            hmrDialogLog(`restore ${captured.componentName} root view never loaded within ${NativeDialog._ROOT_VIEW_LOADED_TIMEOUT_MS}ms; attempting open anyway`);
+            onLoaded();
+        }, NativeDialog._ROOT_VIEW_LOADED_TIMEOUT_MS);
+    }
+    _pollForRootView(captured, componentClass, usingFresh, startedAt) {
+        const rootView = Application.getRootView();
+        if (rootView) {
+            this._scheduleRestoreOpenWhenReady(captured, componentClass, usingFresh);
+            return;
+        }
+        if (Date.now() - startedAt > NativeDialog._ROOT_VIEW_LOADED_TIMEOUT_MS) {
+            hmrDialogLog(`restore ${captured.componentName} aborted: no root view after ${NativeDialog._ROOT_VIEW_LOADED_TIMEOUT_MS}ms`);
+            abortCapturedDialog(captured);
+            return;
+        }
+        setTimeout(() => this._pollForRootView(captured, componentClass, usingFresh, startedAt), 16);
     }
-    ngOnDestroy() {
-        // Only close the dialogs at this level on destroy
-        // since the parent service may still be active.
-        this._closeDialogs(this._openDialogsAtThisLevel);
-        this._afterAllClosedAtThisLevel.complete();
-        this._afterOpenedAtThisLevel.complete();
+    _performRestoreOpen(captured, componentClass, usingFresh) {
+        hmrDialogLog(`restore ${captured.componentName} usingFreshClass=${usingFresh}`);
+        if (NativeScriptDebug.isLogEnabled() && usingFresh) {
+            NativeScriptDebug.hmrLog(`HMR modal restore using fresh class for ${captured.componentName}`);
+        }
+        // Force the restored modal to open without animation so the round-
+        // trip looks like an instant content refresh rather than a full
+        // close-and-reopen sequence.
+        const restoreConfig = buildNonAnimatedRestoreConfig(captured.config);
+        try {
+            const newRef = this.open(componentClass, restoreConfig);
+            hmrDialogLog(`restore ${captured.componentName} → opened newRef.id=${newRef?.id ?? 'n/a'}`);
+            newRef.afterClosed().subscribe({
+                next: (value) => captured.graftAfterClosed(value),
+                complete: () => captured.graftAfterClosed(undefined),
+            });
+        }
+        catch (err) {
+            abortCapturedDialog(captured);
+            const message = err?.message ?? String(err);
+            hmrDialogLog(`restore ${captured.componentName} FAILED: ${message}`);
+            if (NativeScriptDebug.isLogEnabled()) {
+                NativeScriptDebug.hmrLogError(`HMR modal restore failed: ${message}`);
+            }
+        }
+    }
+    /**
+     * Test/debug helper: discard any captured modals without restoring them.
+     * Mostly useful when projects want to opt out of restoration without
+     * recompiling. Public callers should prefer `preserveOnHmr: false` instead.
+     */
+    static _clearPendingHmrDialogs() {
+        clearPendingHmrDialogs();
     }
     /**
      * Attaches the user-provided component to the already-created dialog container.
@@ -5925,6 +7093,7 @@ class NativeDialog {
         const index = this.openDialogs.indexOf(dialogRef);
         if (index > -1) {
             this.openDialogs.splice(index, 1);
+            this._openDialogMetadata.delete(dialogRef);
             // If all the dialogs were closed, remove/restore the `aria-hidden`
             // to a the siblings and emit to the `afterAllClosed` stream.
             if (!this.openDialogs.length) {
@@ -5961,6 +7130,41 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.9", ngImpor
 function _applyConfigDefaults(config, defaultOptions) {
     return { ...defaultOptions, ...config };
 }
+/**
+ * Register `NativeDialog` with the application's HMR eager-instantiate
+ * registry so the post-bootstrap pipeline forces an `injector.get()` on
+ * the service in the same JS task as the bootstrap event. Without this,
+ * `NativeDialog` is only constructed when something in user-app code
+ * injects it (typically a wrapper service that opens modals). When that
+ * injection happens lazily — on first user-driven modal open — captured
+ * dialogs from a prior HMR cycle wait until the user reopens *something*
+ * before the new realm even sees the stash. Eager instantiation makes
+ * the restore work happen as early as possible during a hot reload while
+ * staying gated to dev mode + HMR-active environments.
+ *
+ * Registered after the class declaration so the closure references the
+ * fully-defined class rather than tripping the temporal dead zone.
+ *
+ * Idempotent: the registry de-dupes function references, so multiple
+ * evaluations of this module across HMR cycles never accumulate stale
+ * registrations.
+ */
+if (isAngularHmrEnabled()) {
+    const added = registerHmrEagerInstantiator((injector) => {
+        try {
+            const inst = injector.get(NativeDialog, null);
+            hmrDialogDiag(`eager-instantiator fired NativeDialog=${inst ? `instance#${inst._diagInstanceId}` : 'null'}`);
+        }
+        catch (err) {
+            hmrDialogDiag(`eager-instantiator threw: ${err?.message ?? err}`);
+            // Some user-app providers may not include `NativeDialog` (e.g. a
+            // module that doesn't depend on the dialog feature). The registry
+            // contract is "best effort": failing to find the token must be a
+            // silent no-op so unrelated apps aren't penalized.
+        }
+    });
+    hmrDialogDiag(`registerHmrEagerInstantiator added=${added} (false means already present in registry)`);
+}
 
 /**
  * @license
@@ -6036,17 +7240,42 @@ function getClosestDialog(element, openDialogs) {
     return view ? openDialogs.find((dialog) => dialog.id === view['__ng_modal_id__']) : null;
 }
 
+/**
+ * Convenience module that re-exports the `NativeDialogCloseDirective` for
+ * template-driven `[nativeDialogClose]` usage.
+ *
+ * **Important**: `NativeDialog` itself is **not** listed in this module's
+ * `providers` array. The service is `@Injectable({ providedIn: 'root' })`,
+ * which already registers a single root-level instance and is fully
+ * tree-shakeable. Listing it here as well caused Angular to treat the
+ * module-level provider and the `providedIn: 'root'` factory as
+ * *separate* registrations once the module was pulled into a standalone
+ * app via `importProvidersFrom(NativeDialogModule, ...)`. The duplicate
+ * registration triggered:
+ *
+ *  - Two `NativeDialog` instances in the same root environment injector,
+ *    each subscribing to `postAngularBootstrap$`, which produced
+ *    duplicate restore attempts during HMR.
+ *  - `NG0200: Circular dependency detected for NativeDialog` while a
+ *    captured modal was being re-opened during HMR restore, because the
+ *    second resolution started while the first was still in progress.
+ *
+ * Removing the redundant entry collapses both providers back into a
+ * single root-level instance, which is what `providedIn: 'root'`
+ * documents. App authors who explicitly wire `NativeDialog` themselves
+ * (e.g. in a feature module's `providers`) keep working unchanged
+ * because they're targeting the same class symbol.
+ */
 class NativeDialogModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.9", ngImport: i0, type: NativeDialogModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.0.9", ngImport: i0, type: NativeDialogModule, imports: [NativeDialogCloseDirective], exports: [NativeDialogCloseDirective] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.0.9", ngImport: i0, type: NativeDialogModule, providers: [NativeDialog] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.0.9", ngImport: i0, type: NativeDialogModule }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.9", ngImport: i0, type: NativeDialogModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [NativeDialogCloseDirective],
                     exports: [NativeDialogCloseDirective],
-                    providers: [NativeDialog],
                 }]
         }] });
 
@@ -7925,9 +9154,37 @@ function cloneRoutesForBootstrap(routes) {
 const CURRENT_ROUTE_KEY = '__NS_ANGULAR_HMR_CURRENT_ROUTE__';
 const PENDING_START_PATH_KEY = '__NS_ANGULAR_HMR_PENDING_START_PATH__';
 const CAPTURE_ROUTE_KEY = '__NS_CAPTURE_ANGULAR_HMR_ROUTE__';
+// Stack of normalized URLs that mirrors Angular Router's back-stack while the
+// app is running, and is snapshotted into `PENDING_HISTORY_KEY` when an HMR
+// reboot is about to fire. After the new module bootstraps, the router replay
+// hook walks the stack to rebuild the back-stack so users keep their back
+// navigation across HMR cycles.
+const HISTORY_KEY = '__NS_ANGULAR_HMR_ROUTE_HISTORY__';
+const PENDING_HISTORY_KEY = '__NS_ANGULAR_HMR_PENDING_HISTORY__';
+// Window flag set while the new bootstrap is mid-replay of a captured route
+// stack. User-app code can consult this to skip default navigations that
+// would otherwise stomp the route the framework is restoring (e.g. a
+// bottom-nav component that defaults to its first tab on init when no
+// signal-backed selection exists).
+const RESTORING_KEY = '__NS_ANGULAR_HMR_RESTORING_ROUTE__';
+const RESTORING_TARGET_KEY = '__NS_ANGULAR_HMR_RESTORING_ROUTE_TARGET__';
 function getGlobalState() {
     return globalThis;
 }
+function readHistoryArray(key) {
+    const g = getGlobalState();
+    const raw = g[key];
+    return Array.isArray(raw) ? raw.filter((entry) => typeof entry === 'string') : [];
+}
+function writeHistoryArray(key, history) {
+    const g = getGlobalState();
+    if (history.length > 0) {
+        g[key] = history.slice();
+    }
+    else {
+        delete g[key];
+    }
+}
 function normalizeAngularHmrRouteUrl(value) {
     if (typeof value !== 'string') {
         return null;
@@ -7965,8 +9222,31 @@ function captureAngularHmrPendingStartPath(value, source = 'hmr-reboot') {
     return writeAngularHmrRouteState(value, { pending: true, source });
 }
 function readAngularHmrPendingStartPath() {
+    // When a back-stack snapshot exists we boot to the bottom of the stack and
+    // let `replayAngularHmrPendingForwardNavigations` walk the rest. Otherwise
+    // fall back to the legacy single-URL slot so projects without history
+    // tracking still land on the page they were viewing.
+    const pendingHistory = readHistoryArray(PENDING_HISTORY_KEY);
+    if (pendingHistory.length > 0) {
+        // Open the restoring-route window so user-app default navigations
+        // can step out of the framework's way until replay completes. The
+        // forward-navigation walk in `NativeScriptAngularHmrRouteReplay`
+        // closes the window after the final URL lands or fails. We pass
+        // the deepest captured URL so consumers can compare against the
+        // active router URL if they want fine-grained suppression.
+        beginAngularHmrRouteRestore(pendingHistory[pendingHistory.length - 1]);
+        return pendingHistory[0];
+    }
     const g = getGlobalState();
-    return normalizeAngularHmrRouteUrl(g[PENDING_START_PATH_KEY]?.url ?? g[PENDING_START_PATH_KEY]) || '';
+    const fallback = normalizeAngularHmrRouteUrl(g[PENDING_START_PATH_KEY]?.url ?? g[PENDING_START_PATH_KEY]) || '';
+    if (fallback) {
+        // Single-URL fallback path: user-app code should still suppress
+        // default navigations briefly — the new bootstrap is about to
+        // navigate to `fallback`, so a default tab init that fires first
+        // would still stomp it.
+        beginAngularHmrRouteRestore(fallback);
+    }
+    return fallback;
 }
 function invokeAngularHmrRouteCapture() {
     const g = getGlobalState();
@@ -7990,20 +9270,402 @@ function installAngularHmrRouteCaptureHook(capture) {
         }
     };
 }
+// ---- back-stack history primitives ------------------------------------------
+/**
+ * Push a URL onto the live back-stack mirror. The mirror is collapsed when the
+ * incoming URL equals the top — Angular fires multiple `NavigationEnd` events
+ * for the same URL during certain `replaceUrl` scenarios and we don't want to
+ * inflate the stack.
+ */
+function pushAngularHmrRouteHistoryEntry(value) {
+    const url = normalizeAngularHmrRouteUrl(value);
+    if (!url) {
+        return null;
+    }
+    const history = readHistoryArray(HISTORY_KEY);
+    if (history.length > 0 && history[history.length - 1] === url) {
+        return url;
+    }
+    history.push(url);
+    writeHistoryArray(HISTORY_KEY, history);
+    return url;
+}
+/**
+ * Pop the top of the live back-stack mirror. Used when Angular reports a
+ * `popstate`-triggered navigation so the mirror tracks back navigations.
+ */
+function popAngularHmrRouteHistoryEntry() {
+    const history = readHistoryArray(HISTORY_KEY);
+    if (history.length === 0) {
+        return null;
+    }
+    const popped = history.pop() ?? null;
+    writeHistoryArray(HISTORY_KEY, history);
+    return popped;
+}
+/**
+ * Replace the top of the live back-stack mirror. Used when Angular reports a
+ * `NavigationEnd` with `replaceUrl=true`, e.g. canonical-redirect cycles.
+ */
+function replaceAngularHmrRouteHistoryTop(value) {
+    const url = normalizeAngularHmrRouteUrl(value);
+    if (!url) {
+        return null;
+    }
+    const history = readHistoryArray(HISTORY_KEY);
+    if (history.length === 0) {
+        history.push(url);
+    }
+    else {
+        history[history.length - 1] = url;
+    }
+    writeHistoryArray(HISTORY_KEY, history);
+    return url;
+}
+/**
+ * Read a defensive copy of the live back-stack mirror.
+ */
+function readAngularHmrRouteHistory() {
+    return readHistoryArray(HISTORY_KEY);
+}
+/**
+ * Reset the live back-stack mirror. Used by tests and on bootstrap when the
+ * router cannot replay the captured stack so we don't carry stale entries
+ * forward.
+ */
+function clearAngularHmrRouteHistory() {
+    const g = getGlobalState();
+    delete g[HISTORY_KEY];
+}
+/**
+ * Snapshot the live back-stack mirror under the pending-history slot so the
+ * next bootstrap can read it. Called from the HMR capture hook.
+ *
+ * The live mirror is cleared after the copy so the freshly bootstrapped app
+ * starts from an empty back-stack. The replay walks the captured snapshot
+ * via `NativeScriptAngularHmrRouteReplay` which fires `NavigationEnd` for
+ * every URL it touches; the new tracker subscribes to those events and
+ * naturally rebuilds the live mirror to match the snapshot. Without this
+ * reset the live mirror would accumulate every URL the replay re-pushes
+ * across HMR cycles, growing without bound and turning subsequent snapshots
+ * into runaway forward-navigation walks (each replayed forward nav from
+ * `/profile` back into `/talk` creates a fresh `TalkComponent` because
+ * forward navigation never reuses the cache, so the leak shows up as
+ * duplicated `Norrix is not enabled` / `BottomNavComponent Router Event:`
+ * lines that double on every save).
+ *
+ * Returns the snapshot for diagnostics. Defensive: an empty live mirror
+ * leaves the pending slot untouched so a single-page snapshot still works.
+ */
+function snapshotAngularHmrRouteHistory() {
+    const live = readHistoryArray(HISTORY_KEY);
+    if (live.length === 0) {
+        return [];
+    }
+    writeHistoryArray(PENDING_HISTORY_KEY, live);
+    // Clear the live mirror so the next bootstrap starts from a clean slate.
+    // The replay will repopulate it via the new tracker's NavigationEnd
+    // subscription as it walks the captured stack.
+    writeHistoryArray(HISTORY_KEY, []);
+    return live.slice();
+}
+/**
+ * Read the snapshotted back-stack pending replay on the new bootstrap.
+ */
+function readAngularHmrPendingRouteHistory() {
+    return readHistoryArray(PENDING_HISTORY_KEY);
+}
+/**
+ * Read URLs to navigate forward through after the initial navigation finishes.
+ * The first entry of the stack is the `START_PATH` consumed by the router; the
+ * rest are forward navigations to push onto the new back-stack.
+ */
+function readAngularHmrPendingForwardNavigations() {
+    const pending = readHistoryArray(PENDING_HISTORY_KEY);
+    if (pending.length <= 1) {
+        return [];
+    }
+    return pending.slice(1);
+}
+/**
+ * Clear the pending snapshot. The router replay calls this once it finishes
+ * walking the stack so subsequent reboots start fresh.
+ */
+function clearAngularHmrPendingRouteHistory() {
+    const g = getGlobalState();
+    delete g[PENDING_HISTORY_KEY];
+}
+// ---- restoring-route window flag --------------------------------------------
+/**
+ * True while the Angular HMR layer is restoring a captured route stack
+ * onto the freshly-bootstrapped router. The window opens just before
+ * `START_PATH` resolves to a deep URL and closes once the router has
+ * walked the entire forward navigation list (or aborted it).
+ *
+ * User-app code that runs default navigations on component init (e.g. a
+ * bottom-nav defaulting to its first tab) can consult this flag to skip
+ * its default navigation so the framework's restored route survives:
+ *
+ * ```ts
+ * if (isAngularHmrRestoringRoute()) {
+ *   return; // framework is restoring a deeper route — leave it alone.
+ * }
+ * defaultTabNavigation();
+ * ```
+ *
+ * Returns `false` outside of HMR or after the replay window has closed.
+ * Production builds always see `false` because the framework never
+ * opens the window there.
+ */
+function isAngularHmrRestoringRoute() {
+    const g = getGlobalState();
+    return g[RESTORING_KEY] === true;
+}
+/**
+ * The target route the framework is currently restoring, or `null` when
+ * no replay is in progress. Useful when the consumer wants to compare
+ * against the current router URL.
+ */
+function getAngularHmrRestoringRoute() {
+    const g = getGlobalState();
+    const value = g[RESTORING_TARGET_KEY];
+    return typeof value === 'string' && value ? value : null;
+}
+/**
+ * Open the restoring-route window. Called by the framework when an HMR
+ * bootstrap is about to navigate to a captured deep route — never call
+ * this from user code.
+ *
+ * `targetUrl` is what the framework intends to land on; the value can
+ * be read back via {@link getAngularHmrRestoringRoute}.
+ */
+function beginAngularHmrRouteRestore(targetUrl) {
+    const g = getGlobalState();
+    g[RESTORING_KEY] = true;
+    if (targetUrl) {
+        g[RESTORING_TARGET_KEY] = targetUrl;
+    }
+    else {
+        delete g[RESTORING_TARGET_KEY];
+    }
+}
+/**
+ * Close the restoring-route window. Called by the framework when the
+ * replay finishes (NavigationEnd reached, replay aborted, or no
+ * pending stack existed in the first place).
+ */
+function endAngularHmrRouteRestore() {
+    const g = getGlobalState();
+    delete g[RESTORING_KEY];
+    delete g[RESTORING_TARGET_KEY];
+}
+
+/**
+ * Grace period to keep `isAngularHmrRestoringRoute()` returning `true`
+ * after `replayForwardNavigations()` finishes its last `navigateByUrl`.
+ *
+ * Why a grace period exists: NativeScript native views (TabView, BottomNavigation,
+ * Frame, etc.) fire their `loaded` events asynchronously after the JS-side
+ * `NavigationEnd`. User-app code wired to those events typically guards a
+ * default navigation (e.g. "select first tab") with `isAngularHmrRestoringRoute()`.
+ * If we close the window the instant the JS replay finishes, the loaded
+ * event arrives a few hundred milliseconds later, the guard reports false,
+ * and the default navigation stomps the freshly-restored route.
+ *
+ * 1000ms covers all the cases observed on iOS device + simulator without
+ * leaving the window open long enough to interfere with genuine user
+ * navigation. The fallback timeout (`fallback-timeout`) below is a safety
+ * net for scenarios where this scheduled close never fires.
+ */
+const REPLAY_COMPLETED_GRACE_MS = 1000;
+/**
+ * Replays the back-stack snapshot captured by `NativeScriptAngularHmrRouteTracker`
+ * during HMR. The router's initial navigation already lands on the bottom of
+ * the stack (`stack[0]`); this service walks `stack[1..n]` so the user keeps
+ * back navigation across HMR cycles.
+ *
+ * The replay is single-shot per bootstrap. Any failure (cancelled navigation,
+ * unrouteable URL) aborts the rest of the replay so we don't fight the router
+ * — the user keeps whichever subset of the stack we successfully re-pushed.
+ */
+class NativeScriptAngularHmrRouteReplay {
+    constructor(router) {
+        this.router = router;
+        if (!isAngularHmrEnabled()) {
+            return;
+        }
+        const forwardNavigations = readAngularHmrPendingForwardNavigations();
+        // The restoring window is opened by `readAngularHmrPendingStartPath()`
+        // when `START_PATH` resolves to a deep route. If that path resolved
+        // to nothing AND we have no forward navigations, there is nothing
+        // to suppress and we must close the window if it was somehow left
+        // open. Otherwise we keep it open until replay finishes.
+        const restoringWindowOpen = isAngularHmrRestoringRoute();
+        if (forwardNavigations.length === 0) {
+            // Nothing to replay; clear the pending slot so a future navigation that
+            // ends in the bootstrap window doesn't carry the snapshot forward.
+            clearAngularHmrPendingRouteHistory();
+            if (restoringWindowOpen) {
+                // Single-URL restore (no back-stack to walk): keep the window
+                // open until the initial navigation completes so user-app
+                // default navigations don't fire before the framework's
+                // restored URL settles. We then schedule the close with the
+                // same grace period as the multi-URL replay path so async
+                // native `loaded` handlers still see the flag.
+                this.subscription = this.router.events
+                    .pipe(filter((event) => event instanceof NavigationEnd || event instanceof NavigationCancel || event instanceof NavigationError), take(1))
+                    .subscribe(() => this.scheduleRestoringWindowClose('initial-navigation-settled'));
+                // Belt-and-braces: bootstrap can race with router init in
+                // unusual cases. Close the window after a short timeout so we
+                // never leave it stuck open and silently breaking default
+                // navigations forever.
+                this.windowFallbackTimeout = setTimeout(() => this.closeRestoringWindow('fallback-timeout'), 5000);
+            }
+            return;
+        }
+        if (NativeScriptDebug.isLogEnabled()) {
+            NativeScriptDebug.hmrLog(`HMR back-stack replay queued: ${forwardNavigations.length} forward navigation(s)`);
+        }
+        this.subscription = this.router.events
+            .pipe(filter((event) => event instanceof NavigationEnd || event instanceof NavigationCancel || event instanceof NavigationError), take(1))
+            .subscribe((event) => {
+            if (event instanceof NavigationEnd) {
+                void this.replayForwardNavigations(forwardNavigations);
+            }
+            else {
+                // Initial navigation never landed; replay would compound the problem.
+                clearAngularHmrPendingRouteHistory();
+                this.closeRestoringWindow('initial-navigation-failed');
+                if (NativeScriptDebug.isLogEnabled()) {
+                    NativeScriptDebug.hmrLog('HMR back-stack replay skipped: initial navigation did not complete');
+                }
+            }
+        });
+        // Same belt-and-braces fallback as the single-URL path above.
+        this.windowFallbackTimeout = setTimeout(() => this.closeRestoringWindow('fallback-timeout'), 10000);
+    }
+    ngOnDestroy() {
+        this.subscription?.unsubscribe();
+        if (this.windowFallbackTimeout !== undefined) {
+            clearTimeout(this.windowFallbackTimeout);
+            this.windowFallbackTimeout = undefined;
+        }
+        if (this.pendingCloseTimeout !== undefined) {
+            clearTimeout(this.pendingCloseTimeout);
+            this.pendingCloseTimeout = undefined;
+        }
+        // Defensive: never leave the restoring window open across module
+        // destruction. A subsequent reboot would otherwise see it set and
+        // suppress the next default navigation indefinitely.
+        this.closeRestoringWindow('replay-service-destroyed');
+    }
+    closeRestoringWindow(reason) {
+        if (this.pendingCloseTimeout !== undefined) {
+            clearTimeout(this.pendingCloseTimeout);
+            this.pendingCloseTimeout = undefined;
+        }
+        if (!isAngularHmrRestoringRoute()) {
+            return;
+        }
+        endAngularHmrRouteRestore();
+        if (this.windowFallbackTimeout !== undefined) {
+            clearTimeout(this.windowFallbackTimeout);
+            this.windowFallbackTimeout = undefined;
+        }
+        if (NativeScriptDebug.isLogEnabled()) {
+            NativeScriptDebug.hmrLog(`HMR restoring-route window closed (${reason})`);
+        }
+    }
+    /**
+     * Schedule the restoring window to close after a small grace period
+     * so that asynchronous user-app handlers (e.g. NativeScript native
+     * `loaded` events on TabView / BottomNavigation / Frame) still observe
+     * `isAngularHmrRestoringRoute() === true` and skip default navigations
+     * that would otherwise stomp the freshly-restored route.
+     *
+     * The grace period is bounded by the existing `fallback-timeout` so
+     * we never leave the flag set indefinitely even if `setTimeout` is
+     * blocked by a misbehaving consumer.
+     */
+    scheduleRestoringWindowClose(reason) {
+        if (!isAngularHmrRestoringRoute()) {
+            return;
+        }
+        if (this.pendingCloseTimeout !== undefined) {
+            clearTimeout(this.pendingCloseTimeout);
+        }
+        this.pendingCloseTimeout = setTimeout(() => {
+            this.pendingCloseTimeout = undefined;
+            this.closeRestoringWindow(reason);
+        }, REPLAY_COMPLETED_GRACE_MS);
+    }
+    async replayForwardNavigations(urls) {
+        let aborted = false;
+        try {
+            for (const url of urls) {
+                const succeeded = await this.router.navigateByUrl(url).catch(() => false);
+                if (!succeeded) {
+                    aborted = true;
+                    if (NativeScriptDebug.isLogEnabled()) {
+                        NativeScriptDebug.hmrLog(`HMR back-stack replay aborted at ${url}`);
+                    }
+                    return;
+                }
+                if (NativeScriptDebug.isLogEnabled()) {
+                    NativeScriptDebug.hmrLog(`HMR back-stack replay navigated to ${url}`);
+                }
+            }
+        }
+        finally {
+            clearAngularHmrPendingRouteHistory();
+            this.scheduleRestoringWindowClose(aborted ? 'replay-aborted' : 'replay-completed');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.9", ngImport: i0, type: NativeScriptAngularHmrRouteReplay, deps: [{ token: i1$3.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.9", ngImport: i0, type: NativeScriptAngularHmrRouteReplay }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.9", ngImport: i0, type: NativeScriptAngularHmrRouteReplay, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1$3.Router }] });
 
 class NativeScriptAngularHmrRouteTracker {
     constructor(router) {
         this.router = router;
-        if (!this.isHmrEnabled()) {
+        // Tracks whether the current `NavigationStart..NavigationEnd` pair was kicked
+        // off by a popstate (frame.goBack / NSLocationStrategy.back) so that on
+        // `NavigationEnd` we can pop our mirror instead of pushing a duplicate entry.
+        this.currentNavigationIsPopstate = false;
+        this.currentNavigationReplaceUrl = false;
+        if (!isAngularHmrEnabled()) {
             return;
         }
         this.disposeCaptureHook = this.installCaptureHook();
         this.captureCurrentRoute('bootstrap');
         this.subscription = this.router.events.subscribe((event) => {
+            if (event instanceof NavigationStart) {
+                this.currentNavigationIsPopstate = event.navigationTrigger === 'popstate';
+                this.currentNavigationReplaceUrl = !!event.restoredState;
+                return;
+            }
             if (event instanceof NavigationEnd) {
-                writeAngularHmrRouteState(event.urlAfterRedirects || event.url, {
+                const url = event.urlAfterRedirects || event.url;
+                writeAngularHmrRouteState(url, {
                     source: 'navigation-end',
                 });
+                if (this.currentNavigationIsPopstate) {
+                    // The user (or NSLocationStrategy.back()) walked the back-stack down
+                    // by one page; mirror that by dropping the top of our snapshot so a
+                    // subsequent HMR reboot doesn't carry the popped page back into view.
+                    popAngularHmrRouteHistoryEntry();
+                }
+                else if (this.currentNavigationReplaceUrl) {
+                    replaceAngularHmrRouteHistoryTop(url);
+                }
+                else {
+                    pushAngularHmrRouteHistoryEntry(url);
+                }
+                this.currentNavigationIsPopstate = false;
+                this.currentNavigationReplaceUrl = false;
             }
         });
     }
@@ -8012,6 +9674,32 @@ class NativeScriptAngularHmrRouteTracker {
         this.disposeCaptureHook?.();
     }
     captureCurrentRoute(source) {
+        if (source === 'hmr-reboot') {
+            // Snapshot the live mirror first so the bootstrap can replay forward
+            // navigations to rebuild the back-stack. The pending single-URL slot
+            // remains useful as a fallback when the snapshot turns out to be empty
+            // (e.g. bootstrap-time HMR before the first NavigationEnd).
+            snapshotAngularHmrRouteHistory();
+        }
+        else if (source === 'bootstrap') {
+            // Seed the live mirror with the current URL so the very first HMR
+            // before any user navigation still has a stack of size one to snapshot.
+            //
+            // Skip empty / root URLs: at ENVIRONMENT_INITIALIZER time the router
+            // has not run its initial navigation yet so `router.url` is "/" (or
+            // an empty string). Pushing that here would seed the mirror with a
+            // noise entry that becomes the bottom of the next snapshot, which in
+            // turn becomes the next bootstrap's `START_PATH`. The router then
+            // boots to "/" → redirects to the real default route → fires an
+            // extra `NavigationEnd` that re-enters the replay path. The first
+            // genuine `NavigationEnd` arrives a moment later through the event
+            // subscription below and seeds the mirror with the real URL, so
+            // dropping the seed here is safe.
+            const seedUrl = this.router.url;
+            if (seedUrl && seedUrl !== '/') {
+                pushAngularHmrRouteHistoryEntry(seedUrl);
+            }
+        }
         return writeAngularHmrRouteState(this.router.url, {
             pending: source === 'hmr-reboot',
             source,
@@ -8020,10 +9708,6 @@ class NativeScriptAngularHmrRouteTracker {
     installCaptureHook() {
         return installAngularHmrRouteCaptureHook(() => this.captureCurrentRoute('hmr-reboot'));
     }
-    isHmrEnabled() {
-        const g = globalThis;
-        return !!g.__NS_DEV_PLACEHOLDER_ROOT_EARLY__ || typeof g.__reboot_ng_modules__ === 'function';
-    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.9", ngImport: i0, type: NativeScriptAngularHmrRouteTracker, deps: [{ token: i1$3.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.9", ngImport: i0, type: NativeScriptAngularHmrRouteTracker }); }
 }
@@ -8057,10 +9741,11 @@ class NativeScriptRouterModule {
                 NSRouteReuseStrategy,
                 { provide: RouteReuseStrategy, useExisting: NSRouteReuseStrategy },
                 NativeScriptAngularHmrRouteTracker,
+                NativeScriptAngularHmrRouteReplay,
                 {
                     provide: APP_BOOTSTRAP_LISTENER,
                     multi: true,
-                    deps: [NativeScriptAngularHmrRouteTracker],
+                    deps: [NativeScriptAngularHmrRouteTracker, NativeScriptAngularHmrRouteReplay],
                     useFactory: () => () => undefined,
                 },
             ],
@@ -8103,11 +9788,13 @@ function provideNativeScriptRouter(routes, ...features) {
         NSRouteReuseStrategy,
         { provide: RouteReuseStrategy, useExisting: NSRouteReuseStrategy },
         NativeScriptAngularHmrRouteTracker,
+        NativeScriptAngularHmrRouteReplay,
         {
             provide: ENVIRONMENT_INITIALIZER,
             multi: true,
             useValue: () => {
                 inject(NativeScriptAngularHmrRouteTracker);
+                inject(NativeScriptAngularHmrRouteReplay);
             },
         },
         // {provide: APP_BOOTSTRAP_LISTENER, multi: true, useFactory: getBootstrapListener},
@@ -8501,5 +10188,5 @@ function provideNativeScriptNgZone(options) {
  * Generated bundle index. Do not edit.
  */
 
-export { APP_ROOT_VIEW, ActionBarComponent, ActionBarScope, ActionItemDirective, AndroidFilterComponent, AppHostAsyncView, AppHostView, AppleFilterComponent, BasePortalOutlet, BaseValueAccessor, COMMON_PROVIDERS, CdkPortal, CdkPortalOutlet, CheckedValueAccessor, CommentNode, ComponentPortal, DEVICE, DISABLE_ROOT_VIEW_HANDLING, DateValueAccessor, DetachedLoader, DomPortal, ENABLE_REUSABE_VIEWS, EmulatedRenderer, FrameDirective, FramePageComponent, FramePageModule, FrameService, IOSFilterComponent, InjectableAnimationEngine, InvisibleNode, ItemContext, ListViewComponent, ModalDialogParams, ModalDialogService, NAMESPACE_FILTERS, NATIVESCRIPT_MODULE_PROVIDERS, NATIVESCRIPT_MODULE_STATIC_PROVIDERS, NATIVESCRIPT_ROOT_MODULE_ID, NATIVE_DIALOG_DATA, NATIVE_DIALOG_DEFAULT_OPTIONS, NSEmptyOutletComponent, NSFileSystem, NSLocationStrategy, NSRouteReuseStrategy, NSRouterLink, NSRouterLinkActive, NativeDialog, NativeDialogCloseDirective, NativeDialogConfig, NativeDialogModule, NativeDialogRef, NativeDialog as NativeDialogService, NativeModalRef, NativeScriptAnimationDriver, NativeScriptAnimationPlayer, NativeScriptAnimationsModule, NativeScriptCommonModule, NativeScriptDocument, NativeScriptDomPortalOutlet, NativeScriptFormsModule, NativeScriptHttpClientModule, NativeScriptLoadingService, NativeScriptModule, NativeScriptNgSafeEvent, NativeScriptNgZone, NativeScriptRendererFactory, NativeScriptRendererHelperService, NativeScriptRouterModule, NativeScriptSanitizer, NativescriptXhrFactory, NavigationButtonDirective, NgViewRef, NsHttpBackEnd, NsTemplatedItem, NumberValueAccessor, Outlet, PAGE_FACTORY, PREVENT_CHANGE_EVENTS_DURING_CD, PREVENT_SPECIFIC_EVENTS_DURING_CD, PageDirective, PageRoute, PageRouterOutlet, PageService, PlatformNamespaceFilter, Portal, PortalModule, RootCompositeModule, RootViewProxy, RouterExtensions, START_PATH, SelectedIndexValueAccessor, TEMPLATED_ITEMS_COMPONENT, TabViewDirective, TabViewItemDirective, TemplateKeyDirective, TemplatePortal, TextNode, TextValueAccessor, TimeValueAccessor, VisionOSFilterComponent, bootstrapApplication, createKeyframeAnimation, customFrameComponentFactory, customFrameDirectiveFactory, customPageFactory, customPageFactoryFromFrame, dashCaseToCamelCase, defaultNavOptions, defaultPageFactory, defaultPageFactoryProvider, detachViewFromParent, disableRootViewHanding, errorHandler, extractSingleViewRecursive, frameMeta, generateDetachedLoader, generateFallbackRootView, generateNativeScriptView, generateRandomId, generateRootLayoutAndProxy, getFirstNativeLikeView, getItemViewRoot, getSingleViewRecursive, getViewClass, getViewMeta, instantiateDefaultStyleNormalizer, instantiateSupportedAnimationDriver, isBlank, isContentView, isDetachedElement, isInvisibleNode, isJsObject, isKnownView, isLayout, isListLikeIterable, isPresent, isView, onAfterLivesync, onBeforeLivesync, once, platformNativeScript, platformNativeScriptDynamic, postAngularBootstrap$, preAngularDisposal$, provideLocationStrategy, provideNativeScriptHttpClient, provideNativeScriptNgZone, provideNativeScriptRouter, registerElement, registerNativeScriptViewComponents, rootRoute, runNativeScriptAngularApp, throwIfAlreadyLoaded, throwNoPortalAttachedError, throwNullPortalError, throwNullPortalOutletError, throwPortalAlreadyAttachedError, throwPortalOutletAlreadyDisposedError, throwUnknownPortalTypeError, COMPONENT_VARIABLE as ɵCOMPONENT_VARIABLE, CONTENT_ATTR as ɵCONTENT_ATTR, HOST_ATTR as ɵHOST_ATTR, NativeScriptDebug as ɵNativeScriptAngularDebug, viewUtil as ɵViewUtil, actionBarMeta as ɵactionBarMeta, elementMap as ɵelementMap, isActionItem as ɵisActionItem, isNavigationButton as ɵisNavigationButton };
+export { APP_ROOT_VIEW, ActionBarComponent, ActionBarScope, ActionItemDirective, AndroidFilterComponent, AppHostAsyncView, AppHostView, AppleFilterComponent, BasePortalOutlet, BaseValueAccessor, COMMON_PROVIDERS, CdkPortal, CdkPortalOutlet, CheckedValueAccessor, CommentNode, ComponentPortal, DEVICE, DISABLE_ROOT_VIEW_HANDLING, DateValueAccessor, DetachedLoader, DomPortal, ENABLE_REUSABE_VIEWS, EmulatedRenderer, FrameDirective, FramePageComponent, FramePageModule, FrameService, IOSFilterComponent, InjectableAnimationEngine, InvisibleNode, ItemContext, ListViewComponent, ModalDialogParams, ModalDialogService, NAMESPACE_FILTERS, NATIVESCRIPT_MODULE_PROVIDERS, NATIVESCRIPT_MODULE_STATIC_PROVIDERS, NATIVESCRIPT_ROOT_MODULE_ID, NATIVE_DIALOG_DATA, NATIVE_DIALOG_DEFAULT_OPTIONS, NSEmptyOutletComponent, NSFileSystem, NSLocationStrategy, NSRouteReuseStrategy, NSRouterLink, NSRouterLinkActive, NativeDialog, NativeDialogCloseDirective, NativeDialogConfig, NativeDialogModule, NativeDialogRef, NativeDialog as NativeDialogService, NativeModalRef, NativeScriptAnimationDriver, NativeScriptAnimationPlayer, NativeScriptAnimationsModule, NativeScriptCommonModule, NativeScriptDocument, NativeScriptDomPortalOutlet, NativeScriptFormsModule, NativeScriptHttpClientModule, NativeScriptLoadingService, NativeScriptModule, NativeScriptNgSafeEvent, NativeScriptNgZone, NativeScriptRendererFactory, NativeScriptRendererHelperService, NativeScriptRouterModule, NativeScriptSanitizer, NativescriptXhrFactory, NavigationButtonDirective, NgViewRef, NsHttpBackEnd, NsTemplatedItem, NumberValueAccessor, Outlet, PAGE_FACTORY, PREVENT_CHANGE_EVENTS_DURING_CD, PREVENT_SPECIFIC_EVENTS_DURING_CD, PageDirective, PageRoute, PageRouterOutlet, PageService, PlatformNamespaceFilter, Portal, PortalModule, RootCompositeModule, RootViewProxy, RouterExtensions, START_PATH, SelectedIndexValueAccessor, TEMPLATED_ITEMS_COMPONENT, TabViewDirective, TabViewItemDirective, TemplateKeyDirective, TemplatePortal, TextNode, TextValueAccessor, TimeValueAccessor, VisionOSFilterComponent, bootstrapApplication, createKeyframeAnimation, customFrameComponentFactory, customFrameDirectiveFactory, customPageFactory, customPageFactoryFromFrame, dashCaseToCamelCase, defaultNavOptions, defaultPageFactory, defaultPageFactoryProvider, detachViewFromParent, disableRootViewHanding, errorHandler, extractSingleViewRecursive, frameMeta, generateDetachedLoader, generateFallbackRootView, generateNativeScriptView, generateRandomId, generateRootLayoutAndProxy, getAngularHmrRestoringRoute, getFirstNativeLikeView, getItemViewRoot, getSingleViewRecursive, getViewClass, getViewMeta, instantiateDefaultStyleNormalizer, instantiateSupportedAnimationDriver, isAngularHmrRestoringRoute, isBlank, isContentView, isDetachedElement, isInvisibleNode, isJsObject, isKnownView, isLayout, isListLikeIterable, isPresent, isView, onAfterLivesync, onBeforeLivesync, once, platformNativeScript, platformNativeScriptDynamic, postAngularBootstrap$, preAngularDisposal$, provideLocationStrategy, provideNativeScriptHttpClient, provideNativeScriptNgZone, provideNativeScriptRouter, registerElement, registerNativeScriptViewComponents, rootRoute, runNativeScriptAngularApp, throwIfAlreadyLoaded, throwNoPortalAttachedError, throwNullPortalError, throwNullPortalOutletError, throwPortalAlreadyAttachedError, throwPortalOutletAlreadyDisposedError, throwUnknownPortalTypeError, COMPONENT_VARIABLE as ɵCOMPONENT_VARIABLE, CONTENT_ATTR as ɵCONTENT_ATTR, HOST_ATTR as ɵHOST_ATTR, NativeScriptDebug as ɵNativeScriptAngularDebug, viewUtil as ɵViewUtil, actionBarMeta as ɵactionBarMeta, elementMap as ɵelementMap, isActionItem as ɵisActionItem, isNavigationButton as ɵisNavigationButton };
 //# sourceMappingURL=nativescript-angular.mjs.map